Unity Ads Playable: Creative Formats and QA Checklist

A Unity Ads playable can run as an end card after a video or as the main ad unit. This guide covers how to choose, how to build for each, and how to QA before spending budget.

By the PlayableRun team··6 min read

Key takeaways - A Unity Ads playable usually runs either as an end card after a video or as the main interactive unit. Each needs a different opening. - Design the first screen for the format. An end card inherits context from the video. A standalone playable has to explain itself. - Build a self-contained file with no external requests, and check Unity's current spec for size and packaging before you export. - QA the exported file on real devices, not your working copy in a desktop browser. - Treat the store redirect, orientation handling, and audio as the three most common failure points.

Where playables appear in Unity Ads

Unity Ads serves ads inside other developers' apps, mostly mobile games. The player sees your creative at a natural break: after a level, in exchange for a reward, or between sessions. That context shapes everything about how a playable should behave.

The user did not choose to see your ad. They are mid-flow in a different game, often holding the phone one-handed. A playable that demands attention before it earns it will be closed. One that lets them tap within a moment and see something happen has a chance.

Unity changes its ad products and dashboard terminology from time to time. Before you build, read the current creative requirements on Unity's documentation site so your format names, packaging, and limits match what the dashboard asks for today.

The two formats worth knowing

Playable end card

Here the user watches a short video, and the playable appears afterward in place of a static end card. The video does the explaining. The playable converts interest into action.

This format suits you if:

  • You already have video creatives that perform acceptably.
  • Your game needs a little context before the mechanic makes sense, such as a puzzle with rules or a strategy game with a goal.
  • You want to add interaction without betting the whole impression on it.

Design implications: the playable can skip a long tutorial because the video set the scene. Match the visuals, art style, and tone to the video. If the video shows a bright puzzle board and the playable opens on a dark menu, the handoff feels like a different ad.

Standalone playable

Here the playable is the whole ad. There is no video lead-in, so the first screen must communicate the goal, the input, and the reward in a glance.

This format suits you if:

  • The mechanic is obvious from one look: tap to shoot, swipe to merge, drag to connect.
  • You have no video, or video has not been a strong channel for your genre.
  • You want to filter for users who are willing to interact, which tends to change the kind of installs you get.

Design implications: put a visible hint, such as a hand cursor or a highlighted object, on screen one. Make the first tap succeed. Cut anything that is not the core loop. If you are unsure which loop to pick, our article on assets needed for a playable covers what to pull from your game.

How to choose

Pick the format based on how fast your game can be understood, not on what is easier to produce. If you cannot explain the hook in one screen without text, use the end card. If you can, test the standalone version too, because the two formats attract different intent.

Build constraints that affect QA

Most QA failures trace back to the build, so settle these before testing.

  • Self-contained file. Everything the playable needs, including images, audio, scripts, and fonts, should be inside the package. Network requests to external hosts are a common cause of blank screens and review problems.
  • Size. Networks cap creative size, and Unity's cap can change. Look up the current number in Unity's documentation instead of relying on memory. If you are over, see how to reduce playable ad file size.
  • Packaging. Check whether the dashboard expects a single HTML file or a ZIP, and what the entry file should be called. Specs differ across networks, and this comparison of playable ad specs explains what to verify before export.
  • Orientation. Decide whether you support portrait, landscape, or both. If both, the layout must adapt, not just scale.
  • Store redirect. The call-to-action must open the correct App Store or Google Play page for the platform the user is on. Read MRAID for playable ads if you are unsure how that handoff works.

If you generate the playable from a store listing with a tool like PlayableRun, you still do this verification. The tool gives you a starting file. The QA is yours.

A QA process that catches real problems

Run the checks in this order. Each stage finds problems the previous one cannot.

Stage 1: Desktop browser

This is for logic only. Open the exported file, not your editor preview.

  • Does the first interaction work on the first tap?
  • Does the playable reach an end state and show the call-to-action?
  • Does the console show errors or failed requests?
  • Does the call-to-action fire the redirect handler without crashing?

Desktop mouse input differs from touch, so do not sign off here. MDN's page on touch events is a useful reference if your interactions behave differently under a finger.

Stage 2: Real devices

Test on at least one iPhone and one Android phone, and include an older or mid-range Android if you can. Performance problems hide on fast hardware.

Check these specifically:

  • Frame rate and responsiveness. Does it stutter during the main interaction?
  • Touch handling. Do taps near screen edges register? Does a swipe get hijacked by the system?
  • Audio. Does sound start only after a user gesture? Is it a reasonable volume? Does the playable still make sense with the device on silent?
  • Orientation. Rotate mid-play. Does the layout recover, or does it break and stay broken?
  • Aspect ratios. Test a tall phone and a shorter one. Buttons pushed under a notch or off screen are a frequent issue.

Stage 3: Inside the network's preview

Use whatever preview or test-device option Unity's dashboard offers at the time you build. Confirm the playable loads inside the actual ad player, with its close button, timers, and overlay. These elements can cover your UI. A call-to-action tucked in a corner may sit under the network's own controls.

Stage 4: Network conditions and interruptions

  • Load it on a slow connection. Does it show something quickly or sit blank?
  • Switch apps mid-play and come back. Does it resume or freeze?
  • Receive a notification or call. Does audio stop cleanly?

Pre-launch checklist

  • The exported file, not the working version, passed every stage above.
  • The first screen shows a clear goal and a visible first action.
  • The call-to-action opens the right store page on both iOS and Android.
  • No external requests appear in the network log.
  • Size and packaging match Unity's current spec.
  • Controls are not covered by the player's overlay.
  • Audio is optional to understanding.
  • The end screen matches what the game really offers.

That last item matters. If your playable shows mechanics, rewards, or progress that the installed game does not deliver, it creates a trust problem and can run into policy issues. Our article on misleading playable ads explains where the line sits between a stylized preview and a fake one.

After launch

Start with a small budget and watch for signs of a technical problem before judging creative quality. A playable with an unusually low interaction rate on one device family often has a bug, not a weak concept. Fix the build first, then compare variants.

When you compare, decide in advance which signal you trust. Taps tell you about the opening. Install quality tells you whether the playable set honest expectations.

Where to go from here

If you want to see what a finished playable looks like before building your own, browse the live demos. If you would rather generate a first version from your store listing and then run the QA above, you can create a free account.

Frequently asked questions

›What is a Unity Ads playable?

It is an interactive HTML5 creative that runs inside the ad player in a publisher's app. The user taps or swipes through a short slice of gameplay and is then sent to your store page. It can appear as an end card after a video or as the main creative, depending on how the campaign is set up.

›Should I build a playable end card or a standalone playable?

Start with the end card if you already have video creatives, because the playable adds interaction to something that works. Build a standalone playable when the core mechanic can be understood without any lead-in. Test both if you have the budget, and compare on install quality, not only on taps.

›Does a Unity Ads playable need MRAID?

Playables on in-app networks typically rely on MRAID-style calls to open the store. The exact calls and any required wrapper depend on the network's current spec, so check Unity's documentation before you export. Our MRAID article explains the basics.

›How do I test a playable before launching a campaign?

Test in a desktop browser first for logic, then on real iOS and Android devices through whatever preview or test-device option Unity's dashboard currently offers. Check orientation changes, audio, the store redirect, and behavior on a weak connection.

›Why does my playable work in the browser but fail in review?

Common causes are external network requests, files that exceed the size limit, a missing or broken store redirect, and layouts that break on certain screen ratios. A browser on your laptop hides most of these, so test the final exported file, not your working copy.

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