AppLovin MAX: Setup, Bidding and Earnings

AppLovin MAX is a mediation platform: one SDK in your app that asks many ad networks, including AppLovin's own, to compete for every ad request, with a dashboard where you control which networks take part. You still earn from the individual networks, and MAX decides who wins each impression.

On our benchmark tables AppLovin's own demand sits at the top for Tier 1 rewarded video, about $14.50 eCPM against $12.00 for AdMob, with 90% fill against 88%. Those are modelled estimates, and they describe AppLovin as a network, not what MAX will do for your particular app. What MAX adds is the machinery around that demand: an auction, price syncing for networks that do not bid, A/B tests and reporting.

This guide covers how MAX works, how to set up an account and ad units, what the Android integration looks like, how to test it, how payment works and where MAX is weaker than the alternatives. Menu names and code come from AppLovin's MAX documentation, starting with its getting started guide.

What MAX is, and how the auction works

In MAX, every ad unit has a waterfall page in the dashboard, but it behaves differently from the classic ranked list. Networks come in two kinds. Bidder networks return a live price for each impression. Other networks, the traditionally mediated ones, sit at a CPM price you enter (or that MAX syncs for you). AppLovin's docs say both kinds compete by highest CPM to serve an impression, in what the docs call the unified auction.

That is the practical meaning of the term. A bidder that offers $11 beats a traditional network priced at $9, and the traditional network at $9 beats a bidder offering $7. Nothing is called in strict order. If you want the theory, bidding versus waterfall explains why live prices usually beat static rankings, and mediation or a single network covers whether you need mediation at all.

AppLovin's own demand arrives through two channels, Ads Manager and the AppLovin Exchange, and it is switched on by default. Everything else you connect yourself. The list of bidder networks in AppLovin's guides includes Google, Meta Audience Network, Unity Ads, ironSource Ads, Liftoff Monetize, InMobi, Chartboost, Mintegral, Pangle, Moloco, Smaato and others. Google appears there as a bidder, which matters for the AdMob question later.

Custom networks, meaning ones MAX does not support officially, can be added through a custom SDK connection. They are not eligible for in-app bidding or auto-CPM, and AppLovin says it cannot troubleshoot them.

Set up the account and ad units

Account creation is not instant. AppLovin creates your account, and the docs say it may need to approve it before you finish setup. Once you are in, do these three things first:

1. Payment details: Account > Payments > Info, until you reach the step labelled Done.
2. Developer domain: Account > General > Basic Info > Domain. Enter the root domain only, such as yourdomain.com. It must match the website in your store listing, because that is where your app-ads.txt lives.
3. Ad units: MAX > Mediation > Manage > Ad Units. Choose the platform (Android, Fire OS or iOS), add your app, choose a format and name the unit.

AppLovin strongly recommends a single ad unit ID per format in each app. That keeps one ad always cached and avoids wasted bandwidth. If your app is not live yet, use Manually Add Your Package Name and type the package name with the same capitalization as in your code.

You will need the ad unit ID and your SDK key. The SDK key is in Account > General > Keys.

Integrate the SDK on Android

The SDK needs a minimum SDK version of 24, according to the Android integration page. Add it to your app-level build.gradle, with google() and mavenCentral() in the repositories block:

dependencies {
    implementation 'com.applovin:applovin-sdk:+'
}

The SDK collects the Google Advertising ID, so it also needs the Android Advertising ID module (com.google.android.gms:play-services-ads-identifier). AppLovin's page says the ProGuard rules ship inside the AARs, so you add none.

Initialization is where most first-time mistakes happen. Create a configuration with your SDK key and the MAX mediation provider, then initialize as early as possible, for example in the launch Activity or your Application class. Starting early gives mediated networks time to cache ads. Do not load ads until the callback fires.

val initConfig = AppLovinSdkInitializationConfiguration.builder("YOUR_SDK_KEY")
    .setMediationProvider(AppLovinMediationProvider.MAX)
    .build()

AppLovinSdk.getInstance(this).initialize(initConfig) { sdkConfig ->
    // start loading ads
}

Optional extras like Ad Review (a Gradle plugin that lets you inspect creatives from the dashboard, with a key from Account > General > Keys) and the Terms and Privacy Policy flow are on the same integration page. Turn Ad Review on early; hunting down a bad creative without it is miserable.

Load and show an interstitial

For the rewarded and interstitial formats, MAX wants ads preloaded. Create the ad object with your ad unit ID, set a listener, call loadAd(), and show only when isReady() is true. Two behaviours are required by AppLovin's checklist: retry failed loads with exponentially longer delays up to a cap (the sample caps at 64 seconds), and load the next ad as soon as the current one is dismissed. Skipping either costs impressions.

class ExampleActivity : Activity(), MaxAdListener {
    private lateinit var interstitialAd: MaxInterstitialAd
    private var retryAttempt = 0

