Unity Ads

What is Unity Ads?

Unity Ads is a mobile ad network built for game developers. It plugs straight into the Unity engine, so studios already shipping with Unity can turn on ads without bolting on a foreign SDK. The network reaches more than 2 billion monthly active users across 200+ countries, which gives even a small studio access to a global pool of players for both game monetization and user acquisition.

The difference from a general-purpose network is the game focus. Unity Ads handles the ad formats that fit a session loop rather than a web page: rewarded video, interstitial, banner, and playable ads. Each one maps to a different moment in play. Rewarded video sits at points where a player wants something (an extra life, currency, a continue). Interstitials run at natural breaks, like the gap between levels. Banners hold a small slot in menus. Playables let a user try an advertised game before installing it.

Because the integration is native to Unity, you manage everything from the same place you build the game. You set up ad units in the Unity Ads dashboard, drop in the Unity Ads SDK, and call it from your existing C# code. The same SDK covers Unity Ads Android and iOS builds, and the platform works alongside Unity mediation if you want to run other networks in the same waterfall. For studios building with the engine, Unity 3D ads and the rest of the toolchain live under one account, which keeps Unity Ads monetization close to the rest of your build and release work.

Unity Ads vs. Competing Ad Networks

Before you commit to a network, it helps to see where Unity Ads sits against the other options you'd actually shortlist. The table below lines it up against AdMob, ironSource, AppLovin, and Facebook Audience Network on the things that move revenue: format support, fill, eCPM, and how the SDK fits into your build.

Feature	Unity Ads	AdMob	ironSource	AppLovin	Facebook Audience Network
Game-Specific Focus	High (built for games)	Medium	High	High	Low
Integration Ease with Unity	Native integration	Requires SDK	Requires SDK	Requires SDK	Requires SDK
eCPM Rates (US/Tier 1)	$10-25	$8-20	$10-30	$10-25	$8-15
Fill Rates	90-98%	85-95%	90-99%	90-98%	80-90%
Ad Formats	Rewarded, Interstitial, Banner, Playable	Rewarded, Interstitial, Banner, Native	Rewarded, Interstitial, Banner, Offerwall	Rewarded, Interstitial, Banner, Native	Rewarded, Interstitial, Banner, Native
Cross-Promotion Tools	Advanced	Basic	Advanced	Advanced	Limited
Bidding Support	Yes (LevelPlay)	Yes	Yes (LevelPlay)	Yes (MAX)	Yes
Mediation Capabilities	Limited	Strong	Strong (LevelPlay)	Strong (MAX)	Limited
Analytics Depth	Deep Unity integration	Good	Excellent	Excellent	Good
Minimum Requirements	None	$1+ daily revenue	$3+ daily revenue	$5+ daily revenue	None

Where Unity Ads wins

The clearest advantage is the SDK. If you build in Unity, the ads package drops in natively instead of bolting on a third-party SDK, so the Unity Ads SDK ships and updates alongside the engine. That tight coupling carries through to reporting too: ad data shows up next to your gameplay analytics in the same Unity tooling rather than in a separate console. For a studio already living in the Unity 3D pipeline, that's less plumbing and fewer build conflicts. Cross-promotion is strong as well, which matters if you run a portfolio of titles and want to move players between them.

Where it falls short

Mediation is the weak spot. Unity supports bidding through LevelPlay, but as a mediation layer it doesn't match dedicated platforms like ironSource's LevelPlay or AppLovin's MAX, both of which manage more demand sources with more control. So in practice, Unity mediation tends to be one network in a stack rather than the layer that runs the whole auction.

That's the takeaway: don't treat this as a single-network decision. The top-grossing games almost never rely on one source of demand. They run several networks behind a mediation layer so every impression goes to the highest bidder, and Unity Ads usually earns its slot in that mix on the strength of its native integration and game-first demand. For most studios, the right question isn't "Unity Ads or AdMob," it's "which mediation layer do I run, and where does Unity sit inside it for my Unity Ads monetization setup on iOS and Unity Ads Android."

Unity Ads Implementation Guide

