How Native Ad Networks Work
A native ad network takes an advertiser’s headline, image and link, matches it to a placement, and lets the host render it in its own style. This page follows that path step by step.
The basic idea
Every native network solves the same problem. Advertisers want attention in a form people do not skip, and publishers want ad revenue that does not clash with their design. A native unit tries to satisfy both: it carries a paid message but takes the shape of the content around it. The network is the layer that makes this repeatable at scale.
Two kinds of network
Native networks fall into two groups, and mixing them up causes most confusion.
- SDK-based networks serve apps. AdMob, Yandex Ads, AppLovin MAX, LevelPlay and Appodeal belong here. They hand an app a set of assets, and the app draws the ad itself.
- Advertiser-side networks sell placements on publisher sites. Taboola, Outbrain, MGID and Revcontent belong here. Advertisers brief them, and the network delivers sponsored content through widgets on publisher sites.
Some products serve both worlds, but most public pages describe one side clearly. The directory keeps them apart.
The path of a native ad
A native ad passes through five stages, whichever kind of network carries it.
- BriefThe advertiser supplies a headline, an image, a brand name and a landing page.
- ReviewThe network checks the creative against its specifications and policies.
- MatchA request from a page or an app triggers a decision about which ad fits.
- RenderThe host styles the assets so that they fit its layout.
- ReportClicks, views and conversions flow back to both sides.
What an advertiser supplies
Specifications show how much the network controls. Outbrain’s public ad specifications, for example, call for an image of 1200 by 800 pixels, with a maximum file size of 2.5 megabytes. Titles may run up to 100 characters, though 60 are recommended, and the brand name is capped at 60. These limits are why a native creative is closer to a small editorial package than to a banner. Read the network’s own ad specifications before you brief a designer.
How the host draws the ad
Widget networks render the unit for the publisher, who chooses a placement and a style within the network’s options. SDK networks work differently. Google’s AdMob documentation says that when a native ad loads, the app receives an object with the assets and is responsible for displaying them. AppLovin’s documentation likewise leaves the layout to the developer. The result is more design freedom and more engineering work.
Programmatic native
When native units are bought in real-time auctions, both sides need a shared description of the ad. The IAB Tech Lab’s OpenRTB Native specification provides it. Version 1.2 is the latest, and the page says it defines the native object that carries the ad unit and layout. It also notes that the object can describe ads in non-auction settings, such as in-app SDKs.
Labels and trust
Because a native ad looks like content, labeling carries more weight than it does for display. The FTC’s Native Advertising: A Guide for Businesses says consumers are likely to understand terms such as “Ad” and “Paid Advertisement”, advises against “Promoted”, and recommends placing the disclosure in front of or above the headline. Publishers and networks are expected to make labels visible on every device.
A simple example
Imagine a company that wants readers to download a home-energy guide. It writes a headline, picks a calm photo within the network’s size limit, adds the brand name and links to the guide’s landing page. The network checks the creative, then a reader finishing an article on a publisher site sees it as one of several suggested links, labeled as an ad. A click sends the reader to the landing page, and the click is counted and reported to both the company and the publisher. Nothing in this chain depends on a banner, which is why the unit tends to feel closer to a recommendation than to an interruption.
Who sets the rules
Several parties shape what a native ad may look like. The advertiser controls the message. The network controls the specifications and reviews creatives against its policies. The publisher or app controls where the unit appears and how it is styled. Public standards, such as the FTC’s guidance on disclosure, sit on top of all three. When a native campaign goes wrong, the cause is usually a mismatch between these layers, for example a creative that satisfies the network but breaks the publisher’s layout or the labeling guidance.
Web and app differences
On websites, the network usually owns the rendering through a widget, and the publisher picks a placement and a style from a set of options. In apps, the developer owns the rendering. This changes where problems appear. On the web, problems show up as page speed and layout shifts. In apps, they show up as memory use, stale ads and inconsistent assets across mediated sources. Plan your testing for the side you are on.
What can go wrong
- A label that is too small, too pale or placed after the headline.
- A creative that is rejected for breaching specifications, which delays a launch.
- A layout that breaks on narrow screens, because the host styled the assets poorly.
- Ads kept in memory too long in an app, so that stale units expire before they are shown.
Next, see the types of native ads or jump to the overview.