Real-Time Bidding Explained: How RTB and Header Bidding Work

Real-time bidding (RTB) is the per-impression auction behind most programmatic advertising: when a page with an ad slot loads, an exchange broadcasts a bid request describing the slot, the page and an anonymized user; demand platforms evaluate it and bid; the winner's ad renders — all in roughly a tenth of a second, before the page finishes painting. Header bidding is the publisher-side technique that lets many exchanges compete for the same slot simultaneously, and OpenRTB is the protocol they all speak. This guide walks the auction end to end, explains the machinery around it, and covers the part most explainers skip: where native ads fit the model and where they break it.

The auction, step by step#

One impression, one auction, six steps:

1. A page loads and an ad slot fires. The publisher's page requests an ad for a specific placement — size, position, context.
2. The supply side packages a bid request. The publisher's supply-side platform (SSP) builds a structured request: slot dimensions, page URL, user geo, device, privacy-permitted identifiers.
3. The exchange fans it out. An ad exchange broadcasts the request to connected demand partners — dozens of them, in parallel.
4. Demand platforms evaluate and bid. Each demand-side platform (DSP) scores the impression against its advertisers' targeting, budgets and frequency caps, then responds with a bid price and a creative — or passes.
5. The auction clears. The exchange picks the winner (first-price, in today's market), notifies the DSP, and returns the winning creative.
6. The ad renders and money moves. The creative displays, impression trackers fire, and the publisher is paid the clearing price minus the fees of everyone in the path.

The entire round trip runs inside a strict timeout — bids that arrive late simply don't count — which is why the ecosystem obsesses over latency.

The cast of characters#

The lines blur constantly — major SSPs run exchanges, DSPs buy from each other, and the same company can sit on both sides — which is part of why supply-path transparency became an industry issue at all. For the broader context of how these pieces assemble into a buying strategy, see programmatic advertising.

First-price vs second-price: why the auction changed#

Classic RTB ran second-price auctions: the winner paid just above the runner-up's bid, so bidding your true value was safe. Then header bidding put the same impression into several parallel auctions at once, and the "second price" stopped meaning anything — a second-price win in one auction still had to compete first-price against the other auctions' winners. Layer in exchanges quietly applying floors and fees, and price discovery turned opaque.

The industry converged on first-price auctions: the winner pays what they bid. Simpler and more honest, but it moved the strategy burden onto buyers — bid your true maximum every time and you systematically overpay, which is why DSPs now run bid shading: algorithms that estimate the minimum winning price and bid closer to that. If you buy programmatically and your DSP's shading is bad, you fund the difference.

Header bidding: the fix for the waterfall#

Before header bidding, publishers ran a waterfall: demand sources were called one at a time in a fixed priority order, each getting a chance to buy at a preset floor before the request "passed back" to the next. Result: the first source in line could buy undervalued inventory while better bids further down never saw the impression.

Header bidding inverts this. A script in the page header (or, in the server-side variant, a proxy the page calls once) requests bids from many SSPs and exchanges simultaneously, then passes the best bid into the publisher's ad server to compete with directly-sold campaigns. Every demand source sees every impression at the same moment, on equal footing.

The trade-offs are operational: client-side header bidding adds page latency and JavaScript weight; server-side trades that for lower cookie-match rates. Most sophisticated publishers run a hybrid. For buyers, the practical consequence is simpler: the days of finding systematically underpriced inventory in a badly-configured waterfall are gone — edge now comes from creative and funnel, not auction arbitrage.

OpenRTB and the transparency layer#

OpenRTB — an IAB Tech Lab standard — is the JSON protocol the bid request and response travel over: standardized objects describing the impression, site, device, user and the bid itself. It is why a DSP can talk to fifty exchanges without fifty integrations.

Around the protocol sits a public transparency layer built to fight fraud and murky reselling:

• ads.txt — a file on the publisher's domain listing who is authorized to sell its inventory.
• sellers.json — the mirror image: exchanges publish who they represent.
• The schain object — every OpenRTB request carries the chain of intermediaries the impression passed through.

These artifacts are public by design — which means outside observers can audit programmatic paths, not just participants. That auditability is the foundation of modern supply-chain analysis.

Where native ads fit — and where they don't#

Here is the part display-centric explainers get wrong. The big native networks — Taboola, Outbrain, MGID, Revcontent — do not primarily sell through the open RTB pipes. Each runs its own closed marketplace: advertisers bid inside the network's platform, and the native ad auction happens network-internally for each widget slot, per user, per page view.

RTB concepts still apply — it is a real-time, per-impression auction with floors and pacing — but the competitive arena is different. Your Taboola bid competes against other Taboola advertisers, not against the open exchange. OpenRTB has a Native Ads spec, and native inventory does flow programmatically at the edges; networks also resell each other's demand, producing supply paths with more hops than a typical display impression. We traced real examples of these chains — widget to network to reseller to advertiser — in the native ad supply chain, explained.

Practical consequences for a media buyer:

• DSP tooling mostly can't see native-network auctions. Programmatic dashboards won't tell you what's running on Taboola.
• Competition is network-local. Winning on MGID is about beating MGID's advertisers in your geo and vertical, not the global programmatic market.
• The supply chain is observable anyway. Because served ads and their request chains are public-facing, independent observers can classify who served what — the technique behind how ad spy tools capture native ads.

Why this matters when you buy#

Three working conclusions from the mechanics:

1. Know your path, know your fees. Every intermediary in the chain takes a cut before the publisher is paid; on resold native inventory the hops multiply. Fewer hops generally means more of your dollar buys attention.
2. First-price changed bidding. Don't bid your ceiling reflexively; understand what shading your platform applies — and on native networks' internal auctions, test bid levels empirically because no shading is done for you.
3. On native, competitive research replaces auction data. You cannot query Taboola's auction, but you can observe its output. OpenAdLibrary's supply-chain classification — built from 6.8 million+ ad observations across 49 networks (July 2026) — shows which networks and resellers actually served an ad, per creative, in the ad intelligence platform. Reading the served reality beats guessing at the auction.

RTB is a simple idea executed at absurd scale: one auction per impression, cleared before the page paints. Understand the auction, the protocol and the paths — and the programmatic acronym soup reduces to plumbing.