How header bidding works

0:00Welcome, outcomes and key terms

Play from 0:00 It's nine o'clock on a match night. A sports site in Pune is serving four million ad impressions an hour.

Play from 0:18 If those impressions sell at a CPM just twenty cents lower than buyers would have paid, that's eight hundred dollars gone in one hour. That's an illustrative number. Nobody sees it in a report, because a bid that was never asked for leaves no trace.

Play from 0:26 Header bidding exists to find that money. This is Module 1 of the RediAds Academy Header Bidding Masterclass: how header bidding works.

Play from 0:37 In the next thirty minutes, you'll learn to do four things.

Play from 0:40 Explain, with numbers, why a unified header auction earns more than a waterfall.

Play from 0:46 Follow one auction from the moment the page asks for bids to the moment an ad appears.

Play from 0:52 Read what an SSP actually sends back, and spot a gross bid pretending to be net.

Play from 0:59 And say which decisions Prebid makes, and which ones belong to Google Ad Manager.

Play from 1:06 Eight terms we'll use all the way through. They'll each come back with an example.

Play from 1:12 A wrapper is the script that runs the header auction. Prebid.js is a wrapper. An adapter is Prebid's translator for one partner. An SSP, a supply-side platform, sells your impression to buyers. GAM is Google Ad Manager, the ad server.

Play from 1:31 CPM is the price per thousand impressions. A first-price auction means the winner pays what it bid. A key-value is a label on an ad slot that the ad server can read. And a line item is a rule inside Ad Manager that can win an impression.

Play from 1:50 The course has eight modules. This one and the next are the browser: how the auction works, then the Prebid wrapper itself.

Play from 2:05 Modules three and four move the auction to a server with Prebid Server. Five and six are Ad Manager: set-up, creatives, floors and yield. Seven and eight are debugging, discrepancies and monitoring.

Play from 2:13 If you already know why the waterfall died, skip to chapter two. Otherwise, let's start there.

2:22Why header bidding exists

Play from 2:22 Chapter one. Why does header bidding exist at all? To answer that, we need to look at how ads were sold before it.

Play from 2:32 For years, most publishers sold their remaining inventory through a waterfall.

Play from 2:37 The ad server called one partner first. Say, an exchange with a three-dollar floor.

Play from 2:43 If that partner didn't fill, the impression fell to the next partner, at two dollars.

Play from 2:49 Then the next, at one dollar. And so on, down the waterfall, until someone said yes or a house ad showed.

Play from 2:57 Each step is a separate call, made one after another. Every pass-back adds delay before an ad appears.

Play from 3:06 So who decided the order? A person, usually once a week.

Play from 3:11 Ad ops looked at last week's average CPM per partner. Illustrative numbers: partner A averaged one dollar sixty, B one thirty, C one ten.

Play from 3:23 A went first, B second, C third. That order then stayed fixed for every impression, all week.

Play from 3:32 Notice the flaw. An average tells you what a partner paid across millions of impressions. It tells you nothing about what it would pay for this reader, right now.

Play from 3:44 Here's that flaw on one impression. These numbers are illustrative.

Play from 3:49 Partner A is first in line. Today it bids one dollar twenty, clears its floor, and wins.

Play from 3:56 But partner C, sitting further down, would have paid two dollars forty for this exact impression.

Play from 4:03 It never got asked. The publisher earned half of what the impression was worth.

Play from 4:08 And nobody noticed, because the lost bid never shows up in any report.

Play from 4:15 Now scale that to a thousand impressions. All numbers illustrative.

Play from 4:20 Partner A fills five hundred and fifty of them, at an average of one dollar forty. That's seventy-seven cents.

Play from 4:28 Partner B fills two hundred and fifty, at one dollar ten. About twenty-eight cents.

Play from 4:33 Partner C fills one hundred and fifty, at ninety cents. About fourteen cents.