Here's how to wire up the Unity Ads SDK and get each ad format running. The steps below cover account setup, SDK init, and the four placement types: rewarded video, interstitial, and banner.

Basic implementation process

1. Set up your Unity Ads account. Create a Unity developer account at https://unity.com/products/unity-ads if you don't have one. Open the Monetization section to reach your Unity Ads dashboard.
2. Add your project. In the dashboard, add each app you want to monetize. You'll need the app name, platform (iOS or Android), store links, and category.
3. Install the SDK. The steps differ depending on whether you build in the Unity engine or somewhere else.For Unity engine projects:

   // In your initialization script (e.g. GameManager.cs):
   using UnityEngine;
   using UnityEngine.Advertisements;
   
   public class GameManager : MonoBehaviour, IUnityAdsInitializationListener
   {
   private string _gameId = "YOUR_GAME_ID";
   private bool _testMode = false;
   
   void Start()
   {
   InitializeAds();
   }
   
   public void InitializeAds()
   {
   Advertisement.Initialize(_gameId, _testMode, this);
   }
   
   public void OnInitializationComplete()
   {
   Debug.Log("Unity Ads initialization complete.");
   // Now you can load ads
   }
   
   public void OnInitializationFailed(UnityAdsInitializationError error, string message)
   {
   Debug.Log($"Unity Ads Initialization Failed: {error.ToString()} - {message}");
   }
   }
   

   For non-Unity projects (Android, Java example). Side note: see AppSamurai's rundown of the best mobile game engines here.

   // In your main activity:
   import com.unity3d.ads.IUnityAdsInitializationListener;
   import com.unity3d.ads.UnityAds;
   
   public class MainActivity extends AppCompatActivity implements IUnityAdsInitializationListener {
   private String unityGameID = "YOUR_GAME_ID";
   private boolean testMode = false;
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);
   
   UnityAds.initialize(getApplicationContext(), unityGameID, testMode, this);
   }
   
   @Override
   public void onInitializationComplete() {
   Log.d("UnityAds", "Initialization Complete");
   // Now you can load ads
   }
   
   @Override
   public void onInitializationFailed(UnityAds.UnityAdsInitializationError error, String message) {
   Log.e("UnityAds", "Initialization Failed: " + error.toString() + " - " + message);
   }
   }
   

4. Add your ad units. Once the SDK is initialized, wire up each format you plan to run.

The unity3d.ads package handles the Android side, so the same Unity Ads SDK powers both Unity engine games and native Android builds. Game IDs and ad unit IDs come straight from the Unity Ads dashboard.

Rewarded video implementation

Rewarded video usually earns the most and feels least intrusive, since the player chooses to watch it in exchange for something. Trigger it at points where a reward actually helps: an extra life, a continue, or a currency top-up.

// Unity C# implementation
using UnityEngine;
using UnityEngine.Advertisements;

public class RewardedAdsManager : MonoBehaviour, IUnityAdsLoadListener, IUnityAdsShowListener
{
private string _adUnitId = "Rewarded_Android"; // Use "Rewarded_iOS" for iOS

public void LoadRewardedAd()
{
Advertisement.Load(_adUnitId, this);
}

public void ShowRewardedAd()
{
Advertisement.Show(_adUnitId, this);
}

// Load Callbacks
public void OnUnityAdsAdLoaded(string adUnitId)
{
Debug.Log("Rewarded Ad Loaded: " + adUnitId);
}

public void OnUnityAdsFailedToLoad(string adUnitId, UnityAdsLoadError error, string message)
{
Debug.Log($"Rewarded Ad Load Failed: {error.ToString()} - {message}");
}

// Show Callbacks
public void OnUnityAdsShowComplete(string adUnitId, UnityAdsShowCompletionState showCompletionState)
{
if (adUnitId.Equals(_adUnitId) && showCompletionState.Equals(UnityAdsShowCompletionState.COMPLETED))
{
Debug.Log("Reward player now!");
// Reward the player here
}
}

public void OnUnityAdsShowFailure(string adUnitId, UnityAdsShowError error, string message)
{
Debug.Log($"Rewarded Ad Show Failed: {error.ToString()} - {message}");
}

public void OnUnityAdsShowStart(string adUnitId) { }
public void OnUnityAdsShowClick(string adUnitId) { }
}

