How Ad Spy Tools Capture Native Ads (Supply Chain Explained)
Feed-level (API-first) native ad spy tools read the same JSON feed the widget calls where they can, store the full-quality creative, and trace the click to the landing page without clicking the ad. Here's how that works.

Picture an ad spy tool and most people imagine a robot that loads web pages and screenshots the ads it finds. That picture is incomplete, and the gap matters. A screenshot only captures what one browser session was handed at one moment, in one country. That is a small, biased slice of a feed that rotates constantly and personalizes for every visitor.
Tools that build larger native-ad datasets work a layer below the pixels where they can. They request the same feeds a publisher's widget uses to fetch its ads, and they rebuild as much of the path as they can from the slot on the page to the advertiser's landing page. This piece walks that path end to end, using the architecture OpenAdLibrary runs: API-first capture from the networks' feeds, with a browser crawler as fallback.
If you want to know what is under the hood of a native ad spy tool before you trust its data, this is for you.
How do ad spy tools capture native ads?#
Feed-level (API-first) ad spy tools capture native ads by requesting the same recommendation feed that fills a publisher's widget, then reading the branding name, headline, image and click URL straight from the JSON response. They store the creative at full quality, resolve the click URL out-of-band to reach the landing page, and parse the redirect chain to label the intermediaries they recognize. Tools that rely on browser crawling or extensions work differently, and practices vary by vendor; OpenAdLibrary's tracing does not click live ads.
That is the whole game in one paragraph. The rest unpacks each step, why the obvious approaches fail, and what separates a thin dataset from a deep one. For the conceptual primer first, start with what a native ad spy tool actually is and how it differs from social-ad libraries.
The native ad supply chain, hop by hop#
You can't capture something you don't understand. A native ad is not a static image dropped into a page. It is the visible tip of a supply chain with several moving parts. Here is the path a single Taboola or Outbrain unit travels:
- The publisher page loads a native ad widget. That is the "Around the Web" or "You May Like" box. At first paint it is mostly an empty container.
- The widget script calls a recommendation endpoint. This is a JSON API on the demand platform's domain. It passes the publisher ID, the slot, the user's approximate geo, and device signals.
- The demand platform runs an auction. In programmatic native, advertisers bid for that impression in milliseconds, and the winners come back in the response.
- The response returns the ads as structured data. Each item carries a title, a thumbnail image URL, a branding or advertiser name, and a click-tracking URL.
- The click URL is a redirect, not a destination. Click it and you bounce through one or more tracker and exchange domains before you reach the advertiser's real page, which is frequently a pre-lander or advertorial rather than a product page.
For networks that serve ads through a feed, the ad data you want already arrives as structured JSON before a single pixel is painted. Screenshotting the rendered widget reconstructs something you could have read directly.
Every step is a capture opportunity and a classification problem at the same time. Steps 2 and 4 hand you the creative and the advertiser. Step 5 hands you the supply chain and the landing page. Tools differ wildly in how many of these they actually use.
API-only harvesting vs browser screenshotting#
There are two fundamentally different ways to harvest native ads, and the choice cascades into cost, coverage, and data quality.
| Approach | How it works | Coverage | Cost to run | Creative quality |
|---|---|---|---|---|
| Browser rendering | Headless browser loads pages and renders widgets; it may screenshot the pixels or read the feed responses the page receives | Limited to what each rendered session is served | Higher: a full browser per page | Screenshot crops, unless the original asset URL is also captured |
| API-first harvest | Requests the recommendation feed directly where a network exposes one and reads the JSON | More rotations, geos and device profiles per unit of cost | Lower per request: no browser needed | Original asset at full resolution |
The browser route is the obvious one. Used alone, it is expensive and shallow: spinning up real Chromium for every page is heavy and slow, and a render only shows the few ads served to that one session. You are sampling a slot that personalizes and rotates constantly. Browsers still have a place: OpenAdLibrary keeps a browser crawler as a fallback for sources and placements the feed route does not cover.
The feed route is what OpenAdLibrary's native harvester runs on; the platform keeps the browser crawler as a fallback. Instead of rendering pages, the harvester requests the same recommendation feeds the widgets call, across many geographies and rotating device and identity personas, and reads the ads directly. Skipping the browser makes each request much cheaper than driving one, which is why it can run continuously and catch more of the rotation; this article has no published cost benchmark for the difference. No browser also means no clicking live ads. The data comes off the feed, not off a rendered impression.
Here is a Taboola finance ad captured from the feed in June 2026, not from a render. It is a historical capture, and its claims were not verified:

This is the difference between a tool that shows you a handful of a competitor's ads and one that shows a much wider sample of them; no tool sees every impression. For affiliates and media buyers, the spread is the point. See how affiliate marketers use native spy tools to find rotations worth studying.
Capturing the creative at full quality#
Once the feed is parsed, the creative image URL points to the advertiser's original asset on a CDN. A good harvester fetches that asset directly and stores it at native resolution instead of keeping a downscaled screenshot crop.
Why it matters in practice:
Reverse image search and dedup work best on the original asset. Cropped screenshots can defeat perceptual hashing and bloat your dataset with near-duplicates. Creative analysis needs the real pixels: the hook, the face, the text overlay, the color treatment. You cannot study a creative's details properly from a cropped thumbnail. Cross-network asset reuse detection depends on the source file. Matching the same image running on Taboola, MGID and Revcontent at once is most reliable when you hold the original.
Storing the original also means the creative survives after the campaign ends and the CDN URL 404s, which is much of why an ad library has value at all. OpenAdLibrary also stores landing-page captures tied to the creatives where the redirect path could be traced. The campaign ends; the record remains.
Archived originals are especially useful in health, where similar creatives can be reworked and re-run many times. Here is one observed on Taboola over 26 days in June 2026:

Following the click to the landing page (without clicking)#
This step is not part of every tool, and it is where much of the useful intelligence lives. The click URL in the feed is a tracking redirect. The destination behind it, the landing page or pre-lander and the advertiser whose domain it sits on, answers the central question: who is actually running this, and where are they sending traffic?
The naive approach is to fire the click in a browser. That can register as a billable click on a live impression and burn budget you do not own. Not acceptable. The approach OpenAdLibrary uses is to resolve the redirect chain out-of-band: follow the hops server-side from an exit in the relevant geo to retrieve the final URL and capture the landing page itself, without clicking the live ad.
Done well, this surfaces three things at once:
- The real advertiser behind a generic-looking branding name in the feed.
- The pre-lander or advertorial, the bridge page native buyers rely on, which never appears in the widget.
- The geo-gated destination. The same ad often routes to different landers by country, and only a multi-geo resolver catches that. The example below is geo-targeted at Australia, which you would miss entirely capturing from a US exit:

OpenAdLibrary traces native ads' redirect paths to their landing pages this way, without clicking the ads, and stores the destination next to the creative where tracing succeeds, so the creative is tied to the advertiser and the funnel it feeds rather than left as an orphaned image. Redirect trails and captured landing pages are visible on the free plan; funnel tracing and real-advertiser resolution are on the Founders plan ($29.99/month).
Classifying the ad-tech supply chain#
Capturing the hops is one thing. Making them legible is another. Between the widget and the lander, a single ad can pass through a demand platform, an exchange, several tracker domains, and a redirect service. Classification is the work of parsing that chain and labelling each node.
A capable system keeps a dynamic registry of known networks, trackers, and redirect domains, then matches each hop against it to answer:
- Which demand platform served the ad (Taboola, Outbrain, MGID, Revcontent, MediaGo, Yahoo, Microsoft Audience Network)?
- Which trackers and exchanges sit in the redirect chain?
- Who is the end advertiser, normalized across the many branding aliases the same buyer hides behind?
Hard-coding tracker lists is a losing game. The domains rotate constantly, so it turns into whack-a-mole. A registry that updates as new patterns appear is the only approach that holds up. Get the supply chain right and you can answer questions a flat ad list never can: which advertisers concentrate on which networks, which trackers signal a particular affiliate stack, which redirect services correlate with the most aggressive offers.
Classification is what makes per-network comparisons possible, but a comparison is only as good as the sample behind it. Counts of captured creatives by vertical and network describe what a collection sampled; they do not show which verticals dominate a network's demand, and they need a dated, reproducible query before they are published.
If the terminology is new, the glossary entry on the ad supply chain lays out the roles, and programmatic native advertising explains the auction that decides which ads you capture in the first place.
Coverage, geo, and personas: why one capture isn't enough#
A native slot is personalized. The ads it serves depend on geo, device, time of day, and inferred interest. So a single capture, from one IP, one device profile, one moment, is a biased sample of a much larger rotation.
Serious harvesting treats this as a sampling problem:
- Geo rotation. The same widget on the same publisher serves different advertisers in the US, UK, AU, and DE. One geo gives you one slice.
- Device and identity rotation. Desktop, Android, and iOS sessions, plus rotated personas, surface different demand and different creative formats.
- Cadence. Rotations turn over throughout the day, so capture has to be continuous, not a one-off crawl.
This is also why longevity and spread are the most useful public research signals available without inside data, though neither measures success. You cannot see a competitor's spend, but you can see how long a creative was observed and how widely it appeared across publishers, geos and networks. When this article was published (July 2026), the longest continuously observed creatives in the collection had reached 28 days of unbroken observation, the length of the observation window at the time. SmartAsset's "Ask a Pro: How Can I Avoid Paying Taxes on IRA Withdrawals?" on Outbrain was observed throughout those 28 days:

Worth being precise here: 28 days was the span of the observation window, not a claim that the creative ran for exactly 28 days and no more. Industry lore about 90-day winners is not something the collection measured. What we can stand behind is the observed run: an ad seen across dozens of placements for weeks shows that it kept being served in sampled placements. It does not show spend, conversions or profit; brand budgets, slow optimisation and capture gaps can produce the same pattern.
What this means for the data you actually get#
Pull the threads together and the harvesting method directly decides what you can do with the output.
| Capability | Needs feed-level capture? | Needs click-trace? | Needs supply-chain classification? |
|---|---|---|---|
| See that a creative ran at all | No (a screenshot can show this; feed capture shows more of the rotation) | No | No |
| Identify the real advertiser | Partly | Yes | Yes |
| Find the landing page or pre-lander | No | Yes | No |
| Detect cross-network asset reuse | Yes | No | Yes |
| Sort ads by observed longevity and spread (research signals, not proof of performance) | Yes | No | No |
A tool that only screenshots gives you the first row. A tool that harvests feeds, traces redirect paths and classifies the supply chain can give you all of them. That is the difference between a curiosity and a research instrument. On top of capture, OpenAdLibrary offers tools that use it: Creative Studio (a manual editor on the free plan; AI remakes and publishing on Founders), Copy DNA for recurring headlines, CTAs and themes, and the REST API and hosted MCP server. Copy DNA, Creative Studio AI, the API and MCP are on the Founders plan ($29.99/month).
Transparency rules and what they do not settle#
For context on transparency rules: Article 39 of the EU's Digital Services Act requires providers of very large online platforms and very large online search engines that present ads (designated services such as Facebook, Instagram, TikTok, YouTube and Google Search) to keep a public, searchable ad repository, with API access, showing each ad's content, the person on whose behalf it was presented, who paid for it if different, the period it ran and targeting information, kept until one year after the ad last ran. Taboola, Outbrain, Teads, MGID and Revcontent are not on the Commission's list of designated services, so that duty does not cover their recommendation widgets. Article 39 obliges those platforms to publish their own repositories; it does not authorize third parties to collect ads from other services, and it does not settle questions about a site's terms, copyright in creatives, database rights or personal data. Whether a particular capture practice is lawful depends on the jurisdiction and the facts, so get qualified legal advice for your use.
The bottom line#
Stripped to essentials, here is what to look for in a native ad spy tool. It reads the recommendation feed where it can, with a browser as a fallback, instead of relying on screenshots. It stores the original creative instead of a crop. It resolves the click URL out-of-band to reach the landing page instead of firing a click on a live ad. And it classifies the hops it can recognize in the supply chain instead of leaving you a flat list. Coverage comes from rotating geos, devices and personas continuously. Longevity and spread are useful research filters, not proof that an ad performs.
When you compare vendors, those are the questions to ask. Our comparison of the best native ad spy tools discusses vendors against these questions; OpenAdLibrary publishes it and sells one of the tools, so weigh that interest. If budget is the constraint, there is also a guide to running native ad research for free.
OpenAdLibrary built its native harvester on the principles above: API-first capture with a browser crawler as fallback, full-quality creatives, redirect-traced landing pages and an updating supply-chain registry. Start free: the free plan shows the 20 newest Meta, TikTok and native ads with no credit card; search, filters, saved research and the API are on the Founders plan at $29.99/month.







