Unity Ads & ironSource LevelPlay: Playable Ad Specs and Developer Guide

ironSource is Unity now. Since the 2022 acquisition, both platforms have merged into a single monetization ecosystem under Unity LevelPlay. But the playable ad specs haven't fully unified. Unity Ads and ironSource still enforce different technical requirements for playable creatives, different MRAID versions, different autoplay rules, different HTML structures, and different code restrictions.

If you're shipping playable ads to Unity's ecosystem, you need to understand both sets of rules. This guide covers the specs for Unity Ads and ironSource side by side, the common rejections we've seen across both, and how to test before you submit.

Unity Ads Playable Ad Specifications

Requirement	Specification
File format	Single HTML file, fully inlined
Maximum file size	5 MB
Minification	Required, all whitespace removed
External requests	Prohibited (no XHR, no CDN calls)
MRAID compliance	MRAID 3.0
Orientation	Must support both portrait and landscape
Android minimum	Version 4.4+
iOS minimum	Version 8.0+
End card	Mandatory with clear CTA
Store link method	mraid.open(url)

The one rule that trips up almost everyone: everything must live in a single file. Images, fonts, audio, CSS, JavaScript. All of it inlined, usually as base64 data URIs. No folder structures, no CDN links, no external references of any kind. The Unity Ads SDK loads your playable as one HTML document. If anything in that document tries to phone home, it either breaks silently or gets your creative rejected outright.

MRAID 3.0: Unity Ads Implementation

MRAID (Mobile Rich Media Ad Interface Definitions) is the API layer between your playable and the Unity Ads SDK. Unity requires MRAID 3.0 compliance but still supports MRAID 2.0 methods for backward compatibility.

You don't bundle the MRAID library yourself. The SDK injects it into the webview. But your code must use it correctly. These are the methods that matter:

• mraid.getState() checks whether the SDK is loading or ready before you initialize your game
• mraid.addEventListener('ready', callback) listens for the SDK to finish loading
• mraid.addEventListener('viewableChange', callback) detects when the ad becomes visible to the user
• mraid.isViewable() checks if the ad container is currently on screen
• mraid.open(url) opens the app store link when the user taps your CTA

Here's the one that really matters: wait for viewableChange before starting your playable content. Unity's docs are explicit about this. If your game starts before the ad is visible, you burn the user's first impression and Unity's QA team will flag it.

MRAID Initialization Sequence

Follow this exact sequence:

1. Check mraid.getState(). If it returns ready, proceed. If loading, listen for the ready event.
2. Once ready, check mraid.isViewable(). If true, start the game.
3. If not viewable, listen for viewableChange and start when the value becomes true.
4. When the user taps the CTA, call mraid.open(storeUrl) to redirect to the app store.

Get this wrong and you're looking at a rejection. We've seen a gaming studio go through three rounds of QA review because they fired game logic before the ready event.

Unity Ads End Card Requirements

Every Unity Ads playable needs an end card. No exceptions. It needs a clear call-to-action ("Download Now", "Install", something obvious), a store link that opens via mraid.open(), and the correct store URLs. iOS must use apps.apple.com, not the deprecated itunes.apple.com. Android must use a Google Play link.

The rules that catch people off guard:

• The end card should feel like a natural conclusion to the gameplay, not an abrupt cut
• Never auto-redirect to the app store. The user must tap the CTA themselves
• Don't let your end card overlap Unity's own close button UI
• Keep the gap between the last interaction and the end card under 1 second. Longer delays get flagged in QA

ironSource (LevelPlay) Playable Ad Specifications

ironSource runs under the Unity LevelPlay umbrella, but its playable ad specs are still distinct from Unity Ads. Some overlap. Others are the complete opposite. This is where studios burn hours if they don't know the differences upfront.