Note the COMPLETED check in OnUnityAdsShowComplete: only hand out the reward when the player finishes the video. Skipped or failed views shouldn't pay out.

Interstitial implementation

Interstitials run full screen at a break in play, between levels or after a session ends. Load the next one as soon as the current one finishes so it's ready when you need it.

// Unity C# implementation
using UnityEngine;
using UnityEngine.Advertisements;

public class InterstitialAdsManager : MonoBehaviour, IUnityAdsLoadListener, IUnityAdsShowListener
{
private string _adUnitId = "Interstitial_Android"; // Use "Interstitial_iOS" for iOS

public void LoadInterstitialAd()
{
Advertisement.Load(_adUnitId, this);
}

public void ShowInterstitialAd()
{
Advertisement.Show(_adUnitId, this);
}

// Load Callbacks
public void OnUnityAdsAdLoaded(string adUnitId)
{
Debug.Log("Interstitial Ad Loaded: " + adUnitId);
}

public void OnUnityAdsFailedToLoad(string adUnitId, UnityAdsLoadError error, string message)
{
Debug.Log($"Interstitial Ad Load Failed: {error.ToString()} - {message}");
}

// Show Callbacks
public void OnUnityAdsShowComplete(string adUnitId, UnityAdsShowCompletionState showCompletionState)
{
Debug.Log("Interstitial Ad Show Complete");
LoadInterstitialAd(); // Load the next interstitial
}

public void OnUnityAdsShowFailure(string adUnitId, UnityAdsShowError error, string message)
{
Debug.Log($"Interstitial Ad Show Failed: {error.ToString()} - {message}");
}

public void OnUnityAdsShowStart(string adUnitId) { }
public void OnUnityAdsShowClick(string adUnitId) { }
}

Banner implementation

Banners earn quiet, steady revenue and stay out of the way. Pin them to the top or bottom of the screen, and keep them off active gameplay views.

// Unity C# implementation
using UnityEngine;
using UnityEngine.Advertisements;

public class BannerAdsManager : MonoBehaviour
{
private string _adUnitId = "Banner_Android"; // Use "Banner_iOS" for iOS

public void LoadBanner()
{
// Set banner position
Advertisement.Banner.SetPosition(BannerPosition.BOTTOM_CENTER);

// Create a banner load options object
BannerLoadOptions options = new BannerLoadOptions
{
loadCallback = OnBannerLoaded,
errorCallback = OnBannerError
};

// Load the banner
Advertisement.Banner.Load(_adUnitId, options);
}

private void OnBannerLoaded()
{
Debug.Log("Banner loaded");
ShowBanner();
}

private void OnBannerError(string message)
{
Debug.Log($"Banner Error: {message}");
}

private void ShowBanner()
{
BannerOptions options = new BannerOptions
{
clickCallback = OnBannerClicked,
hideCallback = OnBannerHidden,
showCallback = OnBannerShown
};

Advertisement.Banner.Show(_adUnitId, options);
}

private void OnBannerClicked() { }
private void OnBannerShown() { }
private void OnBannerHidden() { }

public void HideBanner()
{
Advertisement.Banner.Hide();
}
}

Swap the _adUnitId values (Rewarded_iOS, Interstitial_iOS, Banner_iOS) when you build for iOS. Keep the IDs in sync with what you create in the Unity Ads dashboard, and you can run the same monetization setup across Unity 3D and native Android builds.

Advanced Implementation Strategies

Once the basics are in place, a few practices push revenue higher without costing you players. These build on the standard Unity Ads SDK setup and assume you already have your ad units configured in the Unity Ads dashboard.

Strategic Ad Placement

Where you show an ad matters as much as how often. Map each placement to a point in the game loop where it fits the flow:

