AppLovin Playable Ad: The Review Checklist

Most playable rejections come from a small set of avoidable problems: a broken CTA, a bloated package, or an ad that doesn't match the app. Here is a checklist to run before you submit to AppLovin.

By the PlayableRun team··7 min read

Key takeaways - Most playable rejections come from a few avoidable issues: a call to action that fails, a package that is too heavy, external dependencies, and gameplay that doesn't match the app. - Check the network's current spec for limits and accepted packaging before you build, not after. Limits change, and this article deliberately doesn't quote them. - Test on real devices with a throttled connection, with sound off and on, in both the first and last seconds of the ad. - Make the tap-to-install path the most tested part of the whole creative. - Keep a short written record of what you submitted so a rejection is a quick fix, not an investigation.

Why a checklist helps

A playable ad is a small piece of software that runs inside someone else's app. When a reviewer opens it, they are checking two things: does it work, and is it honest about the app it promotes. Both are easy to get wrong when you're rushing to hit a test window.

This checklist covers an AppLovin playable ad from the point where the creative is built to the point where you hit submit. It isn't a replacement for the official documentation. Specs, accepted file types and review rules change, so keep AppLovin's developer documentation open while you work and treat it as the source of truth for any number.

Step 1: Read the current spec first

Before building anything, find the creative requirements in the AppLovin dashboard and documentation. Note down:

  • Which packaging is accepted (single HTML file, ZIP, or both).
  • The maximum package size.
  • Supported orientations and any dimension guidance.
  • How the click-through is expected to be triggered.
  • Any rules about external requests, such as fonts, images or scripts loaded from a server.

I don't quote the limits here because they change and the dashboard is the only place that's always current. If you work across several networks, our spec comparison explains which items to compare and why they differ.

Step 2: Check the package

Open the file you plan to upload as if you were the reviewer.

  • Self-contained. Everything the ad needs should be inside the package. If any image, font or script loads from a remote URL, the ad can break on a slow connection or when that server goes down. Reviewers sometimes test in restricted environments, so external calls are a real risk.
  • Entry point is obvious. If the network expects a single HTML file or a specific filename at the root of a ZIP, match it exactly.
  • Size is comfortably under the limit. Don't aim to land just below the ceiling. A little headroom saves you if the pipeline adds anything. If you're over, our guide on reducing playable file size covers asset compression and what to cut first.
  • No stray files. Remove source maps, test pages, .DS_Store and unused assets. They add weight and sometimes trigger validation warnings.
  • Loads without a build step. Open the exported file directly in a mobile browser. If it only works through your local dev server, it isn't ready.

Step 3: Make the call to action work every time

The click-through is the entire commercial purpose of the ad, and it's the most common place for a rejection.

In-app networks usually expect the playable to call an MRAID function to open the store, rather than a plain link. The IAB Tech Lab MRAID page describes the standard, and our piece on MRAID for playable ads explains what it means in practice. The specific call AppLovin expects should be confirmed in its current docs.

Test these cases:

  1. Tap on the end card button opens the correct store page for the right platform.
  2. Tap during gameplay does what you intended. If you let players tap the ad area to install at any time, make sure it doesn't fire accidentally from an ordinary game input.
  3. Repeated taps don't open the store multiple times or leave the ad in a broken state.
  4. Returning from the store leaves the user somewhere sensible, not on a blank screen.
  5. The destination is correct. The store URL should be the one in your campaign, not a placeholder left over from testing.

If the ad runs in a plain browser where the MRAID object doesn't exist, it should fail gracefully rather than throw an error on load. Guard your calls.

Step 4: Check the start, the loop and the end

Reviewers and players both notice the edges of an ad.

  • First screen. The ad should show something meaningful immediately, not a blank page or a spinner. If assets take a moment, show a clean first frame.
  • Instructions. A player should know what to do within a moment of seeing the screen. A simple hand cursor or one short line of text is usually enough.
  • Ending. Every playable needs a defined end: a win, a fail, or a time-out that leads to the end card. An ad that can run forever with no way to install looks broken.
  • Orientation. If the spec lets the network pick the orientation, test both. A layout that crops the button in landscape is a classic issue.
  • Safe areas. Keep the call to action away from notches, rounded corners and the area where the network's close button will appear.

