Just as we were ahead of our time with Search Engine Optimization, digital publishing and running an all-remote workplace, Mediavine was into header bidding before it was cool.
In fact, we’ve been using header bidding before it even had a name — it was simply the technology we used to power our auctions when we began offering ad management services.
Without getting too deep into ad tech history, the industry switched to header bidding from waterfalls because it was both faster and more efficient — both fairly important considerations.
This enabled us to utilize real time bidding and live auction prices instead of using historical averages to determine winners. It was a game changer, and now, the game is changing again.
Server-to-Server Header Bidding, commonly stylized as S2S, is the newest evolution in ad serving technology.
Mediavine has been moving toward S2S for the past year and a half. We predict the rest of the industry will follow, much like they did with the client-side header bidding of the past five years.
Before we talk about the next iteration of header bidding, it’s important to understand the “old technology” or the current technology, depending on your point of view and where one is in the evolution.
In traditional header bidding, or client-side header bidding, auctions are run in real time on the user’s web browser (this process is sometimes referred to as browser-side header bidding).
This means that before ads can load, the user’s browser sends network requests to each of the bidders in the auction.
In today’s market, that can easily mean 10-20 different bidders — and thus 10-20 network requests that must be sent out before the ad server can finally start serving ads using lazy loading.
On a mobile device, that many requests begins to be a problem. Mobile browsers generally only send a few requests at a time, meaning header bidding could compete with the site itself loading.
This is also not great for ad loading speed. All those requests mean a second or two of waiting for the auctions to complete before calling the ad server, which then runs its own auction and determines a winner.
You’re often talking almost three seconds for the auction, and potentially even more for the ad to complete rendering. Three seconds is actually a long time — long enough to negatively impact ad viewability.
As an industry, we justified this for a while because it was still light years faster and way more efficient than those truly old-fashioned waterfalls, however it’s become clear that this is no longer good enough.
Mediavine prides itself on optimum pagespeed and viewability, and we knew there was room for improvement.
The solution? Stop running header bidding within the web browser and instead run it on a server. That’s where S2S comes in.
Server to Server (S2S) Header Bidding uses the same concept as client-side header bidding, but instead of requesting the bids directly from the web browser, the client requests bids from a server, which sends the bids to the ad exchanges.
This means the client makes just a single request to the server, while the server makes those 10-20 requests to the servers of the ad exchanges.
Hence the name “server to server.” Mediavine’s header bidding server is communicating directly with the ad exchange servers.
Remember when we talked about mobile devices and mobile browsers before? With S2S, as an ad is about to load, the client (or browser) only sends out a single request, while getting back those same 10-20 bids to submit into the ad server for the auction.
For something a casual reader might never notice, S2S actually makes a world of difference to publishers.
Again, many mobile browsers limit how many simultaneous requests you can make, which can mean some exchanges getting dropped from the auction altogether — what our industry calls a “timeout.”
Every timeout is essentially money left on the table. What if the top bid wasn’t received before the auction ended, or the ad rendered?
To simplify this even more: Browsers are slow. The “servers” we refer to when talking about S2S are fast.
These are expensive, professional-grade internet connections designed to rapidly process this kind of volume. Compared to a phone running off a battery with a cellular connection, it’s night and day.
Since S2S is so much faster and more efficient at returning bids, you don’t have to wait as long for the process to complete.
That means less latency, or what computer nerds call the delay before transfer of data begins following an instruction for its transfer.
With less latent (sometimes called low-latency) delivery, you can shorten what’s called the auction timeout — the length of time you’re willing to wait for the bids you send out to come back to you.
This is a long way of saying that with a tighter auction timeout, less time elapses before you can render an ad. That means the ad is more likely to be seen, which means higher viewability.
And higher viewability, as you all know if you read the Mediavine blog, means more money in your pocket.
There are multiple options for running S2S, ranging from off the shelf products like Prebid Server, Amazon Transparent Ad Marketplace and Google Open Bidding, or, to try building it yourself.
If you know Mediavine, you can probably guess the route we went.
Much like our in-house Mediavine video player or our CMP, we built our own in-house S2S server based on the OpenRTB (Real-Time Bidding) specifications from the Interactive Advertising Bureau (IAB).
Our own server not only gives us insane computing power, but also levels of customization and flexibility that third-party options lack.
Mediavine’s custom integrations enable us to do so much more processing on the backend, while ensuring optimal bid requests are sent out to the right partners. S2S put us and our publishers ahead of the pack.
There’s a reason the entire web hasn’t adopted S2S yet.
There are some significant roadblocks that have historically prevented many in the advertising ecosystem from moving over.
Traditional / client-side / browser-side header bidding has become easy to run thanks to Prebid.js. Server side is doable as well, if you use hosted solutions like Amazon, Google or even versions of Prebid Server.
Translation: Building your own server to do this means putting up giant data centers prepared to handle billions of requests a month.
It requires significant technical knowledge and resources that most companies couldn’t dream of handling themselves.
Luckily, Mediavine has the best engineers in the business.
This is actually the most complex obstacle to S2S.
As you’re likely aware, there are these things called third-party cookies. They’re used for what is called “user matching” or figuring out the anonymous ID that corresponds to a user and matching that up to an advertiser’s anonymous ID for that user.
Without getting too technical, cookies can only be read via web browsers, not on servers. Introduce a server into the ad serving equation, and you lose the ability to read a user’s cookies.
Basically, you need to do your own user matching or cookie syncing, in order to parse all those IDs from the cookies and transmit them to the server to make the necessary requests.
This is typically where most S2S solutions fall apart, and Mediavine had to spend considerable resources to overcome this roadblock.
Of course, this will be something of a non-issue once third-party cookies go away and are replaced by first-party data but we’re not there in earnest yet, and this was major hurdle we had to clear before going S2S.
Are you wondering whether the user matching and overall complexity is worth it, since the old header bidding seemed to work pretty well?
Since we’re running it, I think you know the answer.
We’ve experimented with S2S for years via products like Amazon and Google Exchange Bidding, and even tested Prebid Server.
However, in order to truly shift our entire operation in a way that made sense for years to come, we knew we had to forge our own path.
We’re excited to announce publicly for the first time that we’ve built our own custom OpenRTB server, known as the Mediavine Exchange.
Running for over two years now as we’ve refined its capabilities, our custom OpenRTB server handles more than 300 billion bid requests a month, which is just a bonkers number to think about.
With nearly all of our ad partners already migrated to the Mediavine Exchange, client-side header bidding is headed toward retirement in 2021 after a distinguished six-year career. We thank it for its service!
Our plan is for Mediavine ad operations to be fully server-to-server next year, which may not sound like a huge deal, but most of our competition has only recently started to dip its toes in S2S.
We have a two-year head start.
In this increasingly privacy-centric world, we are adapting to stay ahead of the curve, as we always have. Being fully S2S in 2021 puts Mediavine and its publishers at a significant advantage amid these sweeping changes.
We’re very fortunate and excited to have the resources necessary to bring industry-leading technology to independent publishers — innovations that even the largest publishers on the internet are still dreaming about.
We are forever grateful to our Mediavine publishers for giving us the opportunity to build the industry’s leading S2S solution.
Stay up to date with the latest from Mediavine
Brad Hagmann
It seems hard to believe that we’re more than a month into a new year, and with it, a new and ever-changing technological landscape. Looking back on the previous year, …
Brad Hagmann
Ah, July. It’s a glorious month of sand-filled swimsuits, mosquito invasions, broken air conditioners and applying sunscreen only to look like cooked lobsters. It’s also the start of a new …
Heather Tullos
The switch from Universal Analytics to GA4 is well underway, and as we all learn about these new metrics, adjust perspectives on how we measure success on our sites, and …
