Display banners are the cheapest impressions most publishers sell, and the reason sits in the supply curve: 300x250, 728x90 and 300x600 units exist on every site, so every demand source prices them against near-infinite alternatives. Native units and outstream video pull from different budgets entirely: sponsored content spend, brand video spend, and in-feed programmatic demand that structurally never bids on a standard banner. A publisher who adds both formats does not cannibalize banner revenue, the move opens two additional budget lines against the same sessions. This article covers the economics of each format, the auction mechanics underneath them, and a rollout order that keeps every step accountable.
The economics of running more than display
Advertisers do not buy pages, they buy formats against objectives. Performance buyers bid where clicks come cheap, so they cluster around display and native placements. Brand buyers bid where attention runs measurable, so they cluster around video and high-impact units. A publisher who monetizes with banners only captures the performance cluster and nothing else, regardless of traffic quality.
The price ordering across formats stays stable even though exact numbers move by geo and vertical. Video impressions typically clear the highest CPMs because they carry motion, sound and a large canvas. Native typically clears at or above display on editorial traffic because the unit sits inside the content flow and inherits high viewability. Display anchors the floor. When a stack runs all three, the session collects bids from all three budget pools.
Diversification also changes the risk profile of your revenue. Banner CPMs swing with open market cycles. Native demand includes content marketers with quarterly budgets, and video demand includes brand campaigns with fixed flights, so a mixed stack smooths the dips that a banner-only publisher feels at full force. Direct deals compound this effect: agencies buy packages across formats, and a publisher who cannot serve native or video simply never sees those briefs.
The cost side of diversification is engineering time and layout risk. Each format needs a container, a request path into the auction, and styling that fits the template. That cost is front-loaded: once the integration exists, additional formats ride the same header bidding path. This is why the rollout order later in this article starts with the cheapest integration and defers the player work.
Native content ads: how they clear price
Native content ads render as editorial-adjacent units: a headline, a thumbnail, a sponsor label and a destination URL, styled to match the surrounding page. The buyer supplies assets, your CSS lays them out, and the unit inherits the site's typography instead of fighting it. Users engage with native because it reads like content, and buyers pay for that engagement.
The transaction layer underneath is the OpenRTB Native Ads API specification. Native 1.2 adds third-party serving, DCO support, privacy flags and event tracking, so a native bid can carry dynamic creative optimization and measurement data the same way a banner bid does. A publisher who integrates through an SSP that speaks OpenRTB reaches that entire demand pool without custom plumbing. Our native content ads product covers the common placements: in-article units between paragraphs, recommendation widgets under the article body, and sticky units on long-scroll templates.
Two mechanical reasons keep native CPMs competitive. First, the unit occupies a content position, so viewability runs high without extra work, and buyers price viewable impressions up. Second, effective click-through rates on well-built native run above banner baselines, and the auction prices that behavior in. Both effects depend on honest design: matched fonts, matched aspect ratios and a clear sponsor label. A native unit that looks like a banner performs like one and prices like one.
Native also carries a filtering advantage that banner-heavy stacks miss. Because the creative renders inside your page rather than inside a fixed-size frame, unwanted categories need policy enforcement at the bid level. We filter aggressively at the request layer, so IAB category blocks, competitor exclusions and sensitive-topic bans apply to native bids the same way they apply to display.
Outstream video: the mechanics that matter
Outstream video places a video ad in its own player outside any video content: between article paragraphs, in a corner sticky player, or as a standalone unit in a feed. The ad enters muted, pauses when it leaves the viewport, and expands to full controls on interaction. Buyers value it because it delivers video reach without the publisher hosting editorial video, which makes it the cheapest way for a text-focused site to enter video demand.
The format's definitions have shifted under it. The IAB standard for classifying video advertising exists because the video marketplace outgrew in-stream and out-stream definitions, and buyers now bid across a wider set of placements than the old taxonomy described. In practice, the bid request declares placement type and playback mode, and demand partners price the impression against that declared context. Our outstream video implementation handles the player, the VAST response parsing and the viewability reporting, so the integration on your side stays limited to placing the container.
Two settings drive outstream revenue more than anything else: autoplay policy and player position. Muted autoplay keeps fill high because buyers treat it as standard outstream behavior, while a player inside the first two viewport heights of an article collects measurable completed views. Sound-on on entry suppresses bids, so we do not recommend it. A sticky player that collapses after one completed view preserves the reading experience while still counting the impression.
Outstream earns its place through session economics, not raw CPM alone. A completed muted view registers as attention, brand buyers pay for attention, and the article stays readable. The format fails when publishers stack it against three banners on the same page, which brings us to density rules later in this article.
In-feed native: the unit between formats
In-feed native ads sit inside content feeds: a sponsored card between article cards, a listing between product listings, a unit between recommended videos. The feed context does the signaling work that a banner border used to do, it tells the user the unit belongs to the surrounding list, and engagement follows. On templates with multiple feed impressions per session, each scroll exposes a new slot to the auction, so a feed with eight cards can carry two or three sponsored slots at sensible intervals.
We sell in-feed native as a distinct product from in-article native because the integration differs. In-article native needs a container between paragraphs, in-feed native needs a slot inside the template loop, with the unit inheriting the card dimensions around it. The request path and the auction stay identical, which is the point: one integration pattern, two placement types.
Feed placement carries the highest CPM potential of the native family on discovery-heavy pages, because the user arrives with scrolling intent and the sponsored card rides that intent. It also carries the highest design risk: an off-model card breaks the feed's rhythm, and users notice immediately. Aspect ratio matching matters more here than anywhere else in the stack, so treat the card template as part of the integration spec, not an afterthought.
One auction, one payment line
This part determines whether diversification pays or just adds work. Each format can live in its own stack: a banner wrapper from one vendor, a native network from another, a video player from a third, each with its own payment threshold and its own reporting login. That setup functions, and it leaks money through minimum payouts, reconciliation time, and competition that never crosses stacks.
We run all of it in one auction. We combine Prebid, OpenRTB, Google MCM and Google AdX demand, plus direct deals from global and local brand agencies, into a single SSP auction, so a native bid, a video bid and a banner bid compete for the same ad spaces and the highest bid wins. Premium sources with strict filtering apply across every format, so a blocked category stays blocked in native and video, not just in display. You get one reporting line and one payment, Net 30, with no per-format minimums to chase.
The verification plumbing stays consistent as formats multiply: ads.txt and app-ads.txt entries, sellers.json, and the SupplyChain object on every bid, so buyers can trace your inventory's path through the auction. A buyer who cannot verify supply discounts the bid, and a multi-format stack multiplies the surfaces that need verifying. One SSP with one sellers.json removes that variable.
If video carries most of your incremental revenue, the video advertising at WireAds page covers player requirements, VAST versions and app or CTV extensions. The same demand sources bid on web, app and CTV/OTT inventory, in every country where Google monetization works, so a format that proves out on web extends without a new vendor relationship.
A rollout order you can copy
Format diversification fails most often from bad sequencing. Publishers launch everything at once, watch total revenue move, and cannot attribute the movement to any format. The order below starts with the lowest integration risk and defers the player work, and each step gets its own baseline.
- Audit before you add. Count ad slots per template, measure viewability per slot, and record session RPM as the master metric. This baseline makes every later format provable rather than anecdotal.
- Ship in-article native first. It needs one container in the article template and zero player code, it typically clears at or above display CPMs on editorial traffic, and it trains your reporting on a format that behaves like display. Two to four weeks of live data settles whether the placement earns its slot.
- Add in-feed native on feed-heavy templates. The integration touches the template loop, so it goes second, after the team knows the native request path from step two. Feed pages with multiple impressions per session show the effect fastest.
- Add outstream video third. The player introduces VAST parsing, autoplay policy, sound handling and viewability measurement, so it deserves its own launch window. Start with one placement per article page, inside the first two viewport heights, muted autoplay on.
- Extend to app and CTV/OTT last. Once the web stack proves out, the same demand sources bid on app and connected TV inventory through the same auction. CTV carries the highest video CPMs of the three, and it also carries the longest integration, so it closes the sequence.
- Rebalance, do not stack. Every format launch should pair with a banner audit: if a template gains a native unit, retire the weakest banner on that template. Ad count per page drives exit rate, and exit rate drives session RPM, which is the metric that pays you.
The sequence assumes one auction underneath it. With per-format vendors, steps two through five each mean a new contract, a new payment threshold and a new reconciliation cycle, and the rollout stalls at step three. With a single SSP, each step reuses the integration from the previous one, and the payment line never changes.
Measuring the stack honestly
Measure revenue per thousand sessions, not CPM per slot. Format CPMs differ by design: video clears the most, display the least, so a dashboard that reports only CPM pushes you toward video everywhere, and video everywhere collapses session depth and search traffic. Session RPM captures the actual trade: a page with one banner, one native card and one outstream unit versus a page with four banners.
Per template, track four numbers: session RPM, viewability per format, fill rate per format, and layout shift per format. The last one belongs in the monetization dashboard because late-loading creative shifts layout, layout shift hurts page experience, and page experience affects search traffic within weeks. Native and video integrations that reserve space in the template avoid the penalty, and that reservation belongs in the integration spec from day one.
Compare formats on contribution, not CPM alone. A native unit that lifts session RPM by holding users on the page earns more than its line item shows, and an outstream player that truncates sessions earns less than its CPM suggests. Attribution here stays simple: run each format's launch against the step-one baseline and read the delta.
Failure points and fixes
Three failure modes account for most of the rescue requests we see.
Density creep. Adding formats without removing banners raises ad count per page, users leave earlier, and session RPM falls even while per-slot CPMs rise. The fix stays mechanical: every new format replaces the weakest banner on that template, and total ad weight per page holds constant.
Design mismatch. A native unit that ignores the page's typography performs like a banner and prices like one. Match fonts, match image aspect ratios, keep the sponsor label visible, and test the unit on both mobile and desktop templates before full rollout.
Privacy signal loss. TCF consent strings and Global Privacy Control flags travel in the bid request, and a native or video integration that drops them loses bid density in regulated traffic, not just compliance standing. We pass the full privacy object on every format's request, but if you run hybrid stacks, verify that each vendor does the same.
One more failure mode deserves a note: launching two formats in the same week. When revenue moves, you cannot tell which format moved it, and you cannot defend either placement in a budget review. One format per launch window keeps the data clean, and clean data keeps the stack funded.
Banner-only monetization leaves the two highest paying budgets out of the auction. Native content ads, in-feed units and outstream video put them back, and a staged rollout keeps each format accountable to a baseline. We run all three against the same demand stack, on CPM terms, paid Net 30, across web, app and CTV/OTT wherever Google monetization works. Audit first, ship native first, let the data set the pace.
