MRAID for Playable Ads: What Marketers Need to Know
MRAID is the small contract that lets a playable ad talk to the app that displays it. You don't need to write the code, but you do need to know where it tends to break.
Key takeaways - MRAID is a small JavaScript contract between your HTML5 ad and the SDK that displays it. It governs when the ad starts, how clicks leave the ad, and how it closes. - Most MRAID problems are lifecycle or click problems: the ad starts before it is visible, or the install button never reaches the store. - Not every network uses MRAID. Google Ads and Meta have their own conventions, so one build rarely fits every network unchanged. - A playable that works in a desktop browser proves very little. Test it in the network's own preview tool. - You don't need to write the code, but you should know which questions to ask your creative team or tool.
What MRAID is, in plain terms
A playable ad is a small web page. On an in-app network, that page is shown inside a web view that lives inside someone else's game or app. The page needs a way to ask the host a few questions and make a few requests:
- Are you ready for me to start?
- Is the user actually looking at me right now?
- Please open this store link.
- Please close me.
MRAID (Mobile Rich-media Ad Interface Definitions) is the standard vocabulary for those questions and requests. It is maintained by IAB Tech Lab, and the official MRAID page links to the specification itself.
In practice, the SDK exposes an object called mraid to your page. Your ad calls functions on it and listens for events from it. If the ad follows the contract, any compliant SDK can run it. If it ignores the contract, it may still render, but it will behave unpredictably.
Why a marketer should care
You probably won't write MRAID code. But MRAID problems show up as marketing problems:
- Wasted impressions. The ad starts its tutorial while the SDK is still loading it, so the user sees the middle of the experience or nothing at all.
- Dead install buttons. The tap fires, but the SDK never receives a valid request to open the store. The user taps, nothing happens, and the install is lost.
- Rejected creatives. Network review runs the ad in a test harness. If the ad doesn't respond the way the spec expects, it gets bounced.
- Misleading test results. If one network's wrapper handles your ad badly, the numbers for that placement say little about the creative itself.
Knowing the basics lets you work out which of these you are looking at before you open a support ticket.
The parts of MRAID that matter for playables
The full specification covers a lot, including expandable banners, resizing, calendar events and more. A playable touches only a handful of it.
1. Ready: when the ad may start
The SDK loads your page, then signals when the MRAID environment is available. A well-behaved ad checks whether mraid exists and looks at its state. If it isn't ready yet, the ad waits for the ready event before doing anything that depends on the host.
Why this matters: if the ad calls MRAID functions too early, they fail silently or throw errors. The usual symptom is an ad that works on a fast test device and breaks on a slow one.
2. Viewable: when the ad should actually begin
Being loaded is not the same as being on screen. MRAID provides a viewability check and a viewableChange event. Many playables wait until the ad is viewable before starting the intro animation, the timer or the audio.
Why this matters: a playable that starts while hidden may burn through its tutorial before the user sees it. It can also play sound over a game the user is still in. For general page-visibility behavior in browsers, MDN's visibilitychange reference is useful background on pausing work when a page is hidden.
3. Open: how the click leaves the ad
This is the most important function for performance. The install button should call mraid.open() (or whatever the network instructs), not just change window.location or use a plain link the way a normal web page would.
Why: the SDK needs to own the click so it can track it, attribute it and hand the user to the correct store. A plain link inside a web view may be blocked, may open the wrong place, or may never be counted.
In many setups the destination isn't hardcoded in the ad. The network supplies it from the campaign settings. Your ad's job is to trigger the call at the right moments, not to decide where it goes. Ask which behavior each target network expects.
4. Close and the end card
Some networks draw their own close button around the ad. Others expect the playable to handle it. The spec includes a close function, and guidance on custom close buttons has changed between versions, so what a network wants today may differ from older tutorials.
Why this matters: a double close button looks sloppy, and no close button at all can break network policy. Our article on designing the end card covers what the final screen should do once the interaction ends.
5. Sizing and orientation
MRAID lets the ad ask about screen and maximum sizes, and some networks pass orientation information. A playable that assumes one fixed layout can look broken on a different device shape.
Why: the web view isn't always the full screen, and notches, system bars and rotation all change the usable area. A layout that adapts to the space it is given is safer than one that assumes a size.
Where MRAID does not apply
MRAID is common across in-app ad networks, but it is not universal:
- Google Ads HTML5 ads use their own click-handling method. If you build for it, read Exit API vs clickTag and check Google's current HTML5 requirements.
- Meta playable ads have their own format and submission process, not an MRAID wrapper in the usual sense.
- Individual networks sometimes add their own requirements on top of MRAID, such as a specific way to signal that the ad has finished, or limits on external requests.
Why this matters: the same creative can need small, network-specific changes. If you are exporting for Google Ads, PlayableRun produces a Google Ads-ready ZIP, but for any other network you should still read that network's current spec and confirm what the ad must call.
Questions to ask your team or tool
You don't have to read the code to hold a useful conversation. Ask:
- Which networks is this build intended for? "All of them" is a warning sign.
- How does the ad wait for the ready state? It should not assume the host is there at load time.
- When does the intro or timer start? The right answer ties to viewability, not just page load.
- What happens when the user taps install? You want a call that goes through the SDK, with the destination coming from the network where required.
- Who draws the close button? The ad or the network, and does that match the network's policy?
- Has it been tested inside the network's own preview tool?
Testing: where the real answers are
MRAID bugs rarely appear in a desktop browser, because there is no SDK on the other end. The page loads, the animation runs and everything looks fine. Then the ad goes into a real web view and the install tap does nothing.
A sensible test pass has three layers:
- Browser check for layout, assets and general behavior. Useful, but only a first filter.
- Network preview or test tool for the real lifecycle, click handling and close behavior. Most networks that accept playables provide one.
- Real devices at least one slower and one newer, because timing bugs show up on slow hardware first.
For a fuller list, use the playable ad QA checklist before you upload.
Also keep your reading of results honest. If one network shows poor engagement while others look healthy, consider whether the wrapper, not the creative, is the problem before you pause the concept.
Common mistakes
- Treating a working browser preview as proof. It only shows the page loads.
- Hardcoding the store URL when the network injects it. This can break tracking or violate the network's rules.
- Autoplaying audio at load. The ad may start while the user is still in the host game.
- Building one file for every network and never checking the differences. Small mismatches add up to rejections.
- Ignoring older guidance changes. Tutorials written for earlier versions of the spec may describe behavior networks no longer want.
A short summary
MRAID is plumbing. When it works, nobody notices. When it doesn't, you see dead taps, ads that start at the wrong moment and creatives that fail review. Knowing the four basic moments (ready, viewable, open, close) is enough to ask good questions and to tell a creative problem from an integration problem.
If you want to see what finished playables look like before you worry about network wrappers, browse the live demos, or create a free account and try one with your own listing.
Frequently asked questions
›What does MRAID stand for?
Mobile Rich-media Ad Interface Definitions. It is a standard maintained by IAB Tech Lab that defines how an HTML5 ad communicates with the mobile SDK displaying it.
›Do all ad networks require MRAID for playable ads?
No. Many in-app networks build on it, but Google Ads and Meta have their own conventions for HTML5 and playable formats. Always check the target network's current documentation before exporting.
›Why does my playable work in a browser but not in the network preview?
A desktop browser has no MRAID host. The ad may never receive the ready or viewable signals, and its click may use a normal link instead of the SDK's open call. The network's own preview tool reproduces the real environment.
›Do I need to write MRAID code myself?
Usually not. Your creative team or tool handles it. You should know the right questions, such as how the ad waits for the ready state, and how the install click leaves the ad.
›What is the most common MRAID problem in playable ads?
Click handling. If the install button does not go through the SDK's open request, the tap may do nothing, open the wrong place or never be counted.
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