Game Stage	Recommended Ad Type	Implementation Notes
Game Start	None	Avoid showing ads before players experience your game
Between Levels	Interstitial	Natural break point that doesn’t interrupt gameplay
After Death/Failure	Rewarded (Continue)	Offer continues or extra lives via rewarded ads
Store/Resources	Rewarded (Currency)	Offer free currency or resources via rewarded ads
Game Completion	Interstitial	Natural conclusion point for session
Main Menu	Banner	Non-intrusive persistent monetization
Game Pause	Banner	Optional additional placement

Frequency Capping and Pacing

Caps stop ad fatigue. Limit how many interstitials a player sees per session and enforce a minimum gap between them. The class below tracks both: a session count and a timer since the last interstitial.

// Example frequency capping implementation
public class AdFrequencyManager : MonoBehaviour
{
private const int MAX_INTERSTITIALS_PER_SESSION = 3;
private const int MIN_SECONDS_BETWEEN_INTERSTITIALS = 120;

private int _interstitialsShownThisSession = 0;
private float _lastInterstitialTime = 0;

public bool CanShowInterstitial()
{
// Check if we've exceeded the session cap
if (_interstitialsShownThisSession >= MAX_INTERSTITIALS_PER_SESSION)
return false;

// Check if enough time has passed since the last interstitial
if (Time.time - _lastInterstitialTime < MIN_SECONDS_BETWEEN_INTERSTITIALS)
return false;

return true;
}

public void RecordInterstitialShown()
{
_interstitialsShownThisSession++;
_lastInterstitialTime = Time.time;
}

public void ResetSession()
{
_interstitialsShownThisSession = 0;
}
}

A/B Testing Ad Implementation

Don’t guess at the right frequency. Split players into groups, give each group a different ad setup, and compare revenue and retention. Assign the group once on first launch, store it in PlayerPrefs so it stays fixed for that player, and tag the group in your analytics so you can read the results per cohort.

// Example A/B testing manager for ad placement
public class ABTestManager : MonoBehaviour
{
// User groups - set upon first app launch and stored in PlayerPrefs
private enum TestGroup { Control, TestVariantA, TestVariantB }
private TestGroup _userGroup;

private void Start()
{
// Assign user to test group if not already assigned
if (!PlayerPrefs.HasKey("AB_Test_Group"))
{
// Randomly assign to one of three groups
int groupValue = Random.Range(0, 3);
_userGroup = (TestGroup)groupValue;
PlayerPrefs.SetInt("AB_Test_Group", groupValue);
}
else
{
_userGroup = (TestGroup)PlayerPrefs.GetInt("AB_Test_Group");
}

ApplyTestSettings();
}

private void ApplyTestSettings()
{
switch (_userGroup)
{
case TestGroup.Control:
// Standard settings
AdSettings.interstitialFrequency = 180; // 3 minutes
AdSettings.maxInterstitialsPerSession = 3;
break;

case TestGroup.TestVariantA:
// More aggressive settings
AdSettings.interstitialFrequency = 120; // 2 minutes
AdSettings.maxInterstitialsPerSession = 5;
break;

case TestGroup.TestVariantB:
// Less aggressive settings
AdSettings.interstitialFrequency = 240; // 4 minutes
AdSettings.maxInterstitialsPerSession = 2;
break;
}

// Track test group in analytics
Analytics.SetUserProperty("ab_test_group", _userGroup.ToString());
}
}

Performance Metrics and Optimization

If you want more revenue from Unity Ads monetization, you have to watch the right numbers and act on them. The metrics below are the ones that actually move your payout, plus what to do when they slip.

Key Performance Metrics

