Playable Ad Specs: What to Check Before You Export
Playable ad specs differ by network, and most rejections come from a handful of predictable mismatches. Here is what to check before you export, and why each check matters.
Key takeaways - Playable ad specs vary by network in packaging, click handling, size measurement and blocked features. A build that passes on one network can fail on another without any change to the gameplay. - Most rejections come from the wrapper, not the creative: the entry file, the store-click call, external requests and orientation. - Never rely on a number you remember. Limits change, so read the network's current spec page before every export. - Test the exported package, not the source project, in a clean browser and on a real phone. - Keep the creative separate from the network-specific wrapper so one playable can ship to several networks with small changes.
Why playable ad specs trip people up
A playable ad is a small web page that runs inside an ad container. The page itself is usually not the problem. The trouble is that every network wraps that page differently. One wants a single HTML file. Another wants a ZIP with a specific entry file. A third expects the ad to talk to the host app through a standard API.
So "the playable works" and "the playable is accepted" are two separate facts. The first is about your creative. The second is about whether the package matches what a particular network's reviewer, validator and SDK expect.
If you are new to the format, What Is a Playable Ad? covers the basics. This article assumes you already have a build and want to avoid avoidable rejections.
Start with the package format
Before anything else, decide what the network actually ingests. The common options are:
- A single self-contained HTML file, with scripts, styles and assets inlined.
- A ZIP archive containing an entry HTML file plus supporting files.
- A hosted URL that the network loads, which is less common for playables.
Check three things about the package:
- Entry file name and location. Many validators look for a specific file at the root of the archive. A nested folder is a classic cause of "no entry file found" errors.
- Relative paths. Assets must resolve from inside the package. A path that worked on your local machine because of a dev server often breaks once zipped.
- No stray files. Source maps, hidden system files and unused assets add weight and sometimes trigger validation warnings.
For Google Ads in particular, the upload flow and policy checks have their own quirks. How to upload an HTML5 ZIP to Google Ads walks through them.
File size: check the limit and the way it is measured
Playable ad file size is the spec people remember best and verify least. Two points matter.
First, the maximum differs between networks and changes over time. I am deliberately not quoting numbers here, because a number copied from a blog post is how a team ends up exporting against an outdated limit. Open the network's current specification page and read the exact figure.
Second, find out what is being measured. Some validators check the compressed archive, others check the total unpacked size, and some count the size of individual files. A playable that squeaks under the compressed limit can still fail an unpacked check.
Even when you are under the limit, smaller is better in practice. The user is waiting for a page to load inside an ad slot, and a slow start means fewer people ever touch the playable. The usual savings come from:
- Compressing and resizing textures to the size they are actually displayed.
- Using one font file, subset to the characters you need, instead of several.
- Replacing long audio with short loops, or dropping music entirely.
- Removing game-engine modules you never call.
Leave some headroom under the limit. A late fix to the end card should not push the build over.
Click handling is the most common failure
Every playable must send the user to the store. How it does so depends on the network, and this is where most rejections originate.
- Google Ads display HTML5 has historically relied on a
clickTagvariable. See clickTag for Display HTML5 for the details. - Google Ads App campaigns use a different call to open the store. ExitApi in App campaigns explains what it does and how it differs from clickTag.
- Many in-app networks use MRAID, an open standard from IAB Tech Lab, where the ad calls an
openfunction on the host. The MRAID specification is the reference. - Some networks supply their own wrapper or SDK call and document it on their developer pages.
Two mistakes recur. The first is hard-coding a store URL in the ad, which most networks forbid because they need to control tracking and attribution. The second is wiring the call to only one element, such as the end-card button, when the network requires that any tap meant to convert goes through the same function. Test every clickable area.
Orientation, sizing and safe areas
A playable runs inside a container whose dimensions you do not control. Check these before export:
- Orientation. Does the network serve portrait, landscape or both? If both, does your layout adapt on resize, or does it only handle the orientation you designed in?
- Responsive scaling. Use the viewport and container size at runtime rather than fixed pixel values. Fixed layouts are what break on unusual phones and tablets.
- Safe areas. Notches, rounded corners and the close button overlay can cover your UI. Keep the call to action and any key control away from the edges.
- Aspect-ratio extremes. Test on a tall narrow phone and on a tablet, not just the device on your desk.
If a network asks for specific dimensions for a given placement, take them from its spec page rather than from memory.
Blocked features and external requests
Ad containers are restrictive on purpose. Many run the ad inside a sandboxed frame, which limits what scripts can do. MDN's page on the iframe element and its sandbox attribute explains the general mechanism, though each network applies its own rules.
Things that commonly cause problems:
- External network requests. Loading fonts, scripts, analytics or images from another domain is often blocked or flagged. Bundle what you need inside the package.
- Local storage and cookies. Not reliably available in a sandboxed frame. Code that assumes they exist can crash on load.
- Pop-ups, redirects and
window.open. Usually prohibited. Store navigation should go through the approved click call only. - Autoplay audio. Browsers and apps restrict it. Start sound only after a user gesture, and make sure the playable still makes sense muted.
- Heavy WebGL or unusual APIs. Older devices may not support them. Have a fallback or keep the visuals simple.
If an upload to Google Ads comes back disapproved, HTML5 Ad Disapproved in Google Ads maps the common messages to causes.
Duration and interaction rules
Some networks define how long a playable should run, whether it needs an end card, or how soon the user can interact. If a limit exists, it will be on the network's spec page. Check it rather than assuming.
Whatever the rule, the design guidance holds: the user should understand what to do almost immediately, and the end card should appear after a short, complete loop. Playable Ad Best Practices covers the tutorial, core loop and end-card structure.
A pre-export checklist you can reuse
Run through this list on every build, for every network:
- Open the target network's current spec page and note package format, size limit, click method and any blocked features.
- Confirm the entry file is named and placed as the network expects.
- Check size against the limit, using the same measurement the network uses.
- Verify the click call matches the network and that every tappable conversion area uses it.
- Search the build for external URLs and remove or bundle them.
- Test orientation and resize on at least two screen shapes.
- Test muted and unmuted, with no sound before first interaction.
- Unzip and run the exported package in a clean browser profile, then on a real phone.
- Run it through the network's own preview or validator, if one exists.
For Google Ads, Playable HTML5 QA checklist goes deeper on the last few steps.
Keep the creative and the wrapper separate
The practical way to handle many networks is to treat the playable as two layers. The creative holds the gameplay, art and end card. The wrapper holds the network-specific parts: the entry file, the click call and the packaging.
When the creative stays stable and only the wrapper changes per network, you test the gameplay once and re-test only the integration points. Tools that export network-ready packages can handle the wrapper for you. PlayableRun, for example, produces a Google Ads-ready ZIP, but you should still verify the result against the network's current spec before you submit. For other networks, confirm the required format on their documentation pages first.
Also keep a short internal note per network: package format, click method, last date you checked the spec page. Specs change quietly, and a dated note tells you when your knowledge is stale.
Where to go from here
Specs are boring, but a rejected upload costs you a day of back and forth, and a day is hard to recover when you are trying to test creatives. If you want a faster way to see what a finished playable looks like before you build your own, browse the live demos. If you would rather generate one from your store listing and test the export yourself, you can create a free account.
Frequently asked questions
›Do all ad networks use the same playable ad specs?
No. Networks share a common base of HTML5, CSS and JavaScript, but they differ in package format, how the store click is triggered, how file size is measured and which features are blocked. Treat each network's current spec page as the source of truth.
›What is the most common reason a playable gets rejected?
Click handling and package structure. A missing or misnamed click call, an entry file in the wrong place, or an external request the network blocks are the usual causes. Most of these are found by testing the exported package, not the source project.
›Does playable ad file size really matter?
Yes, for two reasons. Networks enforce a maximum, and a heavy playable loads slowly, so users may leave before they can interact. Check the current limit in the network's documentation and leave some headroom.
›Do I need MRAID for every network?
No. MRAID is an IAB Tech Lab standard that many in-app networks use for communication between the ad and the app. Google Ads App campaigns use a different mechanism for the store click. Check which one your target network expects.
›Can I reuse one playable build across networks?
Often the gameplay and assets can be reused, but the packaging and click wiring usually need to change per network. Keep the creative separate from the network wrapper so you only rebuild the wrapper.
Sources
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
- Ad network specs
Playable Ad Multiple Networks: One Build, Many Exports
6 min read
- Ad network specs
TikTok Playable Ads: Short Attention, Instant Mechanic
7 min read
- Ad network specs
Single File HTML Playable: Why Networks Want It Inline
7 min read