Your Blended eCPM Dropped and Revenue Went Up: Splitting the Change Into Country Mix and Rate

Getting the report into a shape you can decompose

Three things to clean up before feeding an AdMob country report to anything. I got each of them wrong at least once.

1. Drop rows with zero impressions. eCPM is undefined there. Leave them in and you get a division by zero, or an infinity quietly mixed into the average
2. Keep the currency consistent. If one month was exported under a different display currency, exchange-rate movement shows up disguised as a rate effect
3. Do not compare across the estimate boundary. Recent days get replaced by finalized numbers later. A comparison that straddles the close invents price changes that never happened

The third one is the quietest. I now pull the prior month at the start of the month, then pull the same CSV again after it finalizes and diff the two. Once you know how far the numbers move, you know how many days to wait next time.

You only need three columns.

country,impressions,revenue
US,1230000,4551.00
JP,880000,2860.00

The script

Give it a prior-period and a current-period CSV and it prints the total change plus each country's contribution. Standard library only.

#!/usr/bin/env python3
"""Split a blended eCPM change into mix and rate effects.
 
    python3 ecpm_split.py prev.csv curr.csv
 
CSV columns: country,impressions,revenue  (one currency, finalized figures)
Uses a symmetric-average (Bennet-style) decomposition that reconciles exactly.
"""
import csv
import sys
from collections import defaultdict
 
 
def load(path):
    rows = defaultdict(lambda: [0.0, 0.0])  # country -> [impressions, revenue]
    with open(path, newline="", encoding="utf-8") as f:
        for r in csv.DictReader(f):
            imp = float(r["impressions"])
            rev = float(r["revenue"])
            if imp <= 0:
                continue          # eCPM is undefined with zero impressions
            rows[r["country"]][0] += imp
            rows[r["country"]][1] += rev
    total_imp = sum(v[0] for v in rows.values())
    if total_imp == 0:
        raise SystemExit(f"{path}: every row has zero impressions")
    out = {}
    for c, (imp, rev) in rows.items():
        out[c] = {
            "imp": imp,
            "rev": rev,
            "w": imp / total_imp,              # impression share
            "r": rev / imp * 1000.0,           # this country's eCPM
        }
    return out, total_imp, sum(v[1] for v in rows.values())
 
 
def decompose(prev, curr):
    countries = sorted(set(prev) | set(curr))
    rate_total = mix_total = 0.0
    per_country = []
    for c in countries:
        p, q = prev.get(c), curr.get(c)
        # Present in only one period: hold the price fixed, put it all in mix
        w0, w1 = (p["w"] if p else 0.0), (q["w"] if q else 0.0)
        if p and q:
            r0, r1 = p["r"], q["r"]
        elif q:
            r0 = r1 = q["r"]
        else:
            r0 = r1 = p["r"]
        rate = (r1 - r0) * (w0 + w1) / 2.0
        mix = (w1 - w0) * (r0 + r1) / 2.0
        rate_total += rate
        mix_total += mix
        per_country.append((c, w0, w1, r0, r1, rate, mix))
    return per_country, rate_total, mix_total
 
 
def main():
    if len(sys.argv) != 3:
        raise SystemExit("usage: ecpm_split.py prev.csv curr.csv")
    prev, imp0, rev0 = load(sys.argv[1])
    curr, imp1, rev1 = load(sys.argv[2])
    b0 = rev0 / imp0 * 1000.0
    b1 = rev1 / imp1 * 1000.0
    per, rate_total, mix_total = decompose(prev, curr)
 
    print(f"blended eCPM   {b0:8.3f} -> {b1:8.3f}   diff {b1 - b0:+8.3f}")
    print(f"  rate effect  {rate_total:+8.3f}")
    print(f"  mix  effect  {mix_total:+8.3f}")
    print(f"  reconciliation err {(rate_total + mix_total) - (b1 - b0):+.12f}")
    print(f"revenue        {rev0:10.2f} -> {rev1:10.2f}   diff {rev1 - rev0:+10.2f}"
          f"  ({(rev1 / rev0 - 1) * 100:+.1f}%)")
    print()
    print(f"{'country':<8}{'share0':>8}{'share1':>8}{'eCPM0':>9}{'eCPM1':>9}"
          f"{'rate':>9}{'mix':>9}")
    for c, w0, w1, r0, r1, rate, mix in sorted(per, key=lambda x: -abs(x[5] + x[6])):
        print(f"{c:<8}{w0 * 100:7.1f}%{w1 * 100:7.1f}%{r0:9.3f}{r1:9.3f}"
              f"{rate:+9.3f}{mix:+9.3f}")
 
 
if __name__ == "__main__":
    main()

The reconciliation err line is there so I can doubt myself. On any day it is not zero, I fix the input rather than the decomposition.

What it printed

Below is my monthly report folded down to six countries with the magnitudes rounded. These are not the raw figures, but the ratios and the direction match what I actually saw.

blended eCPM      1.560 ->    1.148   diff   -0.412
  rate effect       -0.003
  mix  effect       -0.409
  reconciliation err +0.000000000000
revenue           9203.00 ->    9828.50   diff    +625.50  (+6.8%)

country   share0  share1    eCPM0    eCPM1     rate      mix
US         20.3%   14.4%    3.800    3.700   -0.017   -0.224
JP         15.3%   10.3%    3.200    3.250   +0.006   -0.160
DE          5.1%    3.5%    3.100    3.140   +0.002   -0.049
ID          0.0%    8.2%    0.190    0.190   +0.000   +0.016
IN         35.6%   39.7%    0.210    0.220   +0.004   +0.009
BR         23.7%   23.9%    0.280    0.290   +0.002   +0.001

Three lines cover the reading.

• The average fell by 0.412, and 0.003 of that came from prices
• The other 0.409 is entirely impression share moving around
• Revenue over the same span rose 6.8%

US and JP prices barely moved. What moved was their share of impressions, from 20.3% to 14.4% and from 15.3% to 10.3%. They shrank not because I throttled anything, but because IN, BR, and a newly served ID added impressions and the denominator grew.

The denominator was what I had been staring at while hunting for countries to cut.

What to check before cutting a low-eCPM country

Cut a low-price country and blended eCPM goes up, guaranteed. Read that rise as proof the change worked and you have made the wrong call.

Here is what dropping IN and ID from the current period does.

The number at the top of the dashboard looks 75% better. Revenue is 9% lower.

So I started sorting every country report twice: by unit price ascending, and by revenue contribution descending. The countries where those two rankings disagree the most are the ones I am most likely to misjudge.

IN sits second from the bottom on price and fourth on revenue share, just under DE. The country I had shortlisted for cutting was carrying roughly as much money as Germany.

None of which means low-price regions are untouchable. The experience cost of an impression is the same everywhere, so varying format allocation and display frequency by region is a perfectly sound lever. What I changed was the doorway into that lever: not "the price is low, so stop serving," but "this region spends more impressions than its revenue contribution justifies, so rebalance." The material for that judgment is revenue per impression against experience, not eCPM.

Moving prices on the network side is a separate topic, and I wrote that up in Putting AdMob Bidding into Production for a Rork App. This piece is about the step before it, reading the numbers correctly.

The same trap shows up by hour and by format

None of this is specific to countries. Swap the aggregation axis and the decomposition still holds.

• Hour of day. A month where late-night impressions grow shows a lower average, because intraday price variation and usage distribution move together
• Ad format. Banners produce an order of magnitude more impressions than interstitials, so adding a single banner placement pulls the average down. That drop is essentially the design working as intended
• OS. Device-mix shifts usually arrive tangled up with country-mix shifts. Move one axis at a time so you do not count the same thing twice

Reading the country column as hour or format is all it takes, so rather than maintaining a generic version and a country version, I normalize the column name to country on the CSV-producing side. Two copies of the decomposition means fixing the formula in two places later.

A weekly loop worth keeping small

Monthly alone finds out too late. I run this weekly, and I deliberately do not send myself alerts about it.

1. Freeze how you pull

Take the prior week and the current week with the same span length, the same currency, and the same finalization state. A comparison where those differ will mislead you no matter how carefully you read the output.

2. Watch a ratio, not a threshold

When the average moves, the thing I look at is the share of the change attributable to the rate effect, not its absolute size. My line is that the rate effect has to exceed 30% of the total change before I stop and investigate. Below that, it is a mix story, so I check revenue and move on.

3. Keep the log

Append one row per period. After half a year you can see which regions grow in which season for your own apps. Not being surprised by the same thing twelve months later is what paid off most.

If you want to revisit the revenue design as a whole rather than the measurement, Getting a Rork App to ¥100K a Month with AdMob walks through placement first.

What to do first tomorrow

Pull last month's and this month's country CSV and run the script once. If reconciliation err is zero and you have a rate-to-mix ratio, that alone settles whether this is a month for cutting countries at all.

Since adding that one step, I have stopped making cut decisions at the start of the month. In the months where cutting is warranted, the rate effect comes out clearly larger. There are different kinds of reasons for a number going down, and I was late in learning to tell them apart.