Your ad SDK sends a request and gets nothing back. That empty slot earns nothing, and if it happens often enough your revenue line starts to look worse than it should. The usual reaction is to blame the ad network or add another one. Sometimes that is the right call. More often, low fill comes from something you can find and fix yourself: account setup, consent handling, how mediation is configured, or when and how often your app asks for ads.
This post walks through how to diagnose low fill in a fixed order, so you stop guessing.
First, define what you are measuring
Ad dashboards use several related ratios, and people mix them up. Before you change anything, be sure which number is actually low.
- Requests: how many times your app asked for an ad.
- Matched requests (some networks call these "filled"): how many requests came back with an ad.
- Match rate / fill rate: matched requests divided by requests.
- Impressions: how many loaded ads were actually shown.
- Show rate: impressions divided by matched requests.
These point to different problems. A low match rate means demand is not answering your requests. A low show rate means you are loading ads and then never showing them, which makes your requests look worse to buyers and wastes the user's bandwidth. Many "fill problems" turn out to be show-rate problems once you separate the two.
In AdMob, open the report, add requests, matched requests, match rate, impressions and show rate as columns, and break it down by ad unit, then by country, then by app version. Write down the baseline for each before you change anything, so you can tell whether a fix worked.
Step 1: Rule out setup and account problems
These are the cheapest things to check, and they can push fill close to zero, so start here.
- Production ad unit IDs. Make sure release builds do not still use test IDs, and debug builds do not use live IDs. It sounds obvious. Build flavors and copy-pasted config files make it easy to get wrong.
- New ad units and new apps. Networks often serve limited demand to brand-new ad units or newly added apps while they gather data. If the unit is only days old, wait before drawing conclusions.
- App store linking. Link the app in the network console to its published store listing. Unlinked apps can be restricted.
- app-ads.txt. Check that the file is on the root of the developer website listed in your store listing, and that it has a correct line for each network you use. Many networks show a verification status in their console. A missing or wrong file can lower demand from buyers who check it.
- Account and policy status. Look for policy notices, ad serving limits, or unfinished payment and identity verification. Any of these can throttle serving without your code changing.
A quick check for app-ads.txt from your terminal:
curl -sL https://example.com/app-ads.txt | grep -i "pub-"If that prints nothing, or the publisher ID doesn't match the one in your console, fix that first.
Step 2: Log every failure with its reason
Dashboards give you totals. Your app can tell you why each request failed. Log the error code and the mediation response info for every failed load, and send it to your analytics with the ad unit, country and app version attached.
On Android with the Google Mobile Ads SDK:
InterstitialAd.load(context, adUnitId, AdRequest.Builder().build(),
object : InterstitialAdLoadCallback() {
override fun onAdLoaded(ad: InterstitialAd) {
analytics.log("ad_loaded", mapOf("unit" to adUnitId))
cachedAd = ad
}
override fun onAdFailedToLoad(error: LoadAdError) {
analytics.log("ad_failed", mapOf(
"unit" to adUnitId,
"code" to error.code,
"message" to error.message,
"adapters" to error.responseInfo
?.adapterResponses
?.joinToString { "${it.adSourceName}:${it.adError?.code}" }
))
}
})Then group the failures by code. The common AdMob codes are:
0internal error: often an SDK or initialization problem on your side.1invalid request: a bad ad unit ID, wrong format for the unit, or a misconfigured request.2network error: the device could not reach the server. Look at connectivity, timeouts, and requests fired during app startup.3no fill: the request was valid but no ad was returned. This is the only true demand problem in the list.
If most of your failures are not code 3, you do not have a demand problem. You have a bug to fix.
Step 3: Check consent and privacy signals
Consent affects demand directly. In regions covered by GDPR, if your consent flow doesn't produce a valid consent signal, or the user declines, many buyers can only bid for non-personalized ads, and some won't bid at all. On iOS, users who decline App Tracking Transparency give buyers less information to work with, which can lower both fill and price.
Things to verify:
- The consent form (for example, a certified consent management platform using the IAB TCF) loads and finishes before you request your first ad.
- Each mediation adapter gets the consent signal. Some read the TCF string automatically and some need you to pass it explicitly. Check each adapter's documentation.
- Your analytics records the consent outcome, so you can split fill by consented vs. not consented.
When fill is low only in one region, or only on iOS, consent and tracking status are the first things to suspect. You can't make every user consent, and you shouldn't try to pressure them. You can make sure a user who did consent isn't treated like one who didn't because of a bug.
Step 4: Review your mediation setup
Mediation can raise fill. A bad setup can also quietly lower it.
- Floors set too high. In a waterfall, a high eCPM floor on every network means many requests get no answer at all. Try one ad unit with a lower floor, or with a last fallback line that has no floor, and compare match rate over a week or more.
- Too few sources. One network may simply have little demand in some of your countries. Check match rate by country to see where the gaps are.
- Adapter version mismatches. An adapter that doesn't match your core SDK version can fail without a clear error. The per-adapter response info you logged in Step 2 shows which source fails and how.
- Timeouts. A waterfall with many lines can run past the request timeout on slow connections. Bidding usually avoids this, because sources compete in a single auction instead of being called one after another.
Step 5: Look at your own request pattern
This is where show-rate problems usually come from.
- Requesting too early. Ads requested before the SDK finishes initializing, or before consent is resolved, are more likely to fail. Wait for the initialization callback.
- Pre-loading ads you never show. If you load an interstitial on every screen but only show one per session, most of those loads are wasted. Load right before a likely ad moment instead.
- Letting cached ads expire. Loaded ads go stale after a while; your network's documentation says how long. If you load at launch and show much later, the ad may no longer be valid. Track how long it has been since each ad loaded and reload when needed.
- Retry storms. Retrying immediately after a no-fill floods the network with requests that will also fail. Use backoff:
private var retryAttempt = 0
fun scheduleRetry() {
val delayMs = (2.0.pow(retryAttempt.coerceAtMost(6)) * 1000).toLong()
retryAttempt++
handler.postDelayed({ loadAd() }, delayMs)
}
// Reset retryAttempt = 0 in onAdLoadedA quick triage checklist
- Separate match rate from show rate. Which one is low?
- Confirm production IDs, store linking, app-ads.txt and account status.
- Group failures by error code. Is code 3 actually the main one?
- Split fill by country, platform and consent status.
- Check floors, adapter versions and timeouts in mediation.
- Check request timing, pre-loading, expiry and retry behavior.
- Change one thing at a time and compare against your baseline over a full week.
Conclusion
Low fill is a symptom, and it can have several causes. Some, like a new ad unit or weak demand in certain countries, you can only wait out or work around. Many others are configuration or code issues you control, and you can find them with a dashboard, some failure logging and a careful look at when your app requests ads. Do the cheap checks first, measure before and after each change, and add a new network only after you have confirmed the missing demand is real.