Requirement	Specification
File format	Inline HTML snippet (not a full HTML document)
Maximum file size	5 MB
Asset embedding	All JS, CSS, and images as base64 within the HTML
External requests	No third-party blocking pixels (IAS, DV, etc.)
MRAID compliance	MRAID 2.0 and 3.0
CTA methods	mraid.open() + mraid.openStoreURL()
Orientation	Both landscape and portrait. Aspect ratio 1:2 to 2:1
Autoplay	Must autoplay without user interaction
Close button	Platform-rendered (do not add your own)

Autoplay: The Biggest Difference

This is where things flip. ironSource requires your creative to autoplay without any user interaction. The game must start immediately on load. That's the exact opposite of how most other networks work, where the timer waits for the first tap. (Compare this with AppLovin's interaction-first model.)

This means your game loop, animations, and tutorial must all fire on load. Don't wait for a tap-to-start. Don't show a "Play" button. The ad starts, the user sees the game in action, and they can interact at any point.

CTA Methods

ironSource gives you two CTA methods:

• mraid.open(URL_STRING) for standard URL redirects
• mraid.openStoreURL() specifically for app store links (Google Play, Apple App Store)

Include <script src="mraid.js"></script> in the <head> section. For dimensions, use mraid.getMaxSize(). Don't try to get ad size any other way.

UI Rules

ironSource renders its own timer and close button. Do not add your own. A custom close button is an instant rejection. Auto-redirects without user interaction are blocked, and so are delayed redirects that fire more than 7 seconds after the last user action.

Code Restrictions

ironSource is picky about code quality in ways that will surprise you:

• Single-line HTML comments? Rejected. Use <!-- --> multi-line format instead
• Accessing the top window object? Breaks their webview
• DAPI initialization scripts? Rejected
• HTTP instead of HTTPS? Rejected

These sound trivial. They're not. A gaming studio we worked with got three consecutive rejections and couldn't figure out why. Turned out their minifier was inserting single-line comments into the build output. Nobody was even looking at that part of the pipeline.

Unity Ads vs ironSource: Side-by-Side Comparison

Same parent company, different specs. Here's where they clash:

Specification	Unity Ads	ironSource (LevelPlay)
Format	Single HTML file (full document)	Inline HTML snippet
MRAID version	3.0	2.0 and 3.0
CTA method	mraid.open()	mraid.open() + mraid.openStoreURL()
Autoplay behavior	Wait for viewableChange	Must autoplay immediately
Audio on load	Follows MRAID viewability	Autoplay (no interaction needed)
Close button	Platform-managed	Platform-managed (do not add your own)
Code comments	No restriction	No single-line comments
Window.top access	No restriction	Prohibited
Minification	Required	Recommended

The two differences that will actually break your build: autoplay behavior and HTML structure. Unity Ads waits for viewableChange before starting; ironSource starts immediately on load. Unity expects a full HTML document; ironSource expects an inline HTML snippet. A single file cannot pass validation on both platforms without platform-specific adaptation.

Common Rejection Reasons Across Both Platforms

Unity Ads Rejections

1. External network requests. Any XHR call, fetch request, or external resource load triggers an instant rejection. The sneaky ones: forgotten CDN links for fonts, analytics scripts, or image tags pointing to external URLs. One client had a single Google Fonts import buried in their CSS. Rejected.
2. File size over 5 MB. The limit is measured on the raw HTML file, not gzipped. Base64 encoding adds roughly 33% overhead. A 3 MB set of images becomes about 4 MB when inlined.
3. Missing orientation support. Unity requires both portrait and landscape. If your layout breaks when the device rotates, it's going back.
4. Broken MRAID calls. Calling MRAID methods before the SDK is ready. Forgetting to call mraid.open() for the store redirect.
5. Ad does not scale to device screen. iPads are the usual culprit. Set your viewport meta tag correctly and test on tablet-sized screens.
6. Close button obstruction. Unity overlays its own close button in the top-right corner. If your UI sits there, rejected.

ironSource Rejections

