How to Add AdMob Ads to a WebView App (Step by Step, 2026)

WebView apps are one of the fastest ways to ship a mobile app — wrap your existing website in a native container and you're done. But getting paid is a different story. AdMob is the right monetization tool for this, and the setup is simpler than most tutorials suggest. This guide covers every step: from creating your AdMob account through displaying live ads, plus the policy traps that get accounts banned.

What Is AdMob and Why Use It in a WebView App?

AdMob is Google's mobile ad platform, and it's the standard way to monetize a WebView app. It serves ads from Google's demand pool — the same advertisers that run Google Search and Display campaigns — so fill rates are high and eCPMs are competitive from day one.

WebView apps are a good fit for AdMob for one specific reason: the ads sit in the native layer, outside the WebView itself. That means you get mobile ad rates (which outperform desktop web rates) without any changes to your website's HTML. Your website stays exactly as it is. The SDK adds revenue on top of it.

AdMob supports four main ad formats:

• Banner — a small strip at the top or bottom of the screen, always visible.
• Interstitial — a full-screen ad shown at natural transition points, like after a user completes an action.
• Rewarded — a full-screen video the user opts into in exchange for a reward.
• Native — an ad styled to match your app's UI. Rarely used in WebView apps.

You can run multiple formats in the same app. Most WebView apps start with a banner (always on) and add interstitials at page-load transitions. Ads are only one revenue channel — see our full guide to mobile app monetization strategies for subscriptions, in-app purchases, and affiliate models.

What Changed in 2025–2026 (AdMob + WebView Updates)

Three changes between 2025 and 2026 directly affect WebView apps using AdMob. If you're following a tutorial from 2023 or earlier, some of it is outdated.

Google Play's WebView Policy (Enforced 2024–2025)

Google tightened enforcement of its policy against apps that do nothing but wrap a website. Apps without meaningful native functionality — push notifications, offline mode, custom navigation, or similar — are now rejected during review. This affects AdMob indirectly: a rejected app can't show ads. If you're building a thin WebView wrapper, add at least one native feature before publishing. We break down the exact requirements in what makes a WebView app good enough for the app stores, and the Apple equivalent in Apple Guideline 4.2 for WebView apps.

Google Mobile Ads SDK v23+

The Mobile Ads SDK reached version 23 in late 2024. The API for loading interstitials changed: InterstitialAd.load() now uses a callback-based pattern instead of the old listener approach. If you're copying code from pre-2024 tutorials, the interstitial loading section will produce compile errors. The step-by-step section below uses the current v23 API.

ATT Prompt Requirement on iOS (Stricter Review)

Apple has enforced the App Tracking Transparency (ATT) prompt more strictly since iOS 17. Any AdMob-enabled iOS app that doesn't show the ATT prompt before initializing the SDK risks App Store rejection. The Google Mobile Ads SDK now ships with a User Messaging Platform (UMP) SDK for consent handling — you must integrate it, not skip it.

Adaptive Banners Replace Smart Banners

Smart banners are deprecated. Adaptive banners auto-size to the device's width and content density, produce higher eCPMs, and are now the default recommendation. Any tutorial still using AdSize.SMART_BANNER is using a deprecated API — switch to AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(context, width).

Prerequisites Before You Start

You need four things before writing a single line of code.

1. A working WebView app. Android Studio project with a WebView in your layout, or Xcode project with a WKWebView. If you haven't built one yet, start with converting your website to an Android app using WebView + Android Studio. The app should load your site and run without crashes.
2. An AdMob account. Free to create at admob.google.com. You need a Google account. Payment activation (address verification, tax forms) can happen after you've confirmed the integration works.
3. A privacy policy. AdMob requires one. It must disclose that your app shows interest-based advertising and uses device advertising identifiers. Host it on a URL you control and link to it from the Play Store listing and from within the app. You'll also declare AdMob's data collection in Google Play's Data Safety form — advertising IDs must be disclosed there.
4. Minimum SDK versions. Android: minSdkVersion 21 or higher. iOS: iOS 13 or higher. The current Google Mobile Ads SDK drops support for older OS versions — check the release notes if you need to support anything older.

Step-by-Step: Adding AdMob to an Android WebView App

The full integration takes 7 steps and roughly 30 minutes for a developer who has done it before. For a first-timer, plan for an hour — the account setup side is mostly waiting for pages to load.

implementation 'com.google.android.gms:play-services-ads:23.6.0'

Replace 23.6.0 with the latest version from the AdMob Android release notes. Click Sync Now in Android Studio after saving.

<meta-data
    android:name="com.google.android.gms.ads.APPLICATION_ID"
    android:value="ca-app-pub-XXXXXXXXXXXXXXXX~XXXXXXXXXX"/>

If you skip this step, your app will crash at runtime with the message: "The Google Mobile Ads SDK was initialized incorrectly." It's the most common first-time mistake.

// Java
MobileAds.initialize(this, initializationStatus -> {
    // SDK ready — load ads after this callback fires
});