Step 5: Handle sound deliberately

Many phones are muted, and webviews often block audio until the user interacts. The MDN autoplay guide explains why. The practical rules:

  • Don't rely on audio to explain the mechanic.
  • Don't start sound before a user gesture.
  • If you include music or effects, make sure they stop when the ad closes or the store opens.
  • Test with the device on silent and at normal volume.

Step 6: Make sure the ad is honest about the app

This is where reviews get subjective, so be conservative.

  • Gameplay matches the game. A simplified mini-version of a core mechanic is fine. A mechanic that doesn't exist in the app is not. If your playable is a match-3 puzzle and the real game is a card battler, expect trouble and unhappy users.
  • Art and branding match the store listing. Icon, name and key visuals should be recognizable. If you're building from your listing, this walkthrough shows which assets to carry across.
  • No misleading UI. Fake system dialogs, fake notifications, fake close buttons or fake progress bars are the quickest way to a rejection and, more importantly, to angry users.
  • Claims are supportable. Avoid wording such as "#1" or "free forever" unless it is accurate and allowed.
  • Age and content fit. The ad should be suitable for the audience and the app's rating.

Step 7: Test the way a reviewer will

Do a proper QA pass before you upload. At minimum:

  • One recent iPhone and one mid-range Android phone, not just a desktop browser.
  • A slow or throttled connection, to catch anything that depends on the network.
  • A cold start, then a restart after the ad has run once.
  • Sound off, then sound on.
  • Portrait and landscape, if both are supported.

If you want a fuller list, our playable ad QA checklist goes through the device and interaction tests in more detail. After that, use whatever preview or test tool the AppLovin dashboard provides. A creative that works on your phone can still behave differently inside the network's own player.

Step 8: Submit with a paper trail

Right before upload:

  • Name the file clearly, with the app, concept and version.
  • Record the build date and what changed since the last version.
  • Keep a copy of the exact package you submitted.
  • Note which store URLs the campaign points to.

If the ad is rejected, the reason you receive may be short. Having the version history makes it easy to see what changed and to fix it without guessing. Read the message carefully, change one thing at a time, and retest before resubmitting. Resubmitting the same file unchanged rarely helps.

When you need many variants

Once a first playable passes, the next problem is volume: different hooks, different end cards, different languages. A review checklist scales better than hand-fixing each build. If you're producing variants from your store listing, a tool like PlayableRun can generate the HTML5 package so you spend your time on the checklist and the testing, not the packaging. Whichever way you build, apply the same checks to every variant, since a small change to one file can break the click path. For deciding which variants to build, see our creative testing framework.

Final thought

A playable that passes review is usually one where someone tapped every button on a real phone and read the current spec. That's unglamorous but reliable. If you'd like to see what a finished playable looks like before you build your own, the demos are a good place to start.

Frequently asked questions

›What format does an AppLovin playable ad use?

A playable is an HTML5 creative that runs inside a webview in the ad slot, usually packaged as a single HTML file or a small bundle. Confirm the exact packaging the dashboard currently accepts in AppLovin's documentation before you export.

›Do I need MRAID for an AppLovin playable ad?

Playables on in-app networks generally use MRAID-style calls to open the store when the player taps the call to action. Check AppLovin's current spec for the exact call it expects, and test that the tap opens the right store page.

›Why do playable ads get rejected?

Common causes are a call to action that does nothing or opens the wrong page, a package that exceeds the network's size limit, external requests that fail, and gameplay that misrepresents the app. Run a QA pass on a real device before uploading.

›Should the playable include audio?

Treat audio as optional. Browsers and webviews often block sound until the user interacts, and many people have their phone muted. Make the ad fully understandable without sound.

›Can I reuse the same playable on AppLovin and Google Ads?

Often the core experience carries over, but the click handling and packaging differ between networks. Plan on a separate export or build step per network and test each one.

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