1. Custom close button. ironSource renders its own. Adding yours is an instant rejection.
2. Not autoplaying. If your creative waits for a tap to start, it fails ironSource's requirement for immediate autoplay.
3. Single-line comments in code. Minifiers that insert single-line comments will get your build bounced.
4. Accessing window.top. Breaks ironSource's webview sandbox.
5. HTTP URLs. Everything must be HTTPS. No exceptions.
6. Delayed redirects. CTA redirects firing more than 7 seconds after the last user action get blocked.

LevelPlay Mediation: What Changes

Unity LevelPlay mediates across both Unity Ads and ironSource inventory (plus other networks). When your playable ad is served through LevelPlay, the underlying SDK determines which spec applies. A creative served through Unity Ads inventory follows Unity specs. A creative served through ironSource inventory follows ironSource specs.

This means if you're using LevelPlay for both demand sources, you need two separate builds. No shortcuts. The autoplay behavior, CTA method, and HTML structure differ enough that a single file will not pass validation on both.

LevelPlay Reporting

LevelPlay's reporting dashboard lets you stack up to 8 metrics at once with custom filters. The key metrics for playable ads:

• Engagement Rate: Engaged users divided by active users. Tells you if people are actually playing or just watching.
• eCPM: Revenue per 1,000 impressions on the monetization side.
• CTR: Click-through rate on the CTA.
• Impressions and revenue data with custom filter presets.

Set up filter presets so you're not rebuilding the same report every Monday morning. And segment by creative to identify which playable variants are driving the best eCPM for your inventory.

Testing Before Submission

Unity Ad Testing App

Unity's official Ad Testing app is available on both iOS and Android. Upload your playable HTML, initialize the ad, and run it on a real device. This is the closest you'll get to how your ad actually behaves in production. If it works here, it'll almost certainly pass QA.

MRAID Web Tester

The MRAID Web Tester at webtester.mraid.org lets you validate MRAID compliance right in the browser. Set the ad size to 320x480, select interstitial mode, and load your HTML. It flags incorrect MRAID calls and shows you exactly what events your playable is firing.

Pre-Submission Checklist

Run through this before every submission. We use it internally and it catches something almost every time.

1. File check: Single HTML file (Unity) or inline snippet (ironSource), under 5 MB, minified
2. Network check: Open browser DevTools, load the file, confirm zero network requests in the Network tab
3. Orientation check: Test in both portrait (360x640) and landscape (640x360)
4. MRAID check: Unity: verify getState → ready → viewableChange → game starts. ironSource: verify autoplay on load
5. CTA check: Confirm end card appears and mraid.open() fires with the correct store URL
6. Code check (ironSource): No single-line comments, no window.top access, HTTPS only

Also test on tablet screen sizes, verify no UI overlaps the top-right corner close button zone, and double-check that iOS URLs use apps.apple.com (not itunes.apple.com).

How Hookin Handles Unity & ironSource Exports

Two platforms, two sets of specs, one game. Hookin's platform-specific adapters handle every difference behind the scenes:

• The Unity Ads adapter outputs a full HTML document, injects MRAID 3.0 with the correct viewableChange listener, wires mraid.open() to your CTA, and ensures both portrait and landscape work. Images get compressed, audio gets reduced, and the entire output is bundled and minified into a single HTML file under 5 MB.
• The ironSource adapter outputs an inline HTML snippet, injects MRAID 2.0/3.0 with both mraid.open() and mraid.openStoreURL(), enables autoplay on load, and strips single-line comments and window.top references from the build.

You build one game. The adapters produce two compliant builds. Export to Unity, ironSource, and 8 other networks, including Google Ads, with a single click.

---

Unity's ecosystem is the largest source of rewarded and interstitial playable ad inventory. Get the specs right, and you're reaching millions of players across both Unity Ads and ironSource inventory through LevelPlay. If you're new to the format, you can create your first playable ad in 10 minutes.

Create a Unity and ironSource-ready playable ad on Hookin, free to start