AdMob & Meta ads, end to end

The short version

Everything that goes wrong in practice falls into one of five buckets: setup (app-ads.txt, app verification, mapping Meta placements), consent (a missing GDPR message or partner list), code (initialising late, loading on demand instead of preloading), policy (accidental clicks, disruptive interstitials) and expectations (eCPM varies wildly by country and format). Each has its own section below.

What changed recently

Most tutorials online predate these changes. If a guide shows play-services-ads as the only option or a Meta waterfall setup, it is out of date.

1. 2021Meta Audience Network becomes bidding-only. The adapter drops waterfall support from v6.12.0.0.Meta
2. Jan 2025AdMob requires app-ads.txt verification for new apps before they can fully serve ads; existing apps rolled in through 2025.AdMob
3. Oct 2025Google retires Privacy Sandbox on Android (Topics, Protected Audience, Attribution Reporting, SDK Runtime). The Advertising ID (GAID) stays.Platform
4. Nov 2025India notifies the DPDP Rules, 2025, with core consent obligations phased in over 18 months.Privacy
5. Jan 2026GMA Next-Gen SDK enters open beta: a Kotlin rewrite with background initialisation and ad preloading.AdMob
6. Feb 2026Legacy SDK 25.0.0: large anchored adaptive banners, removal of old mediation callbacks; 23.x deprecated.AdMob
7. Jun 30 2026Legacy SDK 22.x reaches sunset.AdMob
8. Jul 2026Next-Gen SDK becomes Google's preferred Android SDK; the legacy 25.x line gets a retirement schedule.AdMob
9. TodaySeptember 2026: best time to build new integrations on Next-Gen.
10. May 13 2027DPDP consent notices and data-principal rights apply in India, including verifiable parental consent for users under 18.Privacy
11. Jun 30 2027Legacy SDK deprecated: ads still serve, Google support ends.AdMob
12. Jun 30 2028Legacy SDK sunset: ads may stop serving and outdated-SDK warnings can block app releases.AdMob

The ad marketplace

Mobile advertising is a two-sided market. Advertisers bring budgets; publishers (you) bring attention. Ad platforms sit in the middle, match the two in milliseconds, and take a cut.

Who is who

How AdMob and Meta fit together

You have three realistic setups. The difference is whether Meta and Google compete for the same impression.

Ad formats

Format choice decides both revenue and how users feel about your app. Full-screen formats pay more per impression and carry most of the policy risk.

Relative eCPM is a typical ordering, not a promise. Actual prices vary by country, season (Q4 is highest), audience and app category, often by 5–20× between markets.

Life of an ad request

What actually happens between your app launching and a rupee (or cent) landing in your account. This order matters: consent gates initialisation, initialisation gates signals, and signals decide whether Meta can bid at all.

Step by step, in plain words

1. Consent (1–2). The UMP SDK checks the user's region. In the EEA, UK, Switzerland and US states with privacy laws it may show a consent or opt-out message you configured in AdMob. The result is a stored consent string that later requests carry.
2. Initialise (3–4). MobileAds.initialize() starts Google's SDK and every mediation adapter on the classpath. The Meta adapter initialises Meta's SDK. Next-Gen runs this on a background thread.
3. Request (5–7). You ask for an ad on a specific ad unit ID. The SDK bundles device and app signals: ad ID (if permitted), country, OS, app version, consent, and each bidding adapter's token.
4. Auction (8–11). AdMob sends bid requests to bidding partners, including Meta, collects bids, compares them with Google's own demand and any waterfall sources, and returns the winner's ad.
5. Show (12–13). With preloading the ad waits in a pool until you call show(). If Meta won, the adapter renders Meta's creative using Meta's SDK.
6. Count and pay (14–16). The impression is recorded when the ad actually renders. Clicks and video completions are tracked. The paid event reports the estimated value, which you can forward to analytics.

Bidding vs waterfall

Two ways a mediation platform can decide who fills an impression. Meta only supports the second.

Metrics and money

Revenue is a chain of rates. Every drop in the chain is a place to look when numbers disappoint.

The funnel (example numbers)

Show rate drops when you preload ads that are never shown (user leaves before the break). Low show rate is a code problem; low fill is a demand or setup problem.

Formulas you'll use every week

Revenue estimator

Replace the example inputs with numbers from your AdMob report (Reports → Mediation, grouped by format).

How you get paid

Account setup

Most "ads not showing" problems are dashboard problems, not code problems. Do these in order.

1. Get the Play listing ready

   AdMob verifies apps against their store listing. Publish the app (or prepare the listing) and set a developer website in Play Console → Store settings. That domain will host app-ads.txt.