Metric	Description	Benchmark (2025)	Optimization Tips
eCPM	Effective cost per mille (revenue per 1,000 impressions)	Rewarded: $10-25 Interstitial: $8-20 Banner: $1-3	Test different ad placements; Implement user segmentation; Optimize for high-value regions
Fill Rate	Percentage of ad requests that are fulfilled	90-99%	Implement proper caching; Use multiple ad networks; Ensure correct implementation
Completion Rate	Percentage of video ads watched to completion	70-85%	Place ads at natural breaks; Ensure clear value proposition; Keep rewards meaningful
CTR (Click-Through Rate)	Percentage of impressions that result in clicks	1-3%	Test different creative formats; Optimize ad relevance; Improve placement timing
ARPDAU	Average Revenue Per Daily Active User	Casual: $0.02-0.08 Midcore: $0.05-0.15 Hardcore: $0.10-0.30	Balance ad frequency; Combine with IAPs; Segment users by behavior
Retention Impact	Effect of ads on next day return rate	<5% negative impact	Test ad frequency; Focus on rewarded formats; Avoid early-game ads

Read these together, not one at a time. A 98% fill rate means nothing if your completion rate is sinking, and a high eCPM that drags retention down costs you more over a player's lifetime than it earns this week. Pull all six from your Unity Ads dashboard and check them on the same cadence.

eCPM Optimization Strategies

eCPM is where most of the money is won or lost. Three levers matter most: where your players live, which formats you run, and how you treat different player segments.

1. Geographic Targeting eCPM swings hard by country. Here are typical ranges for rewarded video:
   

   Region	eCPM Range (2025)
   United States	$15-25
   United Kingdom	$12-22
   Canada	$10-18
   Australia	$10-18
   Germany	$8-15
   Japan	$12-20
   South Korea	$8-16
   Brazil	$2-8
   India	$1-3
   Indonesia	$1-4

   A US impression can pay 10x what an India impression pays. Run ads harder in Tier-1 markets and lean on in-app purchases where eCPMs are thin, rather than burning low-value users with ad volume that barely moves revenue.

2. Ad Format Optimization Formats pay very differently:
   

   Ad Format	Average eCPM	Best Use Case
   Rewarded Video	$10-25	Resource gains, continues, boosters
   Interstitial Video	$8-20	Between levels, after sessions
   Interstitial Display	$3-8	Natural breaks, menu transitions
   Banner	$1-3	Persistent, non-intrusive monetization
   Playable	$12-30	Special offers, featured promotions

   Build your revenue around the high payers: rewarded video and playables. Banners and display interstitials are filler that adds a few cents on top, not the foundation.

3. User Segmentation Players differ in what they're worth and how much ad load they'll tolerate. Tie your ad strategy to spend and tenure so new and paying users get a lighter touch than free riders. Here's how the segments map in code, pulled from values stored on the device:

   // Example user segmentation for ad strategy
   public class UserSegmentation : MonoBehaviour
   {
   public enum UserSegment { NewUser, NonPayer, Payer, WhaleUser }
   
   private UserSegment _currentSegment;
   
   private void DetermineUserSegment()
   {
   int daysActive = PlayerPrefs.GetInt("days_active", 0);
   float totalSpend = PlayerPrefs.GetFloat("total_spend", 0f);
   
   if (daysActive < 2)
   {
   _currentSegment = UserSegment.NewUser;
   }
   else if (totalSpend == 0)
   {
   _currentSegment = UserSegment.NonPayer;
   }
   else if (totalSpend < 20f)
   {
   _currentSegment = UserSegment.Payer;
   }
   else
   {
   _currentSegment = UserSegment.WhaleUser;
   }
   
   ApplyAdStrategy();
   }
   
   private void ApplyAdStrategy()
   {
   switch (_currentSegment)
   {
   case UserSegment.NewUser:
   // Go easy on new users
   AdManager.SetInterstitialFrequency(300); // 5 minutes
   AdManager.EnableRewarded(true);
   AdManager.EnableBanners(false);
   break;
   
   case UserSegment.NonPayer:
   // More aggressive with non-payers
   AdManager.SetInterstitialFrequency(180); // 3 minutes
   AdManager.EnableRewarded(true);
   AdManager.EnableBanners(true);
   break;
   
   case UserSegment.Payer:
   // Respect that they've paid
   AdManager.SetInterstitialFrequency(300); // 5 minutes
   AdManager.EnableRewarded(true);
   AdManager.EnableBanners(false);
   break;
   
   case UserSegment.WhaleUser:
   // Minimal ads for big spenders
   AdManager.SetInterstitialFrequency(0); // Disable interstitials
   AdManager.EnableRewarded(true); // Keep rewarded ads
   AdManager.EnableBanners(false);
   break;
   }
   }
   }
   

