Playable Ad Multiple Networks: One Build, Many Exports
Rebuilding a playable for every network wastes time and lets versions drift apart. Keep one creative core, isolate the network-specific parts, and package each export from the same source.
Key takeaways - Treat a playable as one creative core plus a thin network adapter. Only the adapter should know which network it runs on. - Most cross-network bugs come from the same few places: the click-out call, lifecycle events, audio start, sizing and file packaging. - Budget file size and external requests against the strictest network you plan to run, then export downward. - Build every export from one source and never hand-edit exported files, or versions will drift. - Test each export in that network's own preview tool. A build that works in your browser has proven very little.
Why one build per network goes wrong
The usual path is understandable. You ship a playable on one network, it works, and a colleague asks for it on another. Someone copies the project, changes a few lines, and exports. A month later you have several near-identical playables with different bugs, and nobody remembers which one has the fixed tutorial hint.
The problem is not the copying. It is that the creative and the delivery format get mixed together, so every change to one forces edits to the other.
A better question is: what do I actually need to change when the destination changes? The answer is usually small. The game stays the same. The wrapper around it changes.
Split the playable into three parts
Think of the project as three layers.
- Creative core. Mechanic, level, art, sound, copy, and end card. This is what your audience sees and what you test creatively.
- Network adapter. A small module that exposes a few neutral actions to the core and maps them to the network's expectations.
- Packaging. How the result is bundled: a single inlined HTML file, a ZIP with several files, required meta tags or scripts, and naming.
The core should never call a network function directly. It calls something like "open the store" or "the player finished." The adapter decides what that means on this network.
This is the same reasoning behind the standard interface many networks use. If you want the background, MRAID for Playable Ads: What Marketers Need to Know covers it, and the IAB Tech Lab MRAID page is the official reference. MRAID helps, but not every network relies on it alone, which is why an adapter layer pays off.
What should be shared, and what should not
Share everything the player experiences:
- The core mechanic and its tuning
- Art, animation and audio assets
- Tutorial hints and timing
- The end card layout and call to action text
Keep these per network, inside the adapter or the packaging step:
- Click-out. Some networks expect an MRAID open call. Others expect their own function or a required script. Wire this in one place.
- Lifecycle signals. Networks may want to know when the creative is loaded, started, or finished. Naming and timing differ.
- Audio start. Some placements start muted or require a user gesture before sound. The core should handle both cases without errors.
- Viewport and orientation. The container may resize, rotate, or load before it has a final size.
- Bundle format. Single file versus multi-file ZIP, and which meta tags or scripts the network requires.
If you are unsure why networks care so much about inlining, Single File HTML Playable: Why Networks Want It Inline explains it.
Design the adapter as a tiny contract
You do not need a framework. Define a handful of neutral actions the core can call and a few events the adapter can send back:
- Core to adapter: ready, started, finished, open store.
- Adapter to core: the container is visible, the size changed, sound is allowed or blocked, pause or resume.
Then write one adapter per target. A development adapter that just logs to the console is worth having too. It lets you test the core in a plain browser tab without any network code.
Two details save a lot of pain:
- Make the click-out idempotent. Players tap repeatedly. The adapter should debounce so one intent doesn't produce several store opens or duplicate click events.
- Never assume the ad API exists. Check for it and wait for it to be ready before starting. A creative that throws an error on a missing global will simply show nothing.
If you need to pass information between frames or windows during testing, [postMessage on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) is the standard reference.
Budget for the strictest network
Size limits, allowed external requests, and file counts all differ. Rather than memorizing them, pick the strictest network on your plan and build to that.
Practical consequences:
- Compress images and audio at the source, and drop assets the first seconds of play don't need.
- Avoid external fonts, scripts and media unless you have confirmed the network allows them.
- Keep the end card lightweight. It is part of the file too.
Because limits change, don't copy numbers from a blog post, including this one. Playable Ad Specs: What to Check Before You Export lists what to verify, and each network's current documentation is the source of truth.
Build exports from one source
The most important operational rule is that exported files are outputs, not sources. Treat them like compiled binaries.
- Keep one project that builds every target.
- Put the network and version in the file name, for example
puzzle-hint-v3-networkname.zip. - When someone finds a bug, fix it in the source and re-export all targets that are live.
- Keep a short changelog so media buyers know which creative version is running where.
This is boring, and that is the point. Drift is the real cost of multi-network work, and it is mostly a bookkeeping problem.
Test each export where it will run
A playable that works in desktop Chrome can still fail inside a network's preview. Make a short checklist and run it on every export:
- Loads without console errors and without blocked requests
- Starts the first interaction without extra taps
- Plays acceptably with sound off and with sound on
- Works in both orientations, or locks cleanly to the one you intend
- Opens the correct store page from every call to action, including the end card
- Doesn't open the store twice on a double tap
- Handles being paused and resumed
Then use the network's own preview or test tool for the final check. Several networks also have creative review steps with their own rules, so read their guidelines before you submit rather than after a rejection. The Unity Ads and AppLovin checklists on this blog go into those details.
Know when not to reuse
Some destinations are different enough that reuse stops being efficient. Meta's playable format and review flow differ from ad network SDK placements, and short-form video environments reward a faster first interaction than a typical in-game placement. Meta Playable Ads: How They Differ From Ad Networks and TikTok Playable Ads: Short Attention, Instant Mechanic cover what changes.
Even then, reuse what you can: assets, the mechanic, the copy. Change the pacing, the tutorial, or the end card for the context.
Where a tool fits
If your bottleneck is producing the core playable in the first place, a generator can help. PlayableRun turns an App Store or Google Play listing into an HTML5 playable and exports a Google Ads-ready ZIP. For other networks, you will still need to check their requirements and adapt the packaging. The strategy above applies either way.
A practical rollout order
- Build or pick one core playable and make it solid on one network.
- Extract the click-out and lifecycle code into an adapter.
- Add a development adapter for browser testing.
- Add the second network as a new adapter and packaging step, not a copy of the project.
- Run the checklist on both exports and record the version in your naming.
- Only then add more networks.
This order keeps the first launch simple and makes the second one a small job instead of a rewrite.
If you want to see what a finished playable looks like before planning your packaging, browse the live demos, or create a free account and try it with your own listing.
Frequently asked questions
›Can I run the exact same playable file on every ad network?
Rarely. The gameplay and assets can be identical, but click-out calls, lifecycle events, packaging format and size rules differ between networks. Share the creative core and generate a separate export for each network.
›What is the difference between a creative core and a network adapter?
The core is the game logic, art, audio and end card. The adapter is a thin layer that translates the core's actions (ready, started, finished, open the store) into whatever the network expects. Keep network-specific code only in the adapter.
›Which network's spec should I build to first?
The strictest one you plan to run, for file size, external requests and behavior. A build that passes the tightest spec usually passes looser ones, though you still need to test each export.
›Should I reuse the same playable on Meta and ad networks?
Reuse the idea and assets, but expect to repackage. Meta has its own playable requirements and review flow, so treat it as a separate export target rather than another wrapper.
›How do I keep versions from drifting between networks?
Build every export from one source repository or project, tag each release, and put the version in the file name. Never hand-edit an exported file; change the source and re-export.
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
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
- Ad network specs
Unity Ads Playable: Creative Formats and QA Checklist
6 min read