A single pageview on a monetized site can fire ten or more bid requests in under 300 milliseconds, and each request is a structured document that tells a buyer who is reading, what the ad slot is, and what the surrounding page permits. OpenRTB is the protocol that defines those documents, and the bid stream is the continuous traffic of requests and responses that flows between your inventory and the buyers who want it. Most publishers never see this traffic. It runs inside ad servers, wrappers, and supply-side platforms, and it decides far more about revenue than any dashboard widget does.
The practical consequence is simple: when something in the bid stream is wrong, missing, or slow, buyers bid less or not at all, and the publisher sees only the symptom, a lower CPM or a lower fill rate. This article explains the bid stream in plain terms, walks through the OpenRTB objects that carry your inventory, and separates what you control directly from what your SSP controls on your behalf. If you want the protocol from the publisher side in one place, start with our guide to OpenRTB for publishers.
What the bid stream is, in plain terms
The bid stream is the real-time flow of bid requests outward and bid responses inward between a publisher's inventory and the demand side. Each impression opportunity produces one bid request. The request travels to exchanges, DSPs, and direct buyers, each of which evaluates it and decides whether to return a bid. The IAB OpenRTB guidelines describe this model as real-time bidding, a method that puts each impression up for bid in a live auction rather than selling inventory through negotiated contracts alone.
Think of the stream as a conversation with a strict time budget. Your page loads, the ad slot calls for demand, the request goes out, buyers evaluate it, bids come back, an auction runs, and the winning creative renders. The whole cycle typically completes in a few hundred milliseconds because the user is waiting for the page. Anything that adds latency to this cycle, a slow wrapper, a bloated request, a partner with a slow response time, directly reduces the number of bids that make it into the auction. Our primer on real-time bidding covers the auction mechanics in more depth if you want the full picture.
Two properties of the stream matter most to publishers. First, the stream is only as good as the data in it. A request that omits the ad slot's position, the content language, or the consent signal gives buyers less reason to bid and less ability to price accurately. Second, the stream is competitive. Buyers see many requests per second, and they apply bid models that learn from the signals in your requests. Clean, consistent, honest signals train those models in your favor over time, while noisy or inconsistent signals train them to discount your inventory.
The OpenRTB objects that carry your inventory
OpenRTB structures every bid request as a set of nested objects, each describing one layer of the transaction. The IAB Tech Lab OpenRTB standard, currently anchored by the 2.6 maintenance release, documents every object and field, and it is the reference your ad ops team should keep at hand when auditing what your setup actually sends. You do not need to memorize the spec, but you should know which objects exist and which fields inside them carry your decisions.
The request object sits at the top and carries global context: an ID, the number of impressions in the call, test flags, and auction configuration. Inside it live the objects that matter most to revenue. The imp object describes the impression itself: the allowed sizes, the media type (banner, video, native), the floor price, and the placement type. The site object describes the publisher: domain, page URL, category codes, and the content language. For apps, the app object replaces site and carries the bundle identifier. The device object describes the hardware and browser: operating system, screen size, connection type, and user agent. The user object carries what the privacy regime permits, including consent strings. The regs object signals regulatory context, such as whether the request falls under GDPR or COPPA. The source object carries supply chain data, which we will return to because buyers increasingly refuse to bid without it.
Each object answers a specific buyer question. The imp object answers "what am I buying and at what minimum price." The site object answers "where will my ad appear." The device object answers "who will see it and on what hardware." The user and regs objects answer "am I legally permitted to target this person." When a field is absent, the buyer fills the gap with a conservative assumption, and conservative assumptions mean lower bids. This is why field completeness is a revenue lever, not a compliance chore.
What a bid request contains, and what buyers do with it
Buyers run bid models that score each request against campaign goals: target audience, brand safety requirements, performance targets, and budget pacing. The model reads your request fields and outputs a bid price. Three categories of fields move that price the most.
Context fields include the site category, page URL, content language, and the IAB content taxonomy signals that describe the page topic. A finance DSP will bid hard on a personal finance article and not at all on a recipe page, so accurate categorization directly changes which demand shows up. Placement fields include the slot position (above or below the fold), the size, the viewability signals, and whether the slot refreshes. Buyers price above-the-fold, high-viewability placements higher because the ad actually gets seen. A 300x250 slot at the top of an article and the same size at the page footer are different products in the bid stream even though they look identical in your ad server.
Audience and privacy fields include the consent string, Global Privacy Control signals, and any first-party data you pass. Under TCF, a valid consent string lets buyers lawfully apply frequency capping and audience matching, both of which raise effective prices. A missing or invalid consent string forces buyers into contextual-only bidding, which typically narrows the buyer pool and lowers CPMs. The mechanism is mechanical, not mysterious: fewer eligible buyers means less auction pressure, and less auction pressure means lower clearing prices.
One more field deserves attention: the floor price. The floor tells buyers the minimum acceptable bid, and it appears in the imp object. A floor set too high produces no-bids and unsold impressions. A floor set too low leaves money on the table for impressions that would have cleared higher. Floors work best when you tune them per placement, per geo, and per device segment rather than applying one number site-wide.
What comes back: bid responses, auctions, and the winning impression
A bid response is smaller than the request but just as structured. It contains a seat ID identifying the buyer, one or more bid objects with a price and an ad markup or creative reference, and notification URLs the buyer uses to learn the auction outcome. The ad markup field carries the creative itself or a reference to it, including VAST tags for video demand. The buyer also returns the impression ID so the publisher side can match the bid to the original request.
The auction mechanics depend on how you sell. In a first-price auction, the highest bid above the floor wins and pays its own bid amount. Most open market RTB runs on first-price logic today, which is why floor strategy matters so much: in a first-price world, a floor functions partly as a price signal that buyers read when deciding how much to shade their bids. Header bidding adds another layer. Multiple demand sources bid simultaneously before the ad server makes its final decision, and the wrapper enforces a time limit on the whole process. The intro to header bidding from the Prebid documentation explains how those time limits work: bids that arrive after the timeout get excluded from the auction, no matter how high they were.
This timeout mechanic has a direct revenue implication. A demand partner with excellent CPMs but slow response times may contribute almost nothing to your effective revenue if its bids routinely land after the cutoff. Conversely, a slightly lower-paying but consistently fast partner can out-earn it in realized revenue. You cannot see this from a revenue report alone; you need bid-level data, and that data lives in the bid stream, which is one reason a transparent SSP matters.
After the auction, the winning creative renders, and the notification URL fires so the buyer records the win. The buyer then tracks delivery and performance against its campaign. That performance data feeds back into the bid model, which means your inventory's click and conversion history shapes future bids. Inventory that performs for buyers earns sustained demand; inventory that attracts accidental clicks or fraud-adjacent traffic gets modeled downward over time.
What publishers control directly in the bid stream
Publishers control more of the bid stream than they usually realize. The requests that leave your site carry your decisions in nearly every field, and the following areas belong to you.
Ad slot architecture. You decide how many slots each page carries, which sizes each slot accepts, and where the slots sit relative to content. Slot count trades viewability against user experience. Size lists trade fill rate against auction depth: a slot accepting 300x250, 336x280, and 300x600 attracts more demand than a slot locked to one size, but each additional size fragments the auction slightly. Position is the strongest lever of the three, because above-the-fold placements reliably price higher.
Floor prices. You set the minimum acceptable price per impression, either directly or through rules your SSP applies on your behalf. In a first-price market, floors shape buyer behavior as much as they protect revenue, so treat them as a tunable system and revisit them when traffic mix shifts.
Transparency files. ads.txt and app-ads.txt declare who is authorized to sell your inventory, and errors in these files cause buyers to skip your requests entirely. sellers.json and the SupplyChain object let buyers verify that every intermediary in your selling chain is legitimate and disclosed. Incomplete supply chain data increasingly triggers automatic bid suppression from buyers who cannot confirm the inventory's provenance.
Consent and privacy signals. You control the consent management setup that generates the signals in the user and regs objects. A correctly configured TCF integration and proper handling of Global Privacy Control signals keep you compliant and keep buyer eligibility as wide as the law allows. This is one of the few areas where compliance and revenue point in the same direction.
Page performance. The bid stream runs on your page's time budget. Slow page loads, heavy scripts, and render-blocking resources shrink the window in which bidding can complete, which mechanically reduces bid density. Every 100 milliseconds of page latency you remove gives the auction more room to fill.
What your SSP controls on your behalf
The rest of the bid stream belongs to your supply-side platform, and the difference between a good SSP and a careless one shows up in exactly these areas.
Request hygiene. Your SSP assembles the final bid request, and it decides how faithfully your inventory data maps into OpenRTB fields. A disciplined operator fills every field with accurate values: correct content categories, honest placement positions, complete device signals. A careless operator sends sparse requests, reuses stale signals, or lets fields drift out of sync with reality, and buyers respond with lower bids or no bids.
Demand aggregation. The SSP decides how many and which demand sources see each request. We combine Prebid, OpenRTB-based exchange demand, Google MCM with AdX demand, and direct deals from global and local brand agencies, so all demand competes on the same ad spaces and the highest bid wins. The number of qualified bidders per impression is the single biggest structural driver of clearing prices, because auction pressure is what turns good inventory into good CPMs.
Timeout and routing management. The SSP sets response deadlines per demand partner and can weight or deprioritize partners that chronically miss them. This is where slow-but-high-paying partners get balanced against fast-but-lower-paying ones, and it requires bid-level visibility that publishers rarely have on their own.
Quality filtering. The SSP controls what flows back down the stream: which creatines render on your pages. We apply strict filtering to keep unwanted ads, misleading creatives, and low-quality brands out of the stream, because a single bad creative costs more in user trust and return visits than it pays in one impression.
Deal configuration. Private marketplace deals and preferred deals ride on OpenRTB deal IDs that the SSP configures. Deals give buyers priority access at negotiated terms, and a well-run deal book layers guaranteed demand on top of the open auction rather than replacing it.
Common bid stream failures and their symptoms
Most bid stream problems announce themselves through symptoms that publishers see daily but often misdiagnose. Here are the frequent ones.
Low fill rate with healthy traffic usually points to floors set above what the market will pay for that segment, or to a transparency failure: an ads.txt entry that does not match reality, or a missing SupplyChain object that causes buyers to pass. Check the transparency files first, because they fail silently and the failure mode is total, buyers skip the request rather than bid low.
High no-bid rates from specific geos or devices often mean the consent signals are malformed for those segments, or the request omits fields that buyers in those markets require. European traffic with a broken TCF integration shows this pattern constantly: the traffic is fine, the demand is there, but the consent string prevents buyers from bidding with full targeting.
Stale CPMs despite good content usually mean the bid stream has a latency problem. Bids arrive after the timeout and never enter the auction, so the auction clears at whatever the surviving bidders offered. The fix is timeout tuning, partner pruning, or moving part of the demand server-side so the client page carries less of the load.
Sudden revenue drops after a site change frequently trace to a field that changed silently. A redesign that moves slots below the fold without updating the position field, a CMS migration that strips the page URL from the request, or a consent tool update that breaks the signal chain: each one shows up as a CPM decline days before anyone connects it to the change. Keep a change log and compare it against bid data when revenue moves.
How we run the bid stream at WireAds
We operate the bid stream as a discipline, not an afterthought. As an SSP and an ad network, we assemble every bid request with complete, accurate OpenRTB fields, and we push your inventory into a combined auction that includes Prebid demand, OpenRTB exchange demand, Google MCM with AdX access, and direct deals from brand agencies, so every qualified buyer competes for every impression. We work CPM-based and pay Net 30, and we work globally across web, app, and CTV/OTT in every country where Google monetization operates.
On the quality side, we hold our ad sources to premium standards and filter unwanted ads before they ever reach your pages, because the bid stream runs in both directions: requests carry your inventory out, and creatives come back in, and we police both. On the transparency side, we maintain correct ads.txt and app-ads.txt entries and complete SupplyChain objects, because we want buyers to verify your inventory's provenance and bid on it with confidence rather than suppress it.
For publishers who want to audit their own setup, the checklist is short. Verify your ads.txt and app-ads.txt files against your actual selling relationships. Confirm that consent signals generate correctly for every traffic segment. Review your slot architecture for position, size coverage, and viewability. Revisit floor prices per segment rather than site-wide. Ask your demand partners, or ask us, for bid-level data on timeouts and no-bid reasons, because the diagnosis lives in the stream itself. If you want that visibility combined with managed demand, the WireAds SSP is built exactly for this: complete OpenRTB hygiene, aggregated premium demand, and an operator that treats the bid stream as the revenue engine it is.