Play from 4:40 Fifty go unfilled. Total: one dollar eighteen for the thousand. That's an effective CPM of one dollar eighteen.

Play from 4:50 Now run the same thousand impressions through one auction, where every partner bids on every impression.

Play from 4:57 On each impression, the highest bid wins. Sometimes that's A, sometimes C, sometimes a partner who rarely won before.

Play from 5:06 In our example, the average winning price rises to one dollar sixty-five. Fill rises to nine hundred and seventy.

Play from 5:15 Revenue: one dollar sixty for the thousand. That's about thirty-six per cent more, from the same pages and the same readers.

Play from 5:24 The extra money doesn't come from new demand. It comes from asking the demand you already had, at the right moment.

Play from 5:33 Publishers did try to fix the waterfall from the inside. The usual move was raising floors.

Play from 5:40 Illustrative. Partner A's floor goes from one dollar to two dollars. Now A only fills when it's sure to pay two dollars or more.

Play from 5:50 A's fill drops from fifty-five per cent to thirty. Everything else falls through to B and C, one pass-back later.

Play from 5:58 So the average price on A goes up, but total revenue barely moves, and the page gets slower. A floor can only say no. It can't ask the other partners what they'd pay.

Play from 6:14 The waterfall also loses time.

Play from 6:16 Suppose each pass-back takes three hundred milliseconds. Illustrative. Partner C is only asked after A and B have both said no. That's six hundred milliseconds before C even hears about the impression.

Play from 6:32 In a header auction, all partners are asked at once. The wait is set by the slowest partner you're willing to wait for, not by the sum of everyone.

Play from 6:39 We'll put exact numbers on that wait in Module 2.

Play from 6:47 So header bidding flips the model. Instead of asking partners one by one, a script in the page asks all of them at the same time.

Play from 6:57 Each partner answers with a price for this specific impression.

Play from 7:01 The best price is then passed to the ad server, which compares it with its own demand. One fair, simultaneous auction instead of a queue.

Play from 7:09 The name comes from where the code first lived: in the page header, before the ad server is called.

Play from 7:19 A very short history, so the names make sense later.

Play from 7:23 Around 2014, header bidding started as custom wrappers built by individual exchanges.

Play from 7:30 In 2015, Prebid.js was released as open source, so every publisher could run one neutral wrapper instead of one per partner.

Play from 7:39 In 2017, Prebid.org was formed to govern it, and Prebid Server arrived to run auctions outside the browser.

Play from 7:48 Since then, the big changes have been about privacy, identity and speed. Today, Prebid is the default open-source header bidding stack on the web.

Play from 8:00 Two mistakes we still see, years after the waterfall officially died.

Play from 8:05 One: a waterfall hiding behind header bidding. An old ad network tag still sits in the ad server at a fixed price, above the header bids. It takes impressions without ever competing.

Play from 8:19 Two: judging header bidding by CPM alone. A partner can raise your average CPM while filling fewer impressions. The number that matters is revenue per thousand sessions. We'll use it in Module 2.

8:34The cast

Play from 8:35 Chapter two. Before we follow an auction, let's meet the cast. Five players, and you need to know exactly what each one does.

Play from 8:46 First, the page itself, with Google Publisher Tag, the GPT library, which defines your ad slots.

Play from 8:54 Second, Prebid.js, the wrapper. It runs the header auction.

Play from 8:59 Third, bidder adapters. Small modules inside Prebid, one per partner.

Play from 9:05 Fourth, the SSPs and exchanges behind those adapters. They run their own auctions with buyers and return a bid.

Play from 9:13 And fifth, Google Ad Manager, the ad server. It makes the final decision about which ad is shown.

Play from 9:21 Remember this order: page, wrapper, adapters, exchanges, ad server. We'll use it for the rest of the course.

Play from 9:30 The first player deserves one more minute, because everything else hangs off it.