    fun createInterstitialAd() {
        interstitialAd = MaxInterstitialAd("YOUR_AD_UNIT_ID", this)
        interstitialAd.setListener(this)
        interstitialAd.loadAd()
    }

    override fun onAdLoaded(ad: MaxAd) { retryAttempt = 0 }

    override fun onAdLoadFailed(adUnitId: String, error: MaxError) {
        retryAttempt++
        val delayMillis = TimeUnit.SECONDS.toMillis(
            Math.pow(2.0, minOf(6, retryAttempt).toDouble()).toLong())
        Handler(Looper.getMainLooper()).postDelayed({ interstitialAd.loadAd() }, delayMillis)
    }

    override fun onAdDisplayFailed(ad: MaxAd, error: MaxError) { interstitialAd.loadAd() }
    override fun onAdHidden(ad: MaxAd) { interstitialAd.loadAd() }
    override fun onAdDisplayed(ad: MaxAd) {}
    override fun onAdClicked(ad: MaxAd) {}
}

Show it with if (interstitialAd.isReady) interstitialAd.showAd(this). The Kotlin above follows the shape of AppLovin's Java sample; compare it with the current interstitial page before you paste anything, since listener signatures change between SDK versions. Rewarded ads follow the same pattern. Our guide to rewarded and interstitial formats covers where to place them.

Banners are the odd one. AppLovin says to keep the banner on screen, because MAX controls the refresh rate and networks invalidate impressions if the banner is hidden behind other content.

Add networks and build the waterfall

SDK integration is half of it. Each network also needs three things on its own side: an account, your app and ad unit registered there, and approval to serve ads. Then you add the adapter. AppLovin recommends Gradle for adapters, since the adapter's POM file pulls in the network's SDK and its dependencies. The Preparing mediated networks page has a checkbox tool that writes the Gradle block for the networks you choose. One warning from that page: never rename an adapter or change its package name, or MAX will not recognise it and ads will not load.

Back in the dashboard:

1. Connect the network. MAX > Mediation > Manage > Networks, click Connect, enter the credentials or API key and click Save. A green tick means it worked; red or yellow means action is needed. Connecting lets MAX pull network data for bidding and CPM updating.
2. Enable it in the ad unit. On the Ad Units page, open the unit and scroll to Default Waterfall. Expand the network, add its network IDs, and switch Status on. Only enable a network you have both integrated and connected.
3. Set a CPM for non-bidders. Enter the price floor or historical CPM you have with that network.

Use bidders where you can. AppLovin's best practice list suggests adding at least six networks with strong global demand besides AppLovin when you are starting out, prioritising bidding networks to cut manual maintenance and latency, and later building geo-based waterfalls for countries where specific networks are strong. Six is a vendor recommendation. For a small studio, three or four well-set-up networks that you actually monitor beat six that you do not.

Auto-CPM for networks that do not bid

A manually entered CPM goes stale, and a stale CPM means the network competes with the wrong price. Auto-CPM fixes this by syncing the price to what the network reports. Per AppLovin's page, it updates daily from the last seven days of average network CPM, weighted toward recent data, at ad unit, placement and country level. A network ID needs at least 1,000 impressions in the past seven days before updating starts, and custom networks cannot use it.

To switch it on, enter a starting price that matches the network's floor or history, connect the network on the Networks page, then flip the auto-CPM toggle on the Manage Network page. Check the Network Comparison report weekly; AppLovin says to contact your account team if CPM or revenue discrepancies exceed 5%.

Custom waterfalls

The default waterfall serves everyone. Custom waterfalls (Create New Waterfall above the Default Waterfall) let you tailor networks and prices by device targeting, for example for users with limit ad tracking on. Traffic that does not match a custom waterfall falls back to the default. MAX copies the default settings as your starting point.

Test before you release

AppLovin builds in three tools, and they overlap, so use them in order.

Mediation Debugger. Call AppLovinSdk.getInstance(this).showMediationDebugger() from a debug build. It lists networks under Completed Integrations, Incomplete Integrations and Missing Integrations, and flags problems such as an SDK and adapter version mismatch. It also shows a row for app-ads.txt, which turns green when entries for AppLovin are found at your developer domain. It does not support custom SDK networks.

Test ads. Pick a completed network, tap Enable under Test Ad, restart the app so the network initializes with test credentials, then select it again to load a test ad. You can also pass test device advertising IDs in the initialization configuration, and check the logs for Test Mode On: true. AppLovin does not track impressions, clicks or revenue for test ads. No-fills during testing are common and usually not an integration fault.

Live ads. The debugger can load an ad through your actual waterfall, or isolate a single bidding network as the only source. AppLovin warns that testing live traffic can look like fraud to some networks, so keep it brief and use test ads for most of the work.

Two points from the pre-launch checklist are easy to forget. Set privacy flags before the first ad request. And if you previously used a network SDK through another mediator, such as Google bidding via AdMob mediation, create a new application ID for it or delete the active mediation groups, because reusing an ID causes crashes and discrepancies. Our AdMob mediation setup guide shows where those groups live.

A/B test every change

MAX has A/B testing built into the ad unit, and it is the feature most worth learning. Go to MAX > Mediation > Manage > Ad Units, open the unit, use the three-dot menu on the Default Waterfall tab and choose Create A/B Test. MAX copies your waterfall, applies the test to 50% of users by default (you can change Test Group Allocation) and gives you a Control/Test toggle to edit the test side only. Name tests with a start time, as AppLovin suggests.

Watch requests, impressions and revenue for 24 to 48 hours in Advanced Reporting or MAX > Mediation > Analyze > A/B Tests. A result page appears the day after a test group passes 10,000 impressions. AppLovin's rule of thumb is to promote a change that has been stable for 24 hours, above 10,000 impressions a day and above 2% incrementality, and to deprecate anything that does not lift ARPDAU. For what that metric means, see ARPDAU and LTV.

Good first tests: add one new bidder, then remove the weakest network to check it was contributing, then test a price change on a non-bidder.

Reports, payment and app-ads.txt

For reports, Advanced Reporting is the workhorse. Add Application, Ad Unit Name and Ad Type for inventory performance. Add Network to see fill rate and win rate, where win rate is how often a bidder wins against other bidders. Add Waterfall and filter to one ad unit to compare waterfalls, and Country for a finer cut. The User activity report gives daily active users, ARPDAU and impressions per user, handy if you have no attribution tool. Reading these alongside fill rate tells you whether a problem is demand or code.

Payment is split, which surprises people. AppLovin pays you for revenue from its own Ads Manager and AppLovin Exchange. Every other network pays you on its own terms and schedule. AppLovin impressions served through Google Open Bidding are paid by Google. For AppLovin's share, the payment FAQ gives a $100 minimum, payment monthly around the 15th of the following month (net 15), and methods that include direct deposit, wire, check and PayPal, subject to local rules. Earnings below $100 roll over to the next month. Our guide on receiving payouts abroad covers fees on the way in.

For app-ads.txt, get AppLovin's lines from Account > General > App-ads.txt Info and add the other networks' lines too. AppLovin states that many advertisers do not bid on apps without a valid file, and the file must be UTF-8 and served as text/plain. The Google Play app-ads.txt guide shows the hosting steps. If your app is aimed at children, note that AppLovin's own docs say it is not part of the Families Self Certified Ads SDK Program, so read ads in kids apps before adding it. For European users, a working consent message is still your job.

MAX compared with AdMob mediation and LevelPlay

The rows show each company's own demand in our tables. They are not a ranking of the mediation tools. Here is an example with assumptions: 200,000 Tier 1 rewarded requests a month. AdMob's own demand alone gives 176,000 impressions at $12.00, about $2,112. AppLovin's gives 180,000 at $14.50, about $2,610. The gap is roughly $498, or 24%, and a mediation layer can capture some of it without making you pick one. The AppLovin MAX revenue calculator lets you put in your own mix, and the AdMob versus AppLovin page sets the two side by side.

The honest strengths of MAX are the unified auction, auto-CPM, built-in A/B testing and Network Comparison reporting. The weaker points: account approval is manual, you depend on one vendor that is also a seller in the auction, the dashboard has more moving parts than AdMob's, and AppLovin is not part of the Families Self Certified Ads SDK Program, which rules it out for many children's apps. If your app is already tuned inside AdMob, the AdMob mediation guide may get you most of the benefit with less change. Studios on Unity should read the LevelPlay guide and the AppLovin versus ironSource comparison before choosing.

Common questions

Why do my test ads not load?

No-fills during testing are common and usually do not mean the integration is broken, according to AppLovin. Check the logs for Test Mode On: true, give slow-starting networks a few seconds after initialization, and try a live ad through the Mediation Debugger if test ads stay empty.

Can I run AdMob and MAX together?

Yes, because Google bidding is one of the bidder networks inside MAX, and AdMob is an ad source there. What you should not do is run two mediation layers over the same ad units without thought. Move one ad format at a time and use a separate app ID, as AppLovin's checklist warns.

Does MAX work for a small game?

It can, but results depend on volume. Auto-CPM needs 1,000 impressions per network ID over seven days, and A/B results appear once a test group passes 10,000 impressions. A game with a few hundred daily users will wait a long time for either.

What to do next

Open the AppLovin MAX revenue calculator and enter your daily users and country mix, then compare with the AppLovin estimates for your app category. If the gain looks worth a day of work, create the account, integrate on one format first, check it with the Mediation Debugger, and keep the first A/B test small.