HTML5 Ad Disapproved in Google Ads: Causes and Fixes
A disapproved HTML5 ad usually comes down to a short list of causes: the exit link, the size declaration, the ZIP structure, outside requests, or policy. Here is how to find yours and fix it.
Key takeaways - Many HTML5 disapprovals trace back to a short list of causes: the exit link, the size declaration, the ZIP structure, external requests, or a content policy issue. - Read the exact reason shown on the disapproved ad before changing anything. Guessing wastes review cycles. - In most cases you fix the source, rebuild the ZIP, and upload a new ad instead of patching the old one. - Test the exact ZIP you plan to upload, offline and in a clean browser profile, before you submit it. - Appeal only when you have checked the ad and believe the stated reason does not apply.
Start with the stated reason
When an HTML5 ad is disapproved, Google Ads shows a status and a reason next to it. Open it and read the whole message. The wording usually points to one of two kinds of problem:
- Technical: the file doesn't meet the format requirements, so it can't be validated or can't be shown.
- Policy: the file works, but its content, behavior, or destination breaks an advertising policy.
They need different fixes. A technical problem is solved by editing the package. A policy problem may mean changing how the ad behaves or what it promises.
The current rules live in the Google Ads policy center. Read the entry for your specific violation. Details change over time, so treat that page as the source of truth over any blog post, including this one.
Cause 1: the exit link doesn't work
The most common technical problem is the click-through. In Display campaigns, the ad is expected to send clicks through the clickTag variable so the platform controls the destination URL. If your code hard-codes a URL or reads the variable incorrectly, the ad can be flagged or simply fail to register clicks.
Typical mistakes:
- The variable name doesn't match what the spec expects, for example the wrong letter case.
- The click handler is attached to one button, so the rest of the ad does nothing when tapped.
- The code calls
window.openwith a fixed address instead of using the supplied variable. - The variable is defined on the page but never reaches the code that handles taps.
The fix is to define the variable exactly as the spec describes, then route every intended tap through it. Our clickTag for Display HTML5 checklist covers the details.
App campaigns work differently. They use an exit API call rather than a clickTag, and mixing the two up is a classic reason for a good file to be rejected. If you build for App campaigns, read ExitApi in App campaigns.
Cause 2: the size isn't declared or doesn't match
For Display uploads, the ad generally needs to declare its own dimensions in the HTML head. This is done with a meta tag named ad.size, whose content value states the width and height. Copy the exact syntax from the network's current spec instead of writing it from memory.
Problems appear when:
- The tag is missing or malformed.
- The declared size doesn't match the size you picked when uploading.
- The layout is built for one size but declared as another, so content is cropped or leaves empty space.
After checking the tag, confirm that the visible layout fills exactly the declared area, with no scrollbars and no elements hanging past the edge. Check the list of supported sizes in the current spec as well.
Cause 3: the package is built wrong
Validators open your ZIP and look for a specific structure. These things break it:
- A nested folder. If the archive contains one folder that holds
index.html, the validator may not find the entry file. The main HTML file belongs at the root of the archive. - Case mismatches.
Logo.pngandlogo.pngare different files on many servers, even if your laptop treats them as the same. - Missing files. A reference to an image or script that isn't in the archive fails silently on your machine if it is cached.
- Too many or oversized files. Both total size and file count are limited. Check the current limits in the network's spec rather than guessing. Unminified code and uncompressed audio are the usual culprits.
- Unsupported file types left in the archive, such as source project files or hidden system files created by your operating system.
Before uploading, unzip your own archive into a fresh folder and open the entry file from there. If it doesn't work for you, it won't work for the reviewer. The full upload path is in How to upload an HTML5 ZIP to Google Ads.
Cause 4: the ad calls things outside the ZIP
HTML5 ads for Google Ads are expected to be self-contained. Disapprovals often follow when the ad:
- Loads images, fonts, scripts, or video from your own server or a third-party host.
- Pulls a library from a public CDN the network doesn't allow.
- Makes background calls to analytics or tracking endpoints that this format doesn't permit.
This is easy to miss because everything works on your machine, where those resources are reachable. The test is simple. Open your browser's developer tools, switch to the network panel, reload the ad, and read every request. Anything pointing outside your package is a candidate for removal, or for bundling into the ZIP.
Check the network's current spec for which external calls, if any, are allowed. Don't assume that what worked in another format works here.
Cause 5: behavior the format doesn't allow
Some code patterns are risky in an ad context. They can break rendering in the review environment, or they can look like deceptive behavior:
- Automatic redirects that send the user away without a tap.
- Dialogs such as
alertorconfirm. - Reliance on cookies or local storage, which sandboxed ad frames often block. The ad may crash on load instead of degrading gracefully.
- Heavily obfuscated code that a scanner can't tell apart from something malicious. Minifying is fine. Aggressive obfuscation is not worth the risk.
Playable ads need extra care, since they carry far more code than a static banner. If yours is a playable, run through the Playable HTML5 QA checklist before you upload.
Cause 6: policy problems in the content
Sometimes the package is technically perfect and the ad is still disapproved. Typical policy-side triggers include:
- Misleading claims or fake interface elements. A fake system notification, a fake close button, or a button that looks interactive but does nothing can all read as deceptive.
- Gameplay that doesn't resemble the product. If the ad shows a game that the app doesn't offer, expect trouble from reviewers and from users.
- Landing destination mismatches. The store page or site you send people to should match what the ad promises.
- Restricted content categories. Some subjects need certification or extra review, and the ad may be limited or blocked in certain regions.
- Flashing or disruptive motion that harms the experience.
For these, editing the package isn't enough. Change the creative itself, then check the policy page for the category that was cited.
A practical fix-and-resubmit workflow
- Record the reason. Copy the exact disapproval text into your notes.
- Reproduce the problem locally. Unzip the archive you uploaded, not your working folder.
- Change one category of problem at a time. If you alter the exit link, the size tag, and the file structure in one go, you won't know which change mattered.
- Test offline. Disconnect from the network, open the entry file, and tap through the whole ad. Anything that breaks was depending on an outside resource.
- Test in a clean profile. A fresh browser profile with no extensions and no cache shows what a reviewer sees.
- Rebuild the ZIP from scratch. Don't update the old archive in place, because stray files get carried along.
- Upload as a new ad and keep the old one's reason for reference until the new one is approved.
If you generate your playable from a store listing, a tool like PlayableRun can export the ZIP for you. You still need to run the same checks on the output, as the review guide for generated playables explains.
When to appeal
An appeal makes sense when you have verified the ad against the cited policy and the reason clearly doesn't apply. It does not make sense as a first reaction. If the message names a technical defect and you can find that defect, fix it and resubmit. It is faster than waiting on an appeal.
When you do appeal, be specific. State which policy was cited, which part of the ad you checked, and why it complies. A short factual note is easier to review than a long argument.
Prevent the next disapproval
Most repeat rejections happen because the checks live in someone's head. Write a short pre-upload list and use it every time:
- The entry file is at the archive root.
- The exit mechanism matches the campaign type.
- The declared size matches the upload size and the layout.
- No requests leave the package.
- No dialogs, redirects, or storage dependencies.
- The ad was tested offline from the final ZIP.
A list this short takes minutes to run and saves a review cycle each time it catches something.
If you'd like to see how a finished playable behaves before you build your own, browse the live demos. When you are ready to try the export flow, a free account is enough to start, and the checks above still apply to whatever you upload.
Frequently asked questions
›Can I edit an HTML5 ad after it is disapproved?
In most cases you fix the source files, rebuild the ZIP, and upload it as a new ad rather than patching the old one. Remove the disapproved ad once the replacement is approved so your account stays tidy.
›How do I find out why my HTML5 ad was rejected?
Open the ad's status in Google Ads and read the stated reason in full. It usually tells you whether the problem is technical (format, package, exit link) or a policy issue (content, behavior, destination).
›Why does my HTML5 ad work locally but fail in review?
Local tests hide missing files, case-sensitive paths, and external requests that only work on your machine or network. Unzip the exact archive into a clean folder, go offline, and test in a fresh browser profile.
›Should I appeal a disapproval or just fix the ad?
If you found a real defect, fix it and upload a new version. Appeal only when you have checked the ad against the cited policy and believe the reason does not apply.
›Is the clickTag the same as the exit API?
No. Display campaigns use a clickTag variable for the click-through, while App campaigns use an exit API call. Using the wrong one for the campaign type is a common cause of rejection.
Turn your store listing into a playable
Paste an App Store or Google Play link and get an HTML5 playable you can test in minutes. The first one is free.
Keep reading
- Google Ads HTML5
HTML5 Display Ads vs App Campaigns: Different Code
7 min read
- Google Ads HTML5
Google Ads HTML5 Eligibility: Get Your Account Ready
7 min read
- Google Ads HTML5
Self Contained HTML5 Ad: No CDNs, No Web Fonts
8 min read