2. Create the AdMob app and ad units

   • AdMob → Apps → Add app → link it to the Play listing. Note the App ID (ca-app-pub-…~…).
   • Create one ad unit per placement (e.g. home_banner, level_end_interstitial, extra_life_rewarded). Note each ad unit ID (ca-app-pub-…/…). Separate units give you per-placement reports and controls.

3. Publish app-ads.txt and verify

   Host a plain-text file at https://yourdomain.com/app-ads.txt (domain root, not a subfolder). Then AdMob → App settings → Verify app. Apps can't fully serve ads until verification and the app readiness review pass.

   app-ads.txtcopy exact lines from each dashboard

   # Google AdMob (your publisher ID)
   google.com, pub-XXXXXXXXXXXXXXXX, DIRECT, f08c47fec0942fa0
   # Meta Audience Network (line shown in Monetization Manager)
   facebook.com, YOUR_META_ID, DIRECT, c3e20eee3f780d68

4. Configure privacy messages

   AdMob → Privacy & messaging. Create a European regulations (GDPR) message and a US state regulations message. The UMP SDK shows whatever you publish here, so there's no consent UI to design yourself.

5. Set up AdMob payments

   Add payee name and address (must match your bank), tax information, and a bank account once you cross the thresholds. Verify the mailed PIN when it arrives.

6. Set up Meta Audience Network

   • Create a Meta Business account, open Monetization Manager and create a property for your app with the Android platform and package name.
   • Choose Google AdMob as your mediation platform.
   • Create a placement for each AdMob ad unit you want Meta to bid on, in the matching format. Note each placement ID.
   • Add Meta's line to app-ads.txt, and set up payout and tax details. Meta reviews properties before live ads serve.

7. Connect Meta inside AdMob

   • AdMob → Mediation → create (or edit) a mediation group for Android and the format; add your ad units.
   • Under Bidding, add Meta Audience Network and accept the bidding partnership agreement.
   • Map each AdMob ad unit to its Meta placement ID.
   • Privacy & messaging → add Meta to the ad partners lists for both GDPR and US state regulations. Skip this and Meta can't bid on those users.

8. Complete Play Console declarations

   App content → Ads (contains ads: yes), Advertising ID declaration, Target audience, and Data safety including what the Google and Meta SDKs collect (both publish guidance for this form).

Code integration

Versions below are current as of September 2026. Check the release notes before copying: adapter versions track Meta SDK versions and move often.

1 · Dependencies

dependencies {
  implementation("com.google.android.libraries.ads.mobile.sdk:ads-mobile-sdk:1.4.0")
  implementation("com.google.android.ump:user-messaging-platform:<latest>")
  // Meta bidding adapter — also brings in Meta's Audience Network SDK
  implementation("com.google.ads.mediation:facebook:6.22.0.0")
}

// Keep the legacy SDK out of a Next-Gen build (adapters can pull it in)
configurations.configureEach {
  exclude(group = "com.google.android.gms", module = "play-services-ads")
  exclude(group = "com.google.android.gms", module = "play-services-ads-lite")
}

dependencies {
  implementation("com.google.android.gms:play-services-ads:25.4.0")
  implementation("com.google.android.ump:user-messaging-platform:<latest>")
  implementation("com.google.ads.mediation:facebook:6.22.0.0")
}

2 · Manifest and network config

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  <!-- Added automatically by the ads SDK. Child-directed apps must remove it
       with tools:node="remove". -->
  <uses-permission android:name="com.google.android.gms.permission.AD_ID" />

  <application
      android:networkSecurityConfig="@xml/network_security_config">
    <!-- AdMob App ID (note the ~). UMP reads it from here. -->
    <meta-data
        android:name="com.google.android.gms.ads.APPLICATION_ID"
        android:value="ca-app-pub-XXXXXXXXXXXXXXXX~YYYYYYYYYY" />
  </application>
</manifest>

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
  <!-- Meta's SDK serves cached media from localhost. Android 9+ blocks
       cleartext by default, so allow it for 127.0.0.1 only. -->
  <domain-config cleartextTrafficPermitted="true">
    <domain includeSubdomains="true">127.0.0.1</domain>
  </domain-config>
</network-security-config>

If you already have a network security config, merge this domain block into it instead of replacing the file.

3 · Consent first, then initialise

Gather consent before any ad request. Call canRequestAds() right away too, because consent from a previous session is usually still valid and you shouldn't make returning users wait.

class MainActivity : AppCompatActivity() {
  private lateinit var consentInformation: ConsentInformation
  private val adsInitStarted = AtomicBoolean(false)

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    consentInformation = UserMessagingPlatform.getConsentInformation(this)
    val params = ConsentRequestParameters.Builder().build()

    consentInformation.requestConsentInfoUpdate(this, params, {
      UserMessagingPlatform.loadAndShowConsentFormIfRequired(this) { formError ->
        // formError is null on success; log it otherwise
        if (consentInformation.canRequestAds()) initializeAds()
      }
    }, { requestError ->
      // Network failure etc. Fall through to the check below.
    })