Play from 9:36 GPT defines each ad slot with three things: the Ad Manager ad unit path, the sizes, and the ID of the div on the page where the ad will sit.

Play from 9:47 Prebid describes the same slot in its own list, called ad units. Each one has a code.

Play from 9:54 Those two descriptions must point at the same place. Usually that means Prebid's code equals the div ID. When they drift apart, bids get lost, and Module 2 shows exactly how.

Play from 10:09 A quick detour, because adapters cause a lot of confusion.

Play from 10:28 An adapter is a translator. Prebid describes every ad slot in one common format. The adapter turns that into the exact request its exchange expects, usually an OpenRTB request over the network. When the exchange answers, the adapter turns the response back into a standard Prebid bid.

Play from 10:37 That's why adding a partner is usually just adding its adapter to your build and a few lines of configuration. It's also why a badly maintained adapter can slow your whole page down.

Play from 10:48 Here's something people often miss. There are auctions inside the auction.

Play from 10:54 When the RediAds adapter sends a request, the SSP runs its own auction among its buyers.

Play from 11:00 Each SSP sends back only its best answer. So Prebid never sees every buyer, only one bid per partner.

Play from 11:09 That's why two SSPs can return different prices for the same impression. They're talking to different buyers, with different data.

Play from 11:19 So who decides what? Prebid decides which header bid is best for each slot. Google Ad Manager decides whether that best header bid beats everything else it can serve: direct deals, Google's own demand, and house ads.

Play from 11:33 Keep those two decisions separate in your head. A lot of "Prebid isn't winning" problems are really ad server set-up problems, and we'll fix those in Modules 5 and 6.

Play from 11:49 One mistake here, and it costs a lot of meeting time.

Play from 11:53 Blaming the wrapper for an ad server decision. Someone sees AdX serving most impressions and says Prebid is broken.

Play from 12:02 First ask which decision you're looking at. Did Prebid pick the wrong header bid? Or did Ad Manager prefer something else? The fix lives in a different place for each.

12:14One auction, step by step

Play from 12:15 Chapter three. Let's follow one auction, step by step, for one ad slot. Then we'll watch it happen live.

Play from 12:25 Here's the whole journey in six steps.

Play from 12:28 One. The page loads Prebid and calls requestBids.

Play from 12:32 Two. Prebid sends bid requests to every adapter at about the same time.

Play from 12:38 Three. Bids come back, each one at its own speed.

Play from 12:42 Four. When all bids are back, or the timeout hits, Prebid runs its internal auction.

Play from 12:48 Five. Prebid writes the winning bid into key-values on the ad slot.

Play from 12:53 Six. GPT calls Google Ad Manager, which picks the final winner and serves the creative.

Play from 13:01 Step two looks simple, but two details matter.

Play from 13:05 By default, Prebid calls your bidders in random order. No partner gets a permanent head start just because it's first in your list.

Play from 13:14 And the auction has a deadline, called the timeout. Prebid stops waiting when it's reached. Its built-in default is three seconds, which is far too long for most pages. Module 2 shows how to choose yours.

Play from 13:30 Four partners answered for this slot. Illustrative prices.

Play from 13:34 RediAds bid two dollars. Sovrn, one ninety. OpenX, one fifty. Index Exchange, one dollar.

Play from 13:43 Each one arrived at a different time. The fastest might take a hundred milliseconds, the slowest several hundred.

Play from 13:52 In real life, a partner can give you one of three other answers.

Play from 13:57 A no-bid. It looked at the impression and passed. That's normal, and on many pages it's the most common answer.

Play from 14:05 A late bid. It arrived after the timeout. Prebid has already run its auction, so that bid is left out, however high it was.

Play from 14:14 An error. The request failed or the response couldn't be read. On one page view it's noise. On thousands, it's a problem to chase with the partner.

Play from 14:26 Prebid's internal auction is simple. Highest price wins. RediAds, at two dollars, is the best header bid for this slot.

Play from 14:36 Two adjustments can happen first. Prices in other currencies are converted, and a price can be corrected if a partner reports it gross. We'll see both in chapter four.

Play from 14:48 And RediAds hasn't won the impression yet. It's only won the right to go to the ad server.

Play from 14:55 Steps five and six get their own chapter later, so here's the short version.

Play from 15:01 Prebid can't hand Ad Manager a bid object. It writes key-values on the slot instead: the price bucket, the bidder, and an ID to find the creative.

Play from 15:11 Then GPT calls Ad Manager, which compares that price with everything else it could serve.

Play from 15:17 Now let's watch all six steps happen on a real page.

Play from 15:23 Here's a real page running one header auction. It's our demo news site, The Monsoon Times, with one ad slot on the right. The test prices are the same ones from the slides.

Play from 15:53 Down below is the console, and with pbjs underscore debug switched on, Prebid writes down every step it takes.

Play from 16:08 Let's filter for bids. You can see the requests going out to all four partners, and the responses coming back.

Play from 16:15 Now let's ask Prebid directly what happened. First, every bid for our slot. Four partners answered: RediAds at two dollars, Sovrn at one ninety, OpenX at one fifty and Index at one dollar.

Play from 16:19 Next, who won Prebid's auction? RediAds, because it had the highest price. Nothing cleverer than that.

Play from 16:21 And what did Prebid tell the ad server? The hb_pb key-value says two point zero zero. That's the price bucket, and it's all Ad Manager will see of this bid.

Play from 16:23 From here, the decision belongs to Ad Manager. Prebid picked the best header bid. Ad Manager decides who actually serves.

Play from 16:33 Two mistakes we see in this part of the auction.

Play from 16:36 One: the same partner, called twice. It runs through Prebid and through an old direct tag, or through two wrappers. Now it can bid against itself, and set its own clearing price.

Play from 16:50 Two: judging a partner from one page view. One auction tells you how the machinery works. Whether a partner earns its place takes thousands of auctions, and we'll measure that in Module 2.

Play from 17:04 Quick check. Pause the video if you want to think.

Play from 17:12 Four bids arrive: two dollars, one ninety, one fifty and one dollar. A colleague says the two-dollar bidder will now serve the ad. Are they right?

Play from 17:20 Not yet. The two-dollar bid has only won Prebid's auction. Ad Manager still compares it with direct deals, Google's demand and house ads, and any of those can win.

17:32What a bid really is

Play from 17:33 Chapter four. We've been saying "RediAds bid two dollars". But what exactly is that two dollars? Who pays it, in which currency, and before or after fees?

Play from 17:47 Start with how prices used to work. Most exchanges once ran second-price auctions.

Play from 17:54 The highest bidder wins, but pays one cent more than the second-highest bid.

Play from 17:59 Illustrative example. Buyer one bids three dollars. Buyer two bids two ten. Buyer one wins, and pays two dollars eleven.

Play from 18:09 The idea was fairness. Buyers could bid what an impression was truly worth, without fear of overpaying.

Play from 18:18 Header bidding put many of these auctions side by side, and that broke the idea.

Play from 18:24 Each exchange's "second price" depended on who happened to be in its own auction. The same buyer could clear at very different prices on different exchanges.

Play from 18:35 Floors and fees were applied in ways buyers couldn't see. So buyers stopped trusting the clearing price.

Play from 18:43 Through 2017 and 2018, exchanges moved to first-price auctions. In 2019, Google moved Ad Manager to a unified first-price auction.

Play from 18:56 In a first-price auction, the winner pays exactly what it bid.

Play from 19:01 Illustrative. Buyer one bids three dollars, buyer two bids two ten. Buyer one wins and pays three dollars.

Play from 19:10 So buyers adapted. They now shade their bids: they bid less than the impression is worth to them, using models that predict the lowest price that still wins.

Play from 19:21 For you, the good news is simple. The price an SSP sends to Prebid is much closer to what will actually be paid.

Play from 19:31 That's why a header auction can be fair at all.

Play from 19:35 Prebid compares four prices from four different exchanges. That only works if all four mean the same thing: what you'll be paid, in the same currency, after fees.

Play from 19:47 When one of them means something else, the comparison quietly breaks. The rest of this chapter is about the three ways it breaks: format, gross pricing, and currency.

Play from 20:00 Here's what an SSP actually returns. It's an OpenRTB bid response, trimmed down.

Play from 20:08 The price, as a CPM. The ad markup, which is the creative code itself. A creative ID, the advertiser's domain, and the width and height. And a currency code. If it's missing, OpenRTB assumes US dollars.

Play from 20:26 If the SSP has no bid, it usually sends back nothing at all, with HTTP status 204. A no-bid is a normal answer, not an error.

Play from 20:39 The adapter turns that response into a standard Prebid bid. These are the fields worth knowing.

Play from 20:46 cpm and currency: the price and what it's in. width, height and ad: the size and the creative. ttl: how many seconds Prebid may use this bid before it expires. creativeId and advertiser domains: what you'll need when a bad ad shows up.

Play from 21:06 And netRevenue: true means the price is net, what you'll actually be paid. False means gross, before the partner's fee.

Play from 21:16 Here's how a gross price quietly wins. All numbers illustrative.

Play from 21:22 RediAds bids two dollars, net. Partner X bids two dollars twenty, but that's gross. X keeps fifteen per cent as its fee.

Play from 21:32 Without any correction, Prebid compares two dollars with two twenty. X wins.

Play from 21:37 But X will really pay you one dollar eighty-seven. You picked the lower bid, and you'll never see why in Prebid's numbers.

Play from 21:46 The fix is a bid adjustment. In Prebid's bidder settings, you multiply X's price by zero point eight five before the auction. Now X is one eighty-seven, and RediAds wins fairly.

Play from 22:00 Same page, but this time one partner is quoting gross. Let's look inside a single bid first.

Play from 22:38 Here's RediAds' bid as Prebid stores it. The price is two, the currency is US dollars, and netRevenue is true, so that's what you'll be paid. The ttl says how many seconds this bid stays usable. The creative ID is what you'd quote to the partner if a bad ad turned up. And timeToRespond shows how quickly the answer came back.

Play from 22:56 Now every bid, with its net flag. Sovrn bid two dollars twenty, but look: netRevenue is false. That price is gross.

Play from 23:06 What about OpenX? It sent a no-bid. That's a normal answer, and Prebid records it separately.

Play from 23:11 So who wins Prebid's auction right now? Sovrn, with a gross price that's higher than what it will actually pay.

Play from 23:13 Let's fix it. We reload the page with one line of bidder settings, multiplying Sovrn's price by zero point eight five.

Play from 23:14 Here are the prices again, before and after. Sovrn's two twenty is now one eighty-seven.

Play from 23:15 And the winner? RediAds, at two dollars. Same bids, same page, a different and correct result.

Play from 23:16 The third way the comparison breaks is currency. This matters a lot if your ad server runs in rupees.

Play from 23:24 Most SSPs bid in US dollars. But your Ad Manager network, and your price buckets, may be in INR.

Play from 23:32 Prebid's currency module converts every bid into your ad server currency before the auction. You set it once, with adServerCurrency.

Play from 23:42 Illustrative rate. At eighty-four rupees to the dollar, a two-dollar bid becomes one hundred and sixty-eight rupees.

Play from 23:49 The module also has a granularity multiplier, so your price buckets scale with the currency. We'll build rupee buckets properly in Module 5.

Play from 24:00 So, before you trust any price in a header auction, ask it three questions.

Play from 24:07 Is it net? If the partner reports gross, adjust it before the auction.

Play from 24:12 What currency is it in? If it isn't your ad server currency, convert it with the currency module.

Play from 24:19 Is it still fresh? Every bid has a time to live. A bid used after it expires may never be paid.

Play from 24:28 Three mistakes from this chapter that cost real money.

Play from 24:32 One: a gross bidder with no bid adjustment. It wins too often, and pays less than it seems to.

Play from 24:40 Two: a bid adjustment that stays forever. The partner changes its fee or switches to net pricing, and nobody updates the number.

Play from 24:50 Three: mixing currencies without the currency module. A rupee bid and a dollar bid get compared as if they were the same unit.

25:00From bid to ad server

Play from 25:01 Chapter five. Prebid has its winner. Now let's follow it into Ad Manager, and see what happens on the other side.

Play from 25:11 Prebid can't hand Google Ad Manager a bid object. It can only set targeting key-values on the slot. So it sets these.

Play from 25:20 hb_pb: the price bucket. hb_bidder: who bid. hb_adid: the ID Prebid uses to find the creative later. hb_size: the creative size. And a few more, such as the format and where the bid came from.

Play from 25:43 Notice that hb_pb is a bucket, not the exact bid.

Play from 25:49 Prebid's default granularity is called medium. It uses ten-cent steps, up to twenty dollars.

Play from 25:56 Every price is rounded down into its step. A bid of two dollars seven becomes two point zero zero. A bid of one ninety-six becomes one point nine zero.

Play from 26:08 Anything above twenty dollars is capped at twenty.

Play from 26:12 Why buckets at all? Because Ad Manager needs a line item for each price it can see. Buckets keep that number manageable.

Play from 26:22 One more thing Prebid does by default. It doesn't only send the winner.

Play from 26:27 It sends the winner's keys, hb_pb and the rest.

Play from 26:32 And it sends a second set for every bidder, with the bidder's name on the end. hb_pb underscore rediads, hb_pb underscore sovrn, and so on.

Play from 26:45 That lets Ad Manager report on every partner's bids, not only the winners. The trade-offs come in Module 6.

Play from 26:54 Two bids this time, chosen to sit just above a bucket edge.

Play from 27:22 Here are the exact prices next to their medium buckets. RediAds bid two dollars seven, and its bucket is two point zero zero. Sovrn bid one ninety-six, and its bucket is one point nine zero. Both rounded down, never up.

Play from 27:36 Now let's ask GPT, not Prebid. This is the targeting sitting on the slot, which is what goes to Ad Manager. Two point zero zero. The seven cents are gone.

Play from 27:43 And here's every Prebid key on that slot. The winner's keys, plus one set per bidder, ending in underscore rediads and underscore sovrn. That's send-all-bids, on by default.

Play from 27:47 The lesson for later: Ad Manager only ever sees buckets. How you size them is a revenue decision, and we'll make it properly in Module 5.

Play from 27:51 Now Google Ad Manager runs its own competition.

Play from 27:54 Sponsorships and standard direct deals usually come first. In this example, none of them are eligible for this impression.

Play from 28:03 Next, the price-based layer. Our Prebid line item targets hb_pb equals two point zero zero, so it enters at two dollars.

Play from 28:14 In the same unified first-price auction, Google's own demand competes against that two dollars. Today, AdX bids two dollars and two cents.

Play from 28:24 AdX wins, by two cents.

Play from 28:28 And that's completely fine. The header bid did its job.

Play from 28:33 It forced Google's demand to pay more than two dollars for this impression.

Play from 28:37 Without header bidding, there'd be no two-dollar line item in the auction at all. AdX might have cleared much lower.

Play from 28:45 So when you report on header bidding, don't only count Prebid wins. Count the price pressure too.

Play from 28:53 Now look at what bucketing costs. Illustrative numbers again.

Play from 28:58 RediAds actually bid two dollars seven. Ad Manager sees only two point zero zero.

Play from 29:05 AdX bids two dollars three. It beats the bucket, so AdX wins.

Play from 29:10 But RediAds would have paid two dollars seven. You earned four cents per thousand less than the best bid on the table.

Play from 29:19 Four cents sounds tiny. Across a hundred million impressions a month, it's four thousand dollars. That's why granularity gets a whole chapter in Module 5.

Play from 29:32 Now replay it on a day when the Prebid line item wins.

Play from 29:36 Ad Manager serves the Prebid line item's creative. That creative isn't an ad. It's a small script called the Prebid Universal Creative.

Play from 29:46 It reads hb_adid, asks Prebid on the page for the matching winning bid, and renders that bid's ad in the slot.

Play from 29:55 That's why the creative and the hb_adid key-value have to be set up exactly right. If they're not, you get blank ads, and the bid you won is wasted.

Play from 30:09 Here's the whole auction on one clock. Illustrative timing.

Play from 30:13 Prebid starts at zero. The first bids land at around three hundred milliseconds. The slowest partner answers at nine hundred. Prebid sets targeting and calls the ad server just after. The ad server answers, and the ad renders at around one point three seconds.

Play from 30:32 Every partner you add, and every millisecond of timeout, stretches this clock. Module 2 is about keeping it short.

Play from 30:41 Three mistakes from this chapter.

Play from 30:44 One: reading hb_pb as the real price. It's a rounded-down bucket. Your partner's report will show the exact price, and the two won't match.

Play from 30:56 Two: counting only Prebid wins. A header auction that pushes AdX from one fifty to two dollars is earning you money, even when AdX serves.

Play from 31:07 Three: line items and buckets that don't match. If Prebid sends two point zero five and no line item targets it, the bid never enters Ad Manager's auction.

31:20Recap and quick checks

Play from 31:20 Before we wrap up, three myths we hear from publishers almost every week.

Play from 31:26 Myth one: header bidding finds new buyers. Mostly, it doesn't. It makes the buyers you already have compete on every impression.

Play from 31:36 Myth two: the highest header bid always serves. It only wins Prebid's auction. Ad Manager still decides.

Play from 31:45 Myth three: if AdX wins, header bidding failed. The header bid set the price AdX had to beat. A close AdX win is often header bidding working exactly as intended.

Play from 31:59 Let's recap Module 1.

Play from 32:02 A waterfall asks partners one at a time, in a fixed order. A header auction asks them all at once, and earns more from the same demand.

Play from 32:12 Prebid picks the best header bid. Google Ad Manager makes the final decision.

Play from 32:18 Most auctions are first price now, so the bid should be what you're paid.

Play from 32:23 Every price must mean the same thing: net, in one currency.

Play from 32:28 Bids reach Ad Manager as key-values, with the price rounded down into buckets.

Play from 32:35 Quick check. Pause the video if you want to think.

Play from 32:42 A header bid of two dollars reaches Google Ad Manager. AdX bids two dollars and two cents. Who serves the ad?

Play from 32:48 AdX. The Prebid line item enters at two dollars, AdX beats it by two cents and wins. The header bid still did its job: it raised the price AdX had to pay.

Play from 33:03 One more. Partner Y bids two dollars forty, gross, and keeps twenty per cent. Partner Z bids two dollars, net. With no adjustment, who wins Prebid's auction, and who should?

Play from 33:18 Y wins, at two forty. But Y really pays one ninety-two, so Z's two dollars was the better bid. A bid adjustment of zero point eight on Y fixes it.

Play from 33:33 That's Module 1. You now know why header bidding exists, what a bid really is, and how it travels from a partner to Ad Manager.

Play from 33:47 In Module 2, we open the Prebid wrapper itself. We'll read it line by line, choose a timeout with a proper test, and protect your Core Web Vitals.

Play from 33:53 Want to practise first? Play the header bidding levels in the RediAds Academy. See you in Module 2.