// Kotlin
MobileAds.initialize(this) { initializationStatus ->
    // SDK ready
}

The SDK initializes asynchronously. Load your first ad inside this callback, not before it.

<com.google.android.gms.ads.AdView
    xmlns:ads="http://schemas.android.com/apk/res-auto"
    android:id="@+id/adView"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_alignParentBottom="true"
    ads:adSize="BANNER"
    ads:adUnitId="ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX"/>

Then in your Activity, load an ad after SDK initialization:

// Kotlin
val adView: AdView = findViewById(R.id.adView)
val adRequest = AdRequest.Builder().build()
adView.loadAd(adRequest)

Adding Interstitials (v23 API)

Interstitials changed in SDK v23. The static load() method replaced the old listener pattern. Show them at natural break points — when the user navigates to a new page in your WebView is a common trigger.

// Kotlin — load an interstitial
InterstitialAd.load(
    this,
    "ca-app-pub-3940256099942544/1033173712", // test ID
    AdRequest.Builder().build(),
    object : InterstitialAdLoadCallback() {
        override fun onAdLoaded(ad: InterstitialAd) {
            interstitialAd = ad
        }
        override fun onAdFailedToLoad(error: LoadAdError) {
            interstitialAd = null
        }
    }
)

// Show when the user navigates
webView.webViewClient = object : WebViewClient() {
    override fun onPageFinished(view: WebView, url: String) {
        interstitialAd?.show(this@MainActivity)
    }
}

AdMob in iOS WebView Apps

The iOS setup follows the same pattern as Android — SDK in the native layer, ads alongside the WKWebView. The main differences are the integration method (Swift Package Manager or CocoaPods) and the mandatory ATT prompt.

Add the SDK via Swift Package Manager

In Xcode, go to File → Add Package Dependencies. Enter the URL: https://github.com/googleads/swift-package-manager-google-mobile-ads. Select the latest version and add it to your target.

Add your App ID to Info.plist

<key>GADApplicationIdentifier</key>
<string>ca-app-pub-XXXXXXXXXXXXXXXX~XXXXXXXXXX</string>

Initialize in AppDelegate

import GoogleMobileAds

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        MobileAds.shared.start(completionHandler: nil)
        return true
    }
}

Show the ATT Prompt

Before initializing the SDK, request tracking permission using Apple's AppTrackingTransparency framework. Users who grant permission generate higher eCPMs because personalized ads can be shown. Users who deny still see ads — just non-personalized ones.

import AppTrackingTransparency

ATTrackingManager.requestTrackingAuthorization { status in
    // Initialize AdMob after the user responds
    MobileAds.shared.start(completionHandler: nil)
}

Add a GADBannerView

Add a GADBannerView as a subview positioned above or below your WKWebView. Set its adUnitID, its rootViewController, and call load(GADRequest()). The layout is identical in principle to the Android implementation — two views stacked, the WebView taking most of the screen, the ad view pinned to the bottom.

Ad Format Comparison for WebView Apps

Not all ad formats earn equally, and not all suit every app. Here's a practical breakdown.

For most WebView apps, the practical starting point is: adaptive banner always on + interstitial at page transitions. Add rewarded ads once you have enough user engagement to design a meaningful reward mechanic. Ad revenue scales with installs, so pair this with a plan for getting your first 1,000 app downloads.

Using AdMob with WebView Builder Tools

If you're using a no-code builder to generate your WebView app, AdMob support is built in — you don't need to touch the SDK yourself.

Tools like AppOfWeb generate a native Android and iOS WebView app from your website URL and handle AdMob integration as part of the build. You enter your AdMob App ID and Ad Unit IDs in the builder's settings panel. The generated app includes the SDK, the manifest entries, and the ad view layouts — all pre-wired.

This approach is faster than manual integration, but you still need to:

• Create your AdMob account and get your IDs — the builder can't do that for you.
• Create separate ad units for each format you want (banner, interstitial, rewarded) — each format requires its own Ad Unit ID.
• Test with test IDs first, then replace with real IDs before the final build.
• Ensure the app complies with Play Store policies — specifically the native functionality requirement.

Builder tools that include push notifications, offline caching, and custom navigation satisfy Google Play's WebView policy requirements. Apps that wrap a URL with nothing else do not — regardless of how they're built.

Common Mistakes Developers Make with AdMob + WebView

FAQs

Key Takeaways

• AdMob ads go in the native layer — never inside the WebView's HTML.
• The App ID (manifest) and Ad Unit ID (ad view) are different strings. You need both.
• Use Google's test Ad Unit IDs during development. Switch to real IDs only before your final build.
• Smart Banners are deprecated — use Adaptive Banners for better eCPM.
• Interstitials use the v23 callback-based API — old tutorials showing the listener pattern will produce compile errors.
• iOS apps must show the ATT prompt before SDK initialization or face App Store rejection.
• Your app needs native functionality beyond wrapping a URL — Google Play enforces this and it affects your ability to publish at all.
• Rewarded ads earn the most. Start with banner + interstitial, then add rewarded once you have engagement.