A bid request costs money before it earns any. Each request crosses infrastructure, triggers data lookups and consumes a slot in a buyer's query budget, all before a single bid comes back. Traffic shaping is the SSP practice of deciding, request by request, which impressions to send downstream and which to hold back. On large portfolios, supply-side platforms typically drop 20 to 60 percent of requests before any demand partner sees them. Executed well, that removal raises publisher revenue: the impressions that remain enter fuller auctions, and buyers spend their budgets on traffic they can actually use.
The mechanics of traffic shaping
A shaping rule is a conditional statement an SSP applies before distributing a bid request. The rule inspects fields that already exist in the request: country, device type, browser, ad size, site or app ID, and the historical performance of that seller and slot. If the request fails the condition, the SSP drops it entirely or removes one buyer from the distribution list while keeping the request live for everyone else. Shaping therefore acts on the supply side of the auction, before bids exist.
Shaping is not the same as its two neighbors. Throttling caps the raw number of requests per second per buyer, a quota that ignores what the traffic contains. Bid filtering works after bids return: it blocks specific advertisers, categories or creatives from winning. Publishers control filtering directly through settings such as our bid filtering configuration, while shaping usually lives inside the SSP's routing layer. Both affect revenue, but they answer different questions. Filtering asks which ads may not win. Shaping asks which requests should not compete at all.
Shaping also carries a trust problem worth naming. Some platforms have used it for self-preferential arbitrage: predicting where their own margin sits, then dropping the requests where they earn less, regardless of what the publisher would earn. That behavior stays invisible to the publisher unless the SSP discloses it. The practice itself is sound; the disclosure is what separates a partner from a black box.
Where shaping sits in the bid flow
A standard header bidding flow runs in a fixed order. The user loads a page or opens an app. The wrapper or ad server assembles the impression data and calls each SSP endpoint. The SSP then builds an OpenRTB bid request, a structured payload of objects covering the impression, the site or app, the user, the device and the regulatory context. The IAB Tech Lab OpenRTB standard defines those objects, which is exactly why shaping rules can rely on them: every conforming request exposes the same fields, so one rule engine can evaluate any request in a uniform way. Our OpenRTB guide walks through those objects field by field if you want to read the raw payloads.
The shaping layer sits between request construction and distribution. After the SSP assembles the payload, the shaping engine scores it against the active rules, then forwards the survivors to exchanges, DSPs and direct deals. A request can fail for one buyer and pass for the rest, which is the common case: a buyer that only purchases Turkish desktop traffic should not receive your Brazilian mobile impressions, so the SSP strips that buyer from the destination list.
SSPs run shaping on two clocks. Real-time evaluation scores each request as it arrives, which costs compute but stays accurate. Precomputed rules rely on aggregated history, which is cheap but drifts when the traffic mix shifts. Mature platforms use a hybrid: hard rules for geography, device and format in real time, and performance rules for predicted CPM and viewability from tables refreshed daily or hourly.
Why fewer requests can earn more
The economics rest on a hard constraint: buyers do not accept unlimited traffic. Demand partners negotiate query per second budgets with each supply source, and every low-value request consumes budget that a high-value request could use. When an SSP ships unrestricted, unshaped volume, buyers defend themselves: they cap the SSP, raise internal rejection thresholds, or bid conservatively across the entire feed. Shaping keeps the pipe clean, and the publisher collects the difference through buyers who bid more aggressively on the traffic that arrives.
Requests also cost real money to move. Each one consumes compute at the SSP, egress between data centers, enrichment lookups against user data, and log processing after the fact. An SSP that forwards everything must price that overhead somewhere, and it typically lands in the revenue share or the effective CPM the publisher sees. Shaping removes cost per request, and disciplined platforms pass part of that efficiency back as better yield.
Latency compounds the effect. Header bidding auctions run inside a fixed timeout window, commonly 400 to 1000 milliseconds. Buyers that receive a flood of marginal traffic respond more slowly because their own bidding infrastructure saturates, and slow responses turn into timed-out bids. A shaped stream is smaller and faster, so a higher share of auctions closes with at least one real bid. Bid density per auction, not raw request volume, is what drives publisher CPM.
Run the arithmetic on a concrete case. A publisher serving 50 million monthly impressions across three geographies might send 18 million of them from a market where only two buyers actively purchase that format, at clearing prices near the floor. Shaping that market down to the buyers who actually bid, while leaving the other 32 million untouched, cuts request volume without cutting auctions that close. The buyer-side budget that previously soaked up marginal requests now concentrates on the impressions with real competition, and blended CPM rises even though total requests fall.
The honest caveat: shaping can hurt you when it serves the wrong master. If an SSP drops your requests because its own margin looks thin there, or to route spend toward inventory it owns, you lose auctions you would have won. Opaque shaping is the single biggest reason publishers distrust the practice. Ask for drop reports per market and per buyer, and treat silence as a signal.
The signals shaping rules evaluate
Shaping engines read a small set of signals, most of them already present in the bid request.
Geography and market come first. Buyers purchase inventory by country and often by state or region, so requests from markets with no active demand for a given format get shaped out early. Device and environment follow: a buyer with VAST-based video requirements wants nothing to do with a banner slot, and a buyer focused on mobile in-app traffic will not bid on a desktop web request no matter how many times it arrives.
Predicted viewability moves CPMs materially. SSPs model the probability that an impression will measure as viewable, using historical measurement for the same slot, ad position and page, then shape out impressions with a low predicted score. Buyers operating on viewable CPM deals want that filtering, and publishers with strong viewability earn the difference.
Historical performance closes the loop. Shaping tables track the realized CPM for each combination of ad unit, buyer and market. When a request's closest historical analog has never cleared the price floor, the shaping layer stops sending that pattern to that buyer, which saves budget for combinations that actually transact.
User data availability decides reach. Requests carrying valid consent strings and an identifier support interest-based bids; requests without them support only contextual bids, which typically clear lower. Some shaping rules route the two populations to different buyers rather than dropping either one. Regulatory signals such as Global Privacy Control can trigger the same split.
Floors themselves act as a shaping signal: an impression far below floor, with no bid history at that slot, gets dropped rather than dead-hauled through the chain.
Publisher controls: floors, rules and blocking
You do not have to leave shaping entirely to the SSP. Three layers of control sit on your side.
Price floors are the strongest lever. OpenRTB exposes floor prices in the bid request, and Prebid supports floors configuration across the wrapper. When a floor rises, the request itself tells every buyer the minimum acceptable price, and buyers respond by bidding less often but higher. Floors also give the shaping engine a clean threshold: patterns that never clear floor get shaped out, which concentrates demand where it can pay.
Shaping exists on the publisher side too, inside the wrapper. The Prebid shaping rules module lets you configure a rules file, in the same syntax as price floors, that decides which bid requests the wrapper sends to each bidder at all. You can gate a bidder by geography, device or ad unit, run that rules file alongside your floors file, and keep the logic where you can read it. For publishers who want shaping they can audit, this module is the cleanest starting point.
Structural controls complete the picture. ads.txt and app-ads.txt declare who may resell your inventory. sellers.json and the SupplyChain object expose every hop between you and the final buyer, so you can see which requests carry inflated resell chains and shape those paths out of your own setup. Ad unit and format blocking inside Google Ad Manager handles what may serve; your wrapper rules and floors handle what may ask.
How WireAds shapes traffic
We shape, and we publish the reasoning. Our supply stack combines Prebid, OpenRTB, Google MCM and Google AdX demand with direct deals from global and local brand agencies, all merged into one auction so the highest bid wins each ad space. Our sources hold the highest quality standards for brands, and we apply strict filtering of unwanted ads before anything reaches your inventory.
Our shaping follows three principles. We drop requests only when no demand source in the combined auction can monetize them in that market, because carrying dead weight helps nobody. We never shape to favor our own margin: the merged auction treats direct deals and open market demand identically, and the top bid wins regardless of who placed it. And we disclose drops: if you run inventory through WireAds SSP, you can ask what percentage of your requests we hold back, in which markets, and for which reason codes, and you will get numbers rather than a shrug.
We work CPM-based and pay Net 30. We operate globally, in every country with Google monetization available, across web, app and CTV/OTT, and shaping applies to all of it. A CTV request in a market with no connected TV buyers gets the same honest treatment as a display request: we tell you the market is thin rather than quietly shipping dead traffic through the chain.
How to audit shaping on your own inventory
Four questions expose how any SSP shapes your traffic. What percentage of my bid requests do you drop, per buyer and per market? Which rules caused the drops, and can I see them? Do drops differ between my direct deals and open market demand? Do my price floors influence your shaping, and in which direction?
Then measure the funnel yourself: raw impressions generated, bid requests the SSP actually sent, bids returned, and filled impressions. Each ratio tells you where volume disappears. If you send an SSP a million impressions and the sent-request figure comes back far lower with no explanation, you have found an undisclosed shaping layer.
Finally, test the direction of the effect. Turn off your weakest ad units or exclude one thin market for two weeks and watch effective CPM. If revenue holds or rises on less traffic, the shaping logic was doing its job, and you can push harder on fewer, better requests.
