If you're already monetizing with AdMob and want to take it a step further to generate revenue with your Android app, the Advertising revenue optimization through AdMob Mediation It's probably the most cost-effective move you can make. Properly set up, mediation turns your inventory into a continuous auction across multiple networks, maximizing every impression without ruining the user experience.
In this article you will find a complete and very practical guide, designed for developers and publishers who are already generating revenue but want to know more. How to get the most out of AdMob by unifying mediation, bidding, segmentation, legal compliance, and analyticsYou'll see everything from basic concepts to advanced best practices, real-world examples, typical problems, and how to integrate it into Android, iOS, and engines like Unity.
What is AdMob Mediation and why does it boost your revenue?
AdMob Mediation is a feature that allows you manage all ad sources from a single panel that serve ads in your apps: AdMob's own network and dozens of external networks. Instead of relying on just one network, AdMob sends each ad request to multiple sources and keeps the one that pays the most or is most likely to fill the request.
AdMob works with More than 30 networks via official adapters and more than 70 via custom eventsAll these networks receive equal access to inventory, which guarantees a fair auction dynamic: the ad from the network that pays the most for that specific impression is served, provided it meets the targeting and policies.
One of its strengths is that AdMob not only acts as a bridge between networks, but also offers Integrated tools to automate and simplify your monetization strategyThis includes Ad Network Optimization (ORP), mediation groups, detailed reporting, and deep integration with the Google ecosystem (Firebase, Analytics, UMP, etc.).
Cascade mediation vs bidding: two models you can combine
AdMob supports two types of advertising sources: Cascading sources and bidding sourcesThe interesting thing is that you can create hybrid configurations by combining both in the same mediation group to get the most out of each impression.
In the waterfall model, the sources are called one by one following the eCPM medium that you manually definenot what the network is willing to pay at that moment. The network with the highest eCPM is called first; if it doesn't fill the print job, it moves on to the next one, and so on. It's a classic model that works, but it doesn't always capture the true value of each print job.
Bidding, on the other hand, allows the Ad sources compete in real time in a single auctionEach bidding network submits its bid based on the value of that specific impression (user, context, country, device type, etc.), and the highest bidder wins. This solution, which Google simply calls BiddingIt is designed to extract even more money from each print and reduce the manual work of adjusting eCPMs.
AdMob allows you to create hybrid configurations in your mediation groupsBidding sources compete in real time, and if the printout isn't filled, the mediation is passed to the waterfall component as a backup. This way, you combine the efficiency of an auction with the security of having a well-defined waterfall structure.
Traffic mediation and segmentation groups
Mediation groups are at the heart of the setup. A mediation group is a combination of targeting settings and ad sources These apply to one or more ad units. With them, you can finely control which sources compete for which traffic.
AdMob allows you to segment your mediation groups by ad format, platform (Android/iOS), specific app, ad unit, and countryFor example, you can have a mediation group just for interstitials on Android in certain countries, with specific networks and custom eCPM rules.
The great practical advantage is that you don't have to repeat the block-by-block mediation configurationYou create the group with the targeting and sources, and then assign as many ad units as you want to that group. This way you scale much better when managing multiple apps or formats.
Key steps to get started: blocks, sources, assignments, and groups
To use mediation effectively, it's best to follow a logical setup flow. Generally, the recommended order is: create ad blocks, configure sources, make assignments, and set up mediation groups.
First you need to have your app registered with AdMob and, from there, create one or more ad blocksEach block is a container that you insert into your app. This block sends ad requests to AdMob and displays the response it receives. When you create it, you assign it a format (banner, interstitial, native, rewarded video, etc.) and a unique ID is generated that you'll use in your code.
The second step is to configure the advertising sources that you will include in the mediationHere you can choose between bidding networks and cascading networks. The type you choose determines how that network participates in the auction: in real time or according to your fixed eCPM order.
Third, you need assign your ad units to third-party sourcesIn the AdMob interface, each source has a configuration page where you enter mapping data (block IDs, zones, etc.), which you obtain from that external network's account. Without these mappings, AdMob cannot communicate correctly with the source to fulfill requests.
Finally, you create the mediation group by format and platformFor each ad type (banner, interstitial, rewarded, etc.) and for each operating system (Android/iOS), you must have at least one mediation group. Within that group, you define the target country or countries, which sources participate, in what order (for cascade ads), and which ad units are associated with them.
Account prerequisites and permissions
Before diving into the technical integration, it's a good idea to verify that your account meets certain requirements. You need sufficient account permissions to manage inventory, apps, and the Privacy and Messaging sectionThis usually implies an administrator role or a custom role with those access privileges.
Additionally, before integrating mediation for a specific ad format, you must have that format correctly implemented without mediation in your appIn other words, you should already know how to load and display banners, interstitials, or rewarded ads using only AdMob. You'll then add the other networks on top of that solid foundation.
For the bidding section and the latest mediation features, It is mandatory to work with Google Mobile Ads SDK 18.3.0 or higherUsing older versions can leave you without key features, compatibility with certain adapters, and worst of all, support for new privacy policies.
Initializing the Google Mobile Ads SDK and mediation adapters
SDK initialization is critical for mediation to function correctly. During the Google Mobile Ads SDK initialization call, The mediation adapters are also initializedThat's why it's important to wait for this process to finish before loading ads, so that all networks are ready from the first impression.
Bidding adapters, in particular, require an explicit SDK initializationIf you don't, those networks are unlikely to participate in the initial auction, and you'll lose revenue in the first few seconds of app usage, which are usually very valuable.
In Android, for example, you can initialize the SDK in a background thread and log the state of each adapter. The typical pattern in Java is to call MobileAds.initialize(context, callback) And, in the callback, iterate through the adapter state map (adapterStatusMap). This allows you to log the adapter class name, a brief description, and the initialization latency in milliseconds for debugging potential problems.
In Kotlin, the idea is the same, only you can rely on coroutines with Dispatchers.IO To move the initialization process off the main thread, the initialization callback iterates through `adapterStatusMap` and records the description and latency for each adapter. Viewing this data in Logcat is very useful for detecting networks that initialize slowly or fail to reach the ready state.
Additionally, for banners or other formats, you can find out which network served a specific ad by consulting the ResponseInfo of the ad responseIn Java, you use `ad.getResponseInfo().getMediationAdapterClassName()` to get the name of the adapter class that earned that impression. In Kotlin, you access `ad.responseInfo?.mediationAdapterClassName` and write it to the logs.
Context and Activity: an important detail for networks to function
When you create an advertisement object (for example, a AdView for banners), you must pass a Context in the constructor. In mediation this detail is key, because that Context will be passed internally to external networks.
Many third-party networks need a Context of type Activity (not just Application) To properly display their ads, especially interstitials and videos, they need to be able to show them at all. If they only receive a generic context message, some ads may silently fail to display anything, resulting in a drop in fill rate and revenue.
Therefore, it is strongly recommended Always pass an instance of Activity when initializing your advertisement objectsThis way you ensure that the mediated networks have what they need and the advertising experience is consistent across all of them.
Best practices for banners and display inventory
In the case of banners, there is a basic recommendation that many developers overlook: Disable automatic updates in external network user interfaces when that ad unit is used within AdMob Mediation.
If you allow, for example, an external network to refresh the banner on its own, and at the same time AdMob is already updating the block according to its own refresh rate.This can cause a double refresh, which negatively impacts performance and provides a poor user experience. Ideally, AdMob should control the refresh rate directly from the ad unit settings.
It's also key to test your banners with Test ad IDs During development, you avoid accidental clicks or internal tests on real campaigns that could be considered invalid traffic. Only when the app is ready for production do you replace those test IDs with the real IDs of your blocks.
Mediation with native ads: policies and recommendations
With native ads things get a little more complicated because each network has their own presentation policies and design requirementsWhen using mediation, you are still required to comply with the policies of the mediation network serving the ad, while also respecting Google's general content and user experience guidelines.
One important technical detail is that, for mediated native ads, you must Use the loadAd() method and not loadAds()The loadAds() method is intended to load only Google ads; if you use it with intermediaries, third-party networks may not even come into play.
In addition, you have to take great care that the native ads Do not disguise yourselves as organic content in a deceptive wayEnsure that there is some indication that the content is sponsored and that there are no clickable elements outside the areas permitted by each network. This is not only AdMob's policy, but also that of most of the networks you will integrate into your mediation.
Privacy, GDPR and US state laws in mediation
If your app is distributed in Europe or in certain US states, you are required to comply with GDPR and state privacy lawsIn the context of mediation, this means something very specific: you must add your mediation partners to the list of compliant advertising partners within the Privacy and Messaging section of AdMob.
If you don't, it's possible that These networks cannot serve ads to users subject to those regulations.This translates to lower fill rates and decreased revenue in those regions. The AdMob console offers dedicated screens for configuring US regulations by state and GDPR compliance, where you can specify which partners you use and how you manage consent.
To manage permissions and consent correctly, Google offers the User Messaging Platform (UMP) SDKWith UMP you can display consent dialogs adapted to regulations, enable restricted data processing (RDP) in sensitive contexts and ensure that you only share data with networks that have explicit user consent.
AdMob integration and mediation on Android
On Android, implementation usually begins by configuring the necessary dependencies in the build.gradle file from the app module, adding the Google Mobile Ads library and the adapters for the networks you will mediate (for example, AppLovin, ironSource, Meta Audience Network, etc.).
Once you've added the SDK, you register your app with AdMob and copy the application ID into the AndroidManifest or in the initialization code. Next, you create the ad units in the console (banners, interstitials, rewarded ads, etc.) and obtain the unit IDs that you will use in your Java/Kotlin code.
Then, in the app, You initialize the Google Mobile Ads SDK At startup (ideally in Application or the first Activity), you then implement ad loading and display using the IDs provided by AdMob. For banners, you add an AdView to the XML layout; for interstitials and rewarded ads, you typically load them in the background and display them at natural moments (level change, game end, etc.).
Throughout the entire development process, it is advisable to work with Test ad IDs which Google documents for each format. This prevents clicks from your testers or yourself from being considered suspicious behavior. When your app goes into production, you replace those IDs with the real ones and verify that the mediation ads load and are correctly recorded in the reports.
iOS integration: specifics of Xcode and CocoaPods
On iOS, the process is similar, but adapted to the Apple ecosystem. You typically start by adding the Google Mobile Ads SDK for your Xcode projecteither through CocoaPods (the most common method) or by integrating it manually.
With CocoaPods you define in your Podfile the dependency on Google-Mobile-Ads-SDK and, if applicable, the pods of the network adapters you will be usingThen you run pod install and open the generated workspace to always work from there.
In code, you usually Initialize the SDK in AppDelegateUsing the AdMob app ID. Then, just like on Android, you create the ad units in the console, copy their IDs, and use them in your Swift or Objective-C code to load banners (GADBannerView), interstitials, native ads, or rewarded ads at the points in the app where it makes sense.
It is also mandatory to test on iOS. Test IDs Before publishing, check that the ads display correctly on different screen sizes, orientations, and iOS versions. A very common mistake is not properly adjusting the banner size or placing an interstitial ad at a point that disrupts the user's natural navigation.
AdMob dashboard, ad types, and advanced analytics
The AdMob console is structured to provide a Quick overview of performance and easy access to app settings, blocks, and mediationOn the main dashboard you'll see estimates of revenue, impressions, clicks and other key metrics, as well as important alerts and notifications.
In the ad units section you can create, edit and manage all your blocksChoosing the format, behavior, sizes, and options such as banner refresh rate. The apps section allows you to add new applications, link them to stores (Google Play, App Store), and configure specific parameters.
In Reports, AdMob offers a highly customizable reporting suiteYou can analyze impressions, clicks, CTR, estimated revenue, and eCPM by format, country, app, or ad unit. You can also compare time periods, filter by traffic type, and identify trends.
These metrics help you identify which ad formats perform best (banners vs. interstitials vs. rewarded vs. native ads), which placements generate the most revenue, and which countries or user segments are most profitable. By combining this information with Firebase or Google Analytics, you can correlate revenue per user (ARPU), retention, and key in-app events.
Policies, app quality, and valid traffic
AdMob has a fairly strict set of policies that affect both app content as well as ad behaviorIgnoring them is playing with fire: you could end up with a limited or even suspended account.
Regarding content, your app cannot promote illegal activities or contain pornography, extreme violence, hate speech or explicit material. You must also respect user privacy, comply with data protection laws, and handle all matters relating to minors with special care.
In the advertising section, practices such as the following are prohibited: place ads where they blend in with the contentInterstitials should not appear unexpectedly or block critical actions (for example, just as the user is about to tap a key button), overlapping interactive elements, or force clicks.
Invalid traffic is another sensitive issue. The following are prohibited: incentivized clicks, bots, automated scripts, or directly encouraging users to click on adsIt is recommended to monitor for unusual spikes in impressions and clicks, review reports, and use AdMob's filtering tools to block suspicious sources.
Optimization, A/B testing, and comparison with other platforms
Optimizing mediation is an ongoing process. You have to experiment with different ad formats, placements, frequencies, and network combinations until the right balance between revenue and user experience is found.
A/B testing is especially useful. For example, you can Test a network set using only AdMob mediation versus another platform or a different combination. A real-world example: the Gamegou study compared AdMob's mediation against another platform on one of its flagship titles, Super Goal. The test showed that AdMob delivered better results in revenue, eCPM, and ARPU.
When you compare AdMob with other solutions, factors such as advertiser coverage, fill rate, ease of use of the interface, customization options and payment thresholds. AdMob stands out for its integration with the Google ecosystem, its huge advertiser base, and its relatively user-friendly dashboard, even for small teams.
Campaign management, account security, and payments
Managing monetization doesn't end with the technical setup. It's also important to have a clear understanding of your... revenue, retention, and user experience goals and review the data regularly to adjust the strategy.
In terms of security, it is key to use Use strong passwords and enable two-step verification in the Google account associated with AdMob. Regularly reviewing account activity and keeping the SDK and development tools up to date greatly reduces the risk of security issues or incompatibilities.
To get paid, you must meet three basic conditions: reach the minimum payment threshold, have a verified account (including postal PIN if applicable) and comply with the policiesPayments are usually issued in monthly cycles and can arrive via electronic transfer, check, or other methods available depending on the country (such as Western Union or local solutions).
Don't forget that the revenue you generate with AdMob have tax implicationsYou must declare them according to your country's legislation; there may be applicable withholding taxes, and in some cases, you'll need to fill out specific tax forms for Google. Seeking professional advice is usually a good idea when the amounts start to become significant.
Overall, AdMob Mediation, when well-planned and respecting policies, privacy, and user experience, allows you to transform a flat ad inventory into a dynamic system where multiple networks compete transparently for each impressionsupported by advanced reporting, optimization tools, and a Google infrastructure designed to support projects that grow over timeSharing the information helps others learn about the topic..