Balancing Monetization and User Experience

Good ad implementation is a trade-off. Every format you add earns money and costs you some goodwill. The job is to find the line where revenue goes up but retention and session length hold steady. Get that balance right and Unity Ads monetization compounds over the life of the game. Get it wrong and you train players to uninstall.

How Each Format Affects the Player

Not all ad formats cost the same in player experience. Rewarded video is opt-in, so the hit is small. Interstitials interrupt, so they need limits. Use this as a quick reference when you decide where each format goes in your Unity Ads setup.

Ad Format	User Experience Impact	Implementation Best Practices
Rewarded Video	Low (user opt-in)	Make rewards valuable; place at resource pinch points; make completion feedback clear
Interstitial	Medium to High	Cap the frequency; never show during active gameplay; place at natural breaks
Banner	Low to Medium	Use standard positions; keep them out of gameplay areas; consider removing them for paying users
Playable	Low (if rewarded)	Match the ad to your audience; make the interaction obvious; give a worthwhile reward

Protecting Retention

The fastest way to hurt retention is to hit new players with ads before they care about your game. Two things keep that from happening: introduce ads gradually, and tie ad pressure to how far a player has progressed.

Ramp ads up over the first week. Start with rewarded ads only, then layer in interstitials once players are hooked. A schedule like this works well as a baseline:

Days Since Install	Recommended Ad Strategy
Day 1	Rewarded ads only, no interstitials
Days 2-3	Add interstitials at low frequency (1 per 10 minutes)
Days 4-7	Standard interstitial frequency (1 per 5-7 minutes)
Day 8+	Tune frequency based on each player's engagement

Scale ad load with player level. A player on level 2 and a player on level 30 should not see the same ad frequency. Read the level from PlayerPrefs, then set interstitial frequency, banners, and rewarded value to match. The example below keeps new players nearly ad-free, runs standard ads for mid-game players, and rewards loyal players with a lighter interstitial cadence and a 20% reward bump:

// Example implementation considering player progress
public class AdProgressionManager : MonoBehaviour
{
private int _playerLevel;

private void UpdateAdStrategy()
{
_playerLevel = PlayerPrefs.GetInt("player_level", 1);

if (_playerLevel < 3)
{
// New players - minimal ads
AdManager.DisableInterstitials();
AdManager.DisableBanners();
AdManager.EnableRewarded(true);
}
else if (_playerLevel < 10)
{
// Established players - standard ads
AdManager.EnableInterstitials(180); // 3 min frequency
AdManager.EnableBanners(true);
AdManager.EnableRewarded(true);
}
else
{
// Advanced players - balance ads with deeper engagement
AdManager.EnableInterstitials(240); // 4 min frequency
AdManager.EnableBanners(true);
AdManager.EnableRewarded(true);
AdManager.IncreaseRewardedValue(20); // 20% more rewards for loyal players
}
}
}

Two rules cover most of this. Lean on rewarded video, since players choose it and it rarely costs retention. And tie ad pressure to engagement and player level instead of showing everyone the same load. That keeps Unity Ads revenue climbing without burning the players who make your game worth monetizing.

Case Studies: Successful Unity Ads Implementations

Two studio examples show what works in practice. Both ran on the Unity Ads SDK and used the Unity Ads dashboard to configure ad units and read reporting.

Case Study 1: Puzzle Game "Color Match"

Game profile:

• Casual puzzle game
• 2.5 million monthly active users
• Free-to-play with in-app purchases

The problem: the studio wanted more revenue but couldn't afford to dent retention. The game already held 45% on day 1 and 22% on day 7, and those numbers were the whole business.

What they did:

• Added rewarded video for extra lives and power-ups
• Added interstitials between levels, but only after level 10
• Split users into segments based on how they played
• A/B tested ad frequency before rolling anything out wide

Results:

• ARPDAU rose 30%, from $0.035 to $0.046
• Retention dropped less than 2%
• Rewarded ads drove 70% of ad revenue
• Total revenue went up 42% once ads and IAP were counted together

What they learned: holding interstitials back until players were hooked cut most of the retention damage. Rewarded video placed at difficulty spikes actually lifted retention by 5%, because players reached for a free continue instead of quitting. Segmenting by play frequency let them run a different ad load for each group rather than one blunt setting for everyone.

Case Study 2: Hypercasual Game "Endless Runner X"

Game profile:

• Hypercasual endless runner
• 5 million monthly active users
• Ads as the main revenue source

The problem: push ad revenue as high as possible without slowing down the short, fast sessions the game depends on.

What they did:

• Interstitial after every third game session
• Rewarded video for continues
• Banners on menu screens only, never during a run
• Frequency cap that adjusted to session length

Results:

• $0.052 ARPDAU across all users
• 78% interstitial completion rate
• 40% rewarded video opt-in rate
• Session length up 15%, driven by continue offers

What they learned: tying the frequency cap to session length beat a fixed cap on total revenue. Rewarded continues didn't just earn impressions, they kept players in the game longer and raised lifetime value. Pulling banners off the gameplay screen lifted retention by 8%, which more than paid for the banner revenue they gave up.

Unity Ads Revenue Optimization Checklist

Run through this checklist before you call a Unity Ads integration finished. It groups the work into setup, placement, format tuning, and ongoing monitoring so nothing falls through the cracks.

Foundation setup

• The Unity Ads SDK is on the current version.
• Every ad unit you use is configured in the Unity Ads dashboard and matches the IDs in your code.
• Basic analytics tracking fires on impressions, completions, and rewards.
• Initialization and error handling are wired up, so a failed init or load does not crash the game or block the next request.

Strategic implementation

• Ad placements line up with the game flow: rewarded at resource pinch points, interstitials at level breaks, banners on menus.
• Frequency capping limits how often interstitials show in a session and how close together they appear.
• You have a user segmentation plan, so new players, non-payers, and payers see different ad loads.
• An A/B testing setup is in place to compare frequencies and placements on live traffic.

Format optimization

• Rewarded videos pay out something players actually want, such as extra lives, currency, or continues.
• Interstitials sit at natural breaks and never interrupt active gameplay.
• Banner positions are chosen for viewability without covering the play area.
• Each format has been tested against real numbers rather than assumed to work.

Performance monitoring

• You review eCPM by region on a regular cadence and adjust strategy for high and low value markets.
• Fill rate is monitored so you can catch drops fast, ideally with mediation backfilling unsold inventory.
• User experience metrics are tracked next to revenue, not in isolation.
• Retention impact is watched after any change to ad frequency or placement.

Advanced features

• The ad experience adapts to user behavior, so different segments get a different load.
• Ad revenue and in-app purchases work together instead of competing for the same players.
• A/B tests run continuously so the setup keeps improving instead of going stale.

Future Trends in Unity Ads (2025 and Beyond)

A few shifts in mobile advertising are changing how you should set up Unity Ads monetization. Here's what to watch and how to prepare for it.

Programmatic bidding

Unity has moved a lot of its inventory from traditional waterfalls to programmatic bidding. With bidding, advertisers compete for each impression in real time instead of being ranked in a fixed waterfall order. Publishers usually see higher eCPMs because the auction sets the price rather than a manual floor.

To get value from it:

• Turn on bidding in your Unity Ads dashboard.
• Collect first-party audience data where you have user consent to do so.
• Run bidding alongside any direct deals you have, rather than replacing them outright, so you keep both demand sources competing.

Privacy-first targeting

GDPR, CCPA, and Apple's App Tracking Transparency (ATT) all limit how ads get targeted. On iOS you have to request tracking permission through ATT, and a custom prompt that explains the value usually lifts opt-in rates before the system dialog appears. On Android you need an equivalent consent flow. Here's a basic consent handler for the Unity Ads SDK:

// Example implementation handling ATT consent (iOS)
#if UNITY_IOS
using Unity.Advertisement.IosSupport;
#endif

public class PrivacyConsentManager : MonoBehaviour
{
void Start()
{
#if UNITY_IOS
if (ATTrackingStatusBinding.GetAuthorizationTrackingStatus() == 
ATTrackingStatusBinding.AuthorizationTrackingStatus.NOT_DETERMINED)
{
// Show custom explanation UI
ShowCustomTrackingDialog();
}
else
{
// Initialize ads normally
InitializeAds();
}
#else
// For Android, implement appropriate consent flow
ShowAndroidConsentDialog();
#endif
}

public void RequestTrackingAuthorization()
{
#if UNITY_IOS
ATTrackingStatusBinding.RequestAuthorizationTracking();
#endif
}

private void ShowCustomTrackingDialog()
{
// Your custom explanation UI before showing the system prompt
// This helps improve opt-in rates
}

private void ShowAndroidConsentDialog()
{
// Your Android consent implementation
}
}

New compensation models

Some studios are testing monetization models that go beyond standard rewarded video:

• Watch-to-earn: players get cryptocurrency or in-app tokens for watching ads.
• Subscription tiers: a paid tier removes ads for players who want a clean experience.
• Hybrid models: a small purchase cuts ad frequency without removing ads entirely.

None of these replaces a solid rewarded and interstitial setup, but they give you levers to pull for different player segments as your Unity Ads monetization matures.

Future Trends in Unity Ads (2025 and Beyond)

A few shifts in mobile advertising are already changing how Unity Ads monetization works. Here are the ones worth planning for now.

Programmatic Bidding Replaces the Waterfall

Unity has pushed further into programmatic bidding, and it changes how inventory gets sold. In a traditional waterfall, networks are called in a fixed order. With real-time bidding, advertisers compete for each impression at the same time, which usually pushes eCPMs higher for publishers.

To get the benefit:

• Turn on programmatic in your Unity Ads dashboard
• Collect audience data where consent allows it
• Run a setup that mixes programmatic demand with your direct deals instead of relying on one or the other

Privacy-First Targeting

GDPR, CCPA, and Apple's App Tracking Transparency have reshaped what targeting data you can use. On iOS you have to ask for tracking permission before you can pass an IDFA, so your Unity Ads SDK setup needs a consent flow that handles both platforms. A short custom screen explaining why you're asking, shown before the system ATT prompt, tends to lift opt-in rates.

// Example implementation handling ATT consent (iOS)
#if UNITY_IOS
using Unity.Advertisement.IosSupport;
#endif

public class PrivacyConsentManager : MonoBehaviour
{
void Start()
{
#if UNITY_IOS
if (ATTrackingStatusBinding.GetAuthorizationTrackingStatus() == 
ATTrackingStatusBinding.AuthorizationTrackingStatus.NOT_DETERMINED)
{
// Show custom explanation UI
ShowCustomTrackingDialog();
}
else
{
// Initialize ads normally
InitializeAds();
}
#else
// For Android, implement appropriate consent flow
ShowAndroidConsentDialog();
#endif
}

public void RequestTrackingAuthorization()
{
#if UNITY_IOS
ATTrackingStatusBinding.RequestAuthorizationTracking();
#endif
}

private void ShowCustomTrackingDialog()
{
// Your custom explanation UI before showing the system prompt
// This helps improve opt-in rates
}

private void ShowAndroidConsentDialog()
{
// Your Android consent implementation
}
}

On Unity Ads Android, build the equivalent consent step into your initialization path so you stay aligned with regional rules before the first ad request fires.

New Compensation Models

Some studios are testing monetization beyond the standard ad mix:

• Watch-to-earn, where players get crypto or in-app tokens for viewing ads
• Subscription tiers that remove ads for paying users
• Hybrid models that cut ad frequency in exchange for a small purchase

None of these replace a solid unity 3d ads setup, but they're worth watching as you decide how aggressive your ad load should be for different segments. Pair any of them with unity mediation so you can keep comparing real eCPM across demand sources as the market moves.