Running one ad network on an AI chat app leaves money on the table the moment that network has no matching demand. Ad mediation across multiple ad networks fixes that by routing every impression to whichever network is willing to pay the most for it, in real time, without you touching the code again.
- Ad mediation across multiple ad networks routes each chat impression to the highest-paying network instead of the first one you integrated.
- A mediation layer sits above individual network SDKs and picks winners per request, not per app version.
- Waterfall setups still work in 2026, but they need strict timeout windows or they slow down chat response time.
- Elo's SDK plugs into AI chat apps as a mediation layer for conversational ad slots, not a single-network integration.
- Below three ad partners, mediation overhead usually isn't worth building — a single well-matched network is enough.
Why this matters
A single ad network can only fill the requests that match its own advertiser demand. When it has nothing relevant for a given chat context, you get a blank slot and zero revenue on that impression.
Mediation solves this by holding a live auction — or a prioritized fallback chain — across every network you've connected. If Network A has no bid, Network B gets the request within milliseconds. That's the entire point of setting up ad mediation across multiple ad networks in 2026: fewer unfilled impressions, and each one goes to the network paying the most for it.
For AI chat apps specifically, this matters more than for a typical mobile app banner. Ad slots are conversational — a single native card inside a response — so unfilled slots aren't just lost revenue, they're a missed moment where the user was actually asking a buying-intent question. An ad SDK for AI chat apps needs mediation built in from day one, not bolted on after the first network underperforms.
What you'll need
- Active accounts and API credentials for each ad network you plan to connect (most setups start with 3-5 networks)
- A mediation layer capable of holding adapters for multiple networks — either a self-built router or an SDK with mediation already handled
- A defined integration point in your chat flow where an ad slot can render as a native card, not a banner
- Logging in place to track fill rate, latency, and eCPM per network before you flip mediation on
- A default or house ad unit for the rare case where every connected network returns zero fill
The steps
1. Audit every network you're already running
Before adding a mediation layer, pull the last 30 days of fill rate and eCPM from each network you currently use. This tells you which networks are worth keeping and which are dead weight you're about to mediate around for no reason.
Common mistake: keeping a network in the stack purely because it was the first one integrated. Cut anything under a 40% fill rate before you build the mediation layer around it.
2. Pick waterfall or unified auction
A waterfall calls networks in a fixed priority order until one returns a bid. A unified auction calls all networks simultaneously and picks the highest bid. Waterfalls are simpler to build in 2026 but leave money on the table when a lower-priority network would have paid more on a specific request.
For conversational ad slots where latency matters, most teams still start with a waterfall and move to auction-based mediation once volume justifies the added complexity.
3. Set network priority and timeout windows
Order networks by historical eCPM, highest first, and set a hard timeout — 200 milliseconds is a common ceiling for a chat response that shouldn't feel delayed by an ad call. Any network that doesn't respond inside that window gets skipped automatically.
Expected outcome: your chat response time stays consistent whether an ad fills or not. Common mistake: leaving timeouts unset, which lets one slow network stall every single response in the chain behind it.
4. Integrate the mediation SDK into your chat flow
This is where the mediation layer connects to your actual chat app — the point where a response is generated and a native ad card can be inserted contextually. Teams building on OpenAI, Anthropic, or a custom LLM stack need this integration point to work regardless of which model is generating the underlying response.
A mediation SDK for multi-model LLM apps handles this exact case — one integration point across whichever model or models power your chat app.
5. Configure floor prices per network
Set a minimum acceptable bid per network so you're not filling a slot with a $0.02 CPM bid when a house ad or a higher floor from another network would have paid more. Floors should be reviewed monthly against actual eCPM data, not set once and forgotten.
Common mistake: setting the same floor across every network. Networks with historically higher eCPM can carry a higher floor without losing meaningful fill.
6. Test fill rate and latency across the full stack
Run test traffic through every network in the mediation chain before going live with real users. Track two numbers specifically: overall fill rate across the whole stack (should land above 90% once three or more networks are connected) and added latency per ad call (should stay under your 200ms ceiling).
Expected outcome: fill rate climbs compared to any single network alone, and the user never notices the ad call happening.
7. Monitor eCPM and rotate underperforming networks
Once live, pull weekly eCPM and fill rate by network. A network that consistently loses the auction or times out is a candidate to drop or reprioritize. Mediation isn't a one-time setup — it's a stack you adjust as advertiser demand shifts across networks month to month.
8. Set up a reporting dashboard
Build or connect a dashboard showing revenue, fill rate, and eCPM broken out per network, updated daily. Without this, you're mediating blind — you won't know which network is actually earning its place in the stack.
See mediation running on real chat apps
Check how Elo's SDK handles multi-network ad mediation for AI chat apps.
Troubleshooting
Fill rate stays flat after adding networks. Check that each new network's adapter is actually receiving requests — a misconfigured API key often fails silently instead of throwing an error.
Ad calls slow down chat response time. Your timeout window is too loose or missing entirely. Cap every network call at 200ms and skip any network that misses it, instead of waiting.
One network wins every auction regardless of context. Floor prices are likely misconfigured, or that network is bidding a flat rate rather than a contextual one — verify the bid is request-specific, not a static fallback.
eCPM drops after adding a fourth or fifth network. More networks doesn't always mean more revenue. Low-quality networks can win low-value auctions that a higher floor would have blocked; audit and drop the weakest performer.
Reporting numbers don't match network dashboards. Attribution windows differ between mediation logs and network-side dashboards. Reconcile on a 24-hour delay, not real time, to avoid chasing phantom discrepancies.
Tools and resources
- A mediation SDK that already ships adapters for multiple networks, rather than building a router from scratch
- Per-network API documentation for bid response formats and timeout behavior
- A logging pipeline (even a simple event log) for fill rate, latency, and eCPM by network
- Ad monetization SDKs built for AI chatbot developers if you're evaluating options rather than building mediation logic yourself
- A staging environment to test network timeouts before touching production traffic
What to do next
Once mediation is live and reporting is stable, the next decision is which networks to add or drop as advertiser demand shifts through 2026. Revisit floors and priority order monthly — mediation setups that go untouched for six months usually lose 10-20% of achievable eCPM to stale configuration.
FAQ
What is ad mediation across multiple ad networks?
Ad mediation across multiple ad networks is a layer that routes each ad impression to whichever connected network bids highest or has available inventory, instead of relying on one fixed network. It sits above individual network SDKs and picks a winner per request.
How many ad networks should I mediate between?
Three to five networks is the typical starting stack in 2026. Fewer than three rarely justifies the mediation overhead; more than five usually adds latency without proportional revenue gains.
Is waterfall or auction-based mediation better?
Waterfall mediation calls networks in a fixed order and is simpler to build; auction-based mediation calls networks simultaneously and picks the true highest bid. Most teams start with waterfall and move to auction mediation once volume justifies it.
How much latency does ad mediation add to a chat response?
A well-configured mediation setup adds under 200 milliseconds per ad call when timeouts are enforced strictly. Without a timeout ceiling, one slow network can stall the entire chain.
Does ad mediation work for AI chat apps built on multiple LLMs?
Yes, a mediation SDK integration point sits at the chat response layer, independent of which model — OpenAI, Anthropic, or a custom LLM — generated the underlying response.
What fill rate should I expect after setting up mediation?
Fill rates above 90% are achievable once three or more networks are properly connected and floor prices are tuned, compared to 40-60% fill rates common with a single network.
How often should I review my ad mediation stack?
Review floor prices and network priority monthly. Advertiser demand per network shifts, and a stack left untouched for six months typically loses meaningful eCPM to stale configuration.
Can I mediate ads inside conversational chat cards, not just banners?
Yes, native conversational ad cards can be mediated the same way as traditional ad units — the mediation layer picks the winning network before rendering the card inline in the chat response.
One last thing
The biggest revenue leak in a mediation stack isn't a missing network — it's an unenforced timeout. Teams that skip step 3 and let every network call run to completion routinely lose 15-20% of potential fill to slow responders that never had the best bid anyway, they just answered last. Set the 200ms ceiling before you add a fourth network, not after.