    // Returning users: consent from last session may already allow ads
    if (consentInformation.canRequestAds()) initializeAds()
  }

  private fun initializeAds() {
    if (adsInitStarted.getAndSet(true)) return
    CoroutineScope(Dispatchers.IO).launch {
      MobileAds.initialize(
        this@MainActivity,
        InitializationConfig.Builder("ca-app-pub-XXXXXXXXXXXXXXXX~YYYYYYYYYY").build()
      ) {
        // All adapters (including Meta) have reported in. Start preloading.
        startPreloading(INTERSTITIAL_UNIT)
      }
    }
  }
}

Add a Privacy settings entry in your app's settings screen when consentInformation.privacyOptionsRequirementStatus == REQUIRED, and open UserMessagingPlatform.showPrivacyOptionsForm(activity) { … } from it. Users must be able to change their choice later.

4 · Load and show ads

private fun startPreloading(adUnitId: String) {
  val request = AdRequest.Builder(adUnitId).build()
  InterstitialAdPreloader.start(adUnitId, PreloadConfiguration(request))
}

// Call at a natural break, e.g. after a level ends
private fun showInterstitial(activity: Activity, adUnitId: String) {
  val ad = InterstitialAdPreloader.pollAd(adUnitId) ?: return  // none ready: just continue
  ad.adEventCallback = object : InterstitialAdEventCallback {
    override fun onAdImpression() { /* counted */ }
    override fun onAdDismissedFullScreenContent() { /* resume the app */ }
    override fun onAdFailedToShowFullScreenContent(error: FullScreenContentError) { }
  }
  ad.show(activity)
}

private fun showRewarded(activity: Activity, adUnitId: String) {
  val ad = RewardedAdPreloader.pollAd(adUnitId)
  if (ad == null) { showNoAdAvailableMessage(); return }

  // Optional: server-side verification for valuable rewards
  ad.setServerSideVerificationOptions(
    ServerSideVerificationOptions.Builder().setCustomData(userId).build()
  )
  ad.show(activity) { rewardItem ->
    grantReward(rewardItem.amount)   // the only safe place to grant
  }
}

<!-- layout -->
<com.google.android.libraries.ads.mobile.sdk.banner.AdView
    android:id="@+id/adView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

// Kotlin
val adSize = AdSize.getLargeAnchoredAdaptiveBannerAdSize(activity, 360)
val request = BannerAdRequest.Builder(BANNER_UNIT, adSize).build()
adView.loadAd(request, object : AdLoadCallback<BannerAd> {
  override fun onAdLoaded(ad: BannerAd) { }
  override fun onAdFailedToLoad(adError: LoadAdError) { /* collapse the slot */ }
})

// onDestroy
(adView.parent as? ViewGroup)?.removeView(adView)
adView.destroy()

private var interstitial: InterstitialAd? = null

fun loadInterstitial(context: Context) {
  InterstitialAd.load(context, INTERSTITIAL_UNIT, AdRequest.Builder().build(),
    object : InterstitialAdLoadCallback() {
      override fun onAdLoaded(ad: InterstitialAd) { interstitial = ad }
      override fun onAdFailedToLoad(error: LoadAdError) { interstitial = null }
    })
}

fun showInterstitial(activity: Activity) {
  interstitial?.show(activity)
  interstitial = null
  loadInterstitial(activity)   // one ad = one show; load the next
}

Testing

Google's test IDs

Test IDs only exercise Google demand. To test Meta, use your real ad units on a registered test device, as below. Keep IDs in buildConfigField per build type so release builds can never ship test IDs.

Testing Meta through AdMob

1. Register the device in AdMob

   AdMob → Settings → Test devices. Pick a gesture (shake or flick) to open Ad Inspector on that device.

2. Turn on test mode in Meta

   Monetization Manager → your property → testing. The Facebook app must be installed and logged in on the test device. Meta's own testing guide also lets you register device IDs.

3. Force a Meta win in Ad Inspector

   Open Ad Inspector → your ad unit → single ad source testing → "Meta Audience Network (Bidding)". Load an ad and confirm the adapter status is green and a Meta test creative renders.

4. Test consent from outside Europe

   Use ConsentDebugSettings with DEBUG_GEOGRAPHY_EEA and your hashed device ID (printed in Logcat) to see the GDPR form. Call consentInformation.reset() between runs.

5. Switch Meta test mode off before release

   Test mode left on means no revenue from Meta.

Privacy and consent

Consent decides whether an ad is personalised, limited, or not requested at all, and it decides which partners may bid. Getting it wrong costs revenue in the best case and fines in the worst.

The Advertising ID (GAID)

• The AD_ID permission is required for apps targeting Android 13+ to read the ID; the ads SDK adds it for you, and you must complete the Advertising ID declaration in Play Console.
• Users can delete their ad ID. The SDK then receives zeros; ads still serve but usually earn less.
• Play policy forbids linking the ad ID to persistent identifiers (Android ID, IMEI, email) for ad purposes without explicit consent.
• Privacy Sandbox on Android was retired in October 2025, so there is no replacement API to migrate to. The ad ID plus consent remain the model.

Policies and invalid traffic

Three rulebooks apply at once: AdMob program policies, Meta Audience Network policies, and Google Play's ads policy. Advertisers pay for real attention, so anything that inflates impressions or clicks is treated as fraud, even if accidental.

What enforcement looks like

Optimisation and reporting

Which report answers which question

Troubleshooting

Ticks are saved in this browser only.

• Developer website set in Play listing; app-ads.txt live at its root with Google and Meta lines
• App verified in AdMob and readiness review passed
• One ad unit per placement, IDs stored per build type (test IDs in debug only)
• GDPR and US state messages published in Privacy & messaging
• Meta property approved, placements created, payout and tax details done
• Meta added under Bidding in each mediation group, placement IDs mapped
• Meta added to GDPR and US state ad partner lists
• SDK, UMP and Meta adapter dependencies on current versions; no duplicate SDKs
• App ID in manifest; network security config allows 127.0.0.1
• Consent gathered before any ad request; privacy options entry in settings
• SDK initialised in the background; full-screen ads preloaded
• Placements reviewed against the do/don't list (no accidental clicks, no launch/exit interstitials)
• Ad Inspector shows Meta adapter ready and a Meta test ad renders
• Meta test mode switched off
• Play Console: Ads, Advertising ID, Target audience and Data safety declarations complete
• AdMob linked to Firebase; ARPDAU and retention dashboards ready
• AdMob payment profile, address PIN and tax info complete

Glossary

Ad unit

An AdMob placement with its own ID (ca-app-pub-…/…), format and settings. The thing your code requests.

Placement (Meta)

Meta's equivalent of an ad unit. Mapped one-to-one to an AdMob ad unit for bidding.

Mediation

Letting one platform choose among several ad networks for each request.

Mediation group

AdMob rule set: which ad units, countries and sources compete together.

Adapter

A small library that translates between the Google Mobile Ads SDK and another network's SDK.

Bidding

Real-time auction where each network prices the specific impression. Also called in-app header bidding.

Waterfall

Legacy method: ask networks one at a time in a fixed order by expected eCPM.

Signals / bidder token

Data an adapter generates on-device so its network can bid server-to-server.

eCPM

Effective revenue per 1,000 impressions, whatever the advertiser actually paid for.

Fill rate

Share of ad requests that returned an ad.

Show rate

Share of returned ads that were actually displayed.

ARPDAU

Average revenue per daily active user.

Floor

Minimum eCPM you'll accept for an impression.

app-ads.txt

IAB standard file listing who is authorised to sell your app's inventory. Blocks spoofing; required by AdMob.

UMP

Google's User Messaging Platform SDK. Shows GDPR and US state privacy messages you design in AdMob.

TCF / AC string

IAB Transparency & Consent Framework consent string, plus Google's Additional Consent string for vendors outside the IAB list, like Meta.

LDU

Meta's Limited Data Use flag for US state privacy laws.

GAID

Google Advertising ID. Resettable, deletable device ID for ads.

SSV

Server-side verification: AdMob calls your server when a rewarded ad completes, so rewards can't be faked client-side.

IVT

Invalid traffic: clicks or impressions that aren't genuine user interest. Deducted from earnings.

Ad Inspector

In-app debug overlay showing each request, each source's result and errors on test devices.

Sources

1. Next-Gen SDK as the preferred SDK for Android (Jul 2026)
2. Announcing the GMA Next-Gen SDK (Jan 2026)
3. Android Google Mobile Ads SDK 25.0.0
4. Set up GMA Next-Gen SDK
5. Integrate Meta Audience Network with bidding (Next-Gen)
6. Integrate Meta Audience Network with bidding (legacy)
7. Next-Gen interstitial ads
8. Next-Gen rewarded ads
9. Next-Gen banner ads
10. UMP SDK for Next-Gen
11. AdMob bidding FAQ
12. Bidding ad sources that require setup
13. Verify your app with app-ads.txt
14. About app readiness
15. AdMob payment thresholds
16. About Audience Network payments (Meta)
17. Update on plans for Privacy Sandbox technologies
18. Legacy Mobile Ads SDK retirement timeline (PPC Land)
19. DPDP Rules, 2025 (PIB)
20. DPDP Rules implementation timeline