Somewhere, right now, someone taps a link to a recipe site. Their phone screen fills in: a headline, a photo of a dish, a block of text. Near the top, there is a rectangle waiting for an ad. By the time their eyes reach that rectangle, an entire marketplace has already opened, run an auction among strangers, declared a winner, and closed again.
This article follows one ad auction through its hundred milliseconds. Not the vocabulary of real-time bidding in general, which we have already covered elsewhere, but the actual sequence of one impression, step by step, the way it would look if you could slow it down enough to watch.
An ordinary moment in a kitchen, the kind of pageview a 300×250 slot just below the recipe is waiting to fill.
0 ms: the page asks for an ad
The recipe page’s code reaches the empty rectangle and asks, in effect, “who wants to fill this?” This is not a question the page answers itself. It hands the job to code supplied by an ad exchange or a header bidding wrapper sitting on the page, whose only purpose is to find out who, among thousands of possible buyers, wants this exact moment.
Nothing about the visitor is special yet. They are just a browser that opened a page.
The whole journey, start to finish, usually fits inside a tenth of a second.
10 ms: the bid request goes out
The exchange packages what it knows into a structured message called a bid request, built to the OpenRTB specification that most of the industry shares. This is the closest thing the auction has to an envelope, and it deliberately says very little about the person.
A bid request for our rectangle might describe:
- The slot: a 300 by 250 pixel banner, positioned partway down the article.
- The content: a cooking site, this page categorized as food and recipes.
- The device: a mid-range phone, a mobile browser, a rough connection speed.
- The geography: a city-level location, not a street address.
- Sometimes a deal ID, if this slot belongs to a private arrangement rather than the open market.
Crucially, there is no name, no email, no exact address. What there is, is enough context for a computer to make a reasonable guess about whether an ad here would be worth paying for. That envelope goes out, over the open internet, to every connected buyer at once. There might be dozens of them, all receiving the same request within a few milliseconds of each other.
An impression is not a person. It is a short, anonymous description of a moment, sent to everyone who might want it.
The envelope that goes out to every bidder: enough context to price an impression, never enough to identify the person behind it.
40 ms: every bidder makes a decision, alone
This is where the real work happens, and it happens independently inside dozens of separate systems that never talk to each other during the auction. Each buying platform receives the same bid request and has to answer the same three questions, fast.
Does this match anything I am running? A shoe brand’s system checks whether “cooking site, mobile, this city” fits any of its active campaigns. A furniture retailer checks the same request against its own rules. Most buyers will say no to most requests. That is normal: a request is only interesting to the handful of campaigns it actually fits.
Is this impression allowed? Even a good contextual match can fail a rule. Maybe this particular site is on a buyer’s block list. Maybe the campaign’s daily budget already ran out an hour ago. Maybe the targeting excludes this city specifically. These checks are simple individually, but there can be dozens of them, and they all have to run before the clock expires.
What is it worth, right now? If a request clears those checks, the system estimates a price: a judgment, made freshly for this one impression, about how much showing an ad here is worth. A popular sneaker brand might value a cooking-site visitor on a decent phone, in a city where they have stores, more than the same visitor on an old device far from any store.
All of this, for one single buyer, typically takes single-digit to a few tens of milliseconds. Multiply that by every connected buyer running the same process in parallel, and the whole round usually still finishes inside the time it takes to blink.
70 ms: the auction clears
Back at the exchange, bids start arriving, or do not. Most connected buyers will send nothing at all for this particular request, because it did not match anything they are running. A smaller number send an actual price.
The exchange applies its auction rules to whatever arrived before the deadline. In a first-price auction, the highest bid simply pays what it bid. There is also typically a reserve price, a floor below which the exchange will not sell the slot at all, there to protect the publisher from giving away space too cheaply.
Say three bids come in: a sneaker brand at a moderate price, a meal-kit service slightly higher, and a furniture retailer higher still, having decided this particular visitor profile is unusually valuable to them today. The furniture retailer wins, at the price it actually bid.
Any bid that arrives even a few milliseconds after the deadline is simply ignored, no matter how high it was. The clock does not wait.
85 ms: a quiet message confirms the win
The exchange sends the winning buyer a short “you won” message, along with the agreed price, so the buyer’s own systems can log the transaction for billing and reporting. In parallel, the exchange points the ad slot toward the winning creative, usually by handing back a short piece of code that fetches the actual image or video from the buyer’s own server.
This step is easy to overlook, but it matters: the auction decides who wins and at what price, while a separate, equally fast handoff is what actually makes the right picture show up in the right rectangle.
100 ms: the ad appears, and the page moves on
The furniture retailer’s ad loads into the rectangle: a sofa, a price, a short line of text. The visitor, still reading the recipe, may or may not notice it. Either way, the rest of the page has likely already finished loading around it. From their perspective, nothing unusual happened. A page loaded, like pages do.
From the industry’s perspective, a small, anonymous, fully automated market opened and closed in under a tenth of a second, among buyers who never saw each other’s bids, for a single moment that will never happen again in exactly that form.
The sofa that won the auction in our example: not because of size or budget, but because of the highest valid bid before the clock ran out.
Why does an ad auction need to be this fast?
None of this would be worth building if it took a second instead of a tenth of one. Visitors do not wait for ads to decide themselves. The entire design, the short bid request, the parallel decision-making, the hard deadline, exists to compress a real decision into a window too short for anyone to notice it happening.
That compression is also what makes the system fair to small advertisers and large ones alike. Nobody gets to think longer than anyone else. Nobody gets an early look at the competition’s price. The furniture retailer in our example did not win because of size or budget. It won because, for that one visitor on that one page, it placed the highest valid bid before the clock ran out.
If you want the fuller picture, the different auction formats, the privacy constraints on what can and cannot go into that bid request, the risks covered in ad fraud and brand safety, our explainer on real-time bidding covers that ground. This piece was about something narrower: what actually happens, in order, to one ad, one slot, one visitor, in the time it takes to glance at a phone.
FAQ
How long does a real ad auction actually take?
Usually around 100 milliseconds, from the moment a page asks for an ad to the moment the winning creative renders. Each individual bidder’s decision typically takes single-digit to a few tens of milliseconds, run in parallel across every connected buyer.
What information does a bid request contain?
Enough context to price an impression, never enough to identify the person behind it: the slot’s size and position, the page’s content category, a rough device and connection type, and city-level geography. There is no name, no email and no exact address.
What happens if two bidders send the same price?
The exchange’s own tie-breaking rules decide, but in practice this is rare given how many factors feed into a bid, down to fractions of a cent. The core rule stays the same: the highest valid bid before the deadline wins.
What happens to a losing bid?
Nothing. A losing bidder pays nothing for that impression, and the exchange moves on, evaluating the next bid request a moment later. There is no penalty for passing or losing.
Does a bigger advertiser get more time to decide in an ad auction?
No. Every connected buyer answers the same bid request within the same strict timeout, and nobody gets an early look at anyone else’s price. The impression goes to the highest valid bid, regardless of the size of the business behind it.
How Arago helps
Arago’s DSP runs exactly this sequence on every connected auction: a page opens, a slot is auctioned around 10 ms in, Arago checks your rules (zone, allowed site, budget) around 30 ms in, it bids or passes around 60 ms in, and the ad appears around 100 ms in. Those checks run against the drive-time zone, allow and block lists, and budget attached to each line item, so the same hundred milliseconds described in this article is what decides whether your ad is the one that renders.
