Header bidding: the unified auction that reshaped programmatic
Header bidding is the publisher-side mechanism that lets every SSP bid on every impression in parallel, before the ad server makes its final decision. It replaced the old waterfall, broke Google AdX's structural advantage, increased publisher revenue, and made first-price auctions inevitable.
The world before header bidding
Until roughly 2014-2016, publishers ran a waterfall in their ad server. Direct deals had first priority. If no direct deal cleared, the ad server passed the impression to its primary programmatic source — almost always Google AdX, by virtue of AdX being the same product as Google Ad Manager. If AdX didn't fill, the impression cascaded to backup SSPs in priority order. The first one to bid above its floor won.
This had two problems. First, it structurally favored AdX: AdX got first look at every impression, and the other SSPs only saw what AdX didn't fill. Second, it allowed AdX to underprice: knowing it had first look, AdX could clear the auction at modest prices because competing demand never got a chance to bid.
What header bidding changed
Header bidding runs a JavaScript wrapper on the publisher's page that calls every connected SSP in parallel, before the ad server gets the request. Each SSP returns a bid. The wrapper picks the highest, passes it into the ad server as a line-item with that bid as the CPM, and the ad server then runs its standard waterfall — but now with the highest header-bidding bid sitting in the waterfall as a serious contender.
Net effect: every SSP got a fair chance to bid on every impression, the publisher saw the actual market price, and Google's structural advantage was reduced. Industry data from 2017-2019 showed publisher revenue lifts of 10-50% from header-bidding adoption.
Prebid: the open-source standard
Prebid is the dominant open-source header-bidding wrapper, maintained by Prebid.org (an industry consortium). Most publishers either implement Prebid directly or use a managed Prebid wrapper from an SSP (PubMatic's OpenWrap, Magnite's Demand Manager, Index Exchange's IX Wrapper). The Prebid configuration specifies which SSPs to call, what timeout to enforce (commonly 1000-1500ms before falling back), and what data to pass in the bid request.
Client-side vs server-side header bidding
Original header bidding ran client-side: JavaScript on the page made the SSP calls from the user's browser. This added latency (every SSP call from the browser) and reliability concerns (ad blockers and slow networks).
Server-side header bidding moves the auction to a cloud server. The publisher's page makes one call to the header-bidding server; the server fans out to all connected SSPs and returns the winning bid. This is faster and more reliable, but it limits the user-identity signals available (since the auction runs in the cloud, not in the user's browser). Most large publishers run a hybrid: critical-revenue SSPs client-side, long-tail server-side.
| Client-side | Server-side | |
|---|---|---|
| Latency | Higher (each SSP call from browser) | Lower (one call from browser to header server) |
| Identity signals | Full (browser cookies, local storage) | Reduced (server has limited access to user signals) |
| Reliability | Lower (ad blockers, slow networks) | Higher (cloud reliability) |
| Typical use | Top 4-6 SSPs by revenue | Long-tail SSPs |
What buyers care about
Header bidding mostly happens transparently to the buyer. The buyer's DSP sees bid requests; whether those requests originated from a header-bidding auction or a traditional SSP doesn't change the DSP's decision. The implication for buyers: every premium impression is now contested across multiple SSPs. Supply-path optimization (SPO) is the buyer's response — pick the cheapest legitimate path to a given publisher's inventory, avoid paying SSP fees on duplicate auctions.
Common implementation mistakes
- Timeout too short. A 500ms timeout means slow SSPs drop out of the auction; their demand is lost. 1000-1500ms is typical.
- Too many bidders. Connecting 15+ SSPs adds latency without adding meaningful demand. Most publishers see diminishing returns past 6-8.
- No floor-price strategy. Setting one global floor across all auctions throws away revenue. Dynamic floors per impression based on user/page signals capture 5-15% more.
- Forgetting to A/B test changes. Header-bidding config changes (new SSP, new timeout, new floor strategy) should be tested against a control segment of traffic for 1-2 weeks before rolling out.
Did header bidding really increase publisher revenue?
Yes, materially. Industry studies from 2016-2019 reported lifts of 10-50% depending on the publisher's prior stack. The lift came from forcing competition between SSPs that previously didn't see most impressions, plus exposing the true market clearing price to the ad server.
Is Prebid the only option?
Prebid is the dominant open-source wrapper, but managed wrappers from SSPs (PubMatic OpenWrap, Magnite Demand Manager, Index IX Wrapper) wrap Prebid with their own UI, support, and reporting. Underneath, they're Prebid-based. Building a fully custom wrapper is uncommon outside of large publisher engineering teams.
Does header bidding work for video and CTV?
Yes. Prebid Video and Prebid Server support video and CTV inventory. CTV header bidding usually runs server-side because the client (the smart TV or streaming device) can't run JavaScript wrappers reliably.
What is "wrap with floors"?
A floor-pricing strategy applied at the header-bidding wrapper level: dynamic floor per impression based on signals available before the auction. Recent open-source projects (Prebid Floors Provider) enable this. Done well, dynamic flooring adds 5-15% to publisher revenue.
How is Open Bidding different from header bidding?
Open Bidding (formerly EBDA) is Google's server-side answer to header bidding. SSPs bid into Google Ad Manager's server-side auction alongside AdX. The key difference: Open Bidding is run by Google; standard header bidding (Prebid) is independent of any ad server. Most large publishers run both — Prebid client-side for direct SSP connections, Open Bidding for additional Google-mediated demand.
Does header bidding still matter in 2026?
Yes, as the underlying mechanism. The implementation has shifted heavily server-side, the SSP roster has consolidated, and curated marketplaces sit on top of the wrapper. But the principle — every SSP bids in parallel, highest wins — remains the architecture of programmatic transactions for premium publisher inventory.
Operating checklist
- Validate exchange / network access before negotiating deal terms.
- Document the supply path end-to-end (publisher → SSP → exchange → DSP).
- Set pre-bid filters for IVT, viewability, and brand safety at launch.
- Run inclusion lists, not just exclusion lists.
- Reconcile spend across DSP and SSP reports weekly.
- Renegotiate fee structure annually against benchmark.
- Document every deal ID, seat ID, and contact in a runbook.