Technical

How to read a publisher widget ID — a rabbit-hole tour

A technical deep dive into Outbrain SectionIDs, Taboola Site IDs, RevContent Widget IDs, and MGID Slot IDs — how to extract them from a live page, what each part of the ID encodes, and why media buyers obsess over the resulting signal.

By Eyal RosenthalMay 6, 202614 min readAI-assisted research

There is a corner of native-ad operations that is part forensic accounting, part archaeology, part stamp-collecting. It is the practice of cataloging widget IDs — the publisher-and-placement identifiers that every native-ad widget injects into its rendered code — and using them as the unit of analysis for "what's working where." Most people who run native-ad campaigns have heard of widget IDs but couldn't tell you what they actually contain, where to find them, or why they matter. This piece is the rabbit-hole tour. The networks I'll cover: Outbrain (SectionID), Taboola (Site ID), RevContent (Widget ID), MGID (Slot ID).

I will repeatedly recommend you open a real publisher page in DevTools as you read this. The widgets are public artifacts on public pages and the IDs are not secrets — they are the infrastructure that lets the network attribute each impression to a publisher and a placement. Reading them is just close-reading of the public DOM.

The mental model

Every native widget on every publisher page has a hierarchy of identifiers attached to it. The hierarchy varies by network but the broad shape is consistent:

Network identifier — which platform is serving (Outbrain, Taboola, etc.). Implicit in the script source.
Publisher identifier — which media property this is. Stable across pages on the same publisher.
Placement identifier — which specific widget on which specific kind of page. Different homepages, articles, end-of-article rails, in-content units, and sidebars get different placement IDs even on the same publisher.
Variant identifier — sometimes encodes A/B test variants, regional splits, or campaign-tier filters.
Session/request identifier — random per page-load, used for impression dedupe.

The reason buyers care: bid strategy on Outbrain and Taboola is partly placement-level. Widgets on premium publisher article-end rails monetize differently than widgets on long-tail publisher sidebars. If you can map the universe of (publisher, placement) tuples on the network and the inventory each one carries, you can bid more intelligently than the auto-optimization algorithms on either side. Most buyers don't bother. The ones who do have a meaningful edge.

Outbrain: SectionID

Outbrain's widget identifier is called SectionID. It's exposed in the rendered widget HTML as a data-ob-template attribute or in the URL of the recommendation feed JSON request, depending on the integration. Their developer documentation and the Outbrain developer site describe the integration patterns.

To extract: open a publisher page that has an Outbrain widget (CNN, BBC, USA Today). Open DevTools, network tab. Filter by "outbrain." Look at the request to widgets.outbrain.com/nanoWidget/... or odb.outbrain.com/.... The query parameters typically include:

widgetId or sid — the SectionID, a string like SF_1, AR_1, MB_1, etc.
psrc — the publisher source.
permalink — the article URL the widget is embedded on.

The interesting part: Outbrain SectionIDs are conventionally human-readable codes that publishers themselves assign. SF_1 typically means "story-feed, position 1" — an in-content recommendation on a story page. AR_1 is "article-end rail position 1." MB_1 is "mobile body 1." Different publishers use different conventions, but the patterns are consistent enough that experienced buyers can read a SectionID and infer where on the publisher page the widget sits.

What this signals to a buyer: a SectionID like AR_1 on a tier-1 publisher (CNN-tier) is almost always premium-priced inventory with high audience attention — the user has just finished reading an article and is choosing what to read next. A MB_1 on the same publisher is mid-content mobile, lower attention but higher volume. A long-tail publisher's SectionIDs are typically SF_1, SF_2, SF_3 style — sequential rather than semantically named — and rarely command premium pricing.

The bid implication: Outbrain's Conversion Bid Strategy documentation describes section-level bid modifiers. Sophisticated buyers will whitelist SectionIDs they know convert and lower bids on sections that don't, even within the same publisher.

Taboola: Site ID and Placement Name

Taboola uses a two-part identifier: siteId (the publisher) and placement (the named widget on that publisher). Both are exposed in the script tag that publishers embed and in the network requests the widget makes.

To extract: open a Taboola-served publisher page. DevTools network tab. Filter "taboola." The request to cdn.taboola.com/libtrc/... will include a path segment that's the publisher's Site ID — e.g., /yahoo-yahoo/loader.js for Yahoo's main feed, or /usatoday-usatoday/loader.js for USA Today's. The _taboola.push({ ... }) calls in the page source then include the placement name — strings like "Below Article Thumbnails", "Right Rail Thumbnails", "Mid Article", etc.

Taboola's developer documentation describes the integration and confirms the placement-naming convention is publisher-defined. The placement names are usually English-readable and self-explanatory. The implication for buyers is similar to Outbrain: certain placements (Below Article, Mid Article on premium publishers) are premium; sidebars and homepage placements vary widely.

Taboola's Site ID convention — publisher-publisher repeated, lower-case, hyphen-separated — is a quirk of how the integration historically worked. It encodes both a CMS-level publisher identifier and a network-level identifier, originally to support multi-property publishers.

For media buyers, the placement-level breakdown is exposed in Taboola's advertiser reporting under the "Sites" and "Placements" reports. The granularity is the same as the front-end widget shows; the names match.

RevContent: Widget ID

RevContent uses a numeric Widget ID — a string of digits like 12345 or 78901. It's exposed in the embed script publishers use: <script src="https://assets.revcontent.com/master/delivery.js" data-widget-id="12345"></script>. Their help docs describe the integration.

To extract: open a RevContent-served publisher page. View source. Search for revcontent.com. The numeric widget ID is right there in the data attribute or in the URL parameters of the iframe request.

What it encodes: a single Widget ID is a single (publisher, placement) tuple. Unlike Outbrain and Taboola, RevContent does not encode a separate publisher and placement layer in a structured way — each widget is its own atomic identifier.

For buyers, RevContent exposes widget-level reporting in their advertiser dashboard, and you can whitelist or blacklist by widget. The opacity is that the Widget ID alone doesn't tell you semantic information about the placement (is this a sidebar? In-content?) — you have to visit the publisher page to find out, or rely on RevContent's metadata in the dashboard.

MGID: Slot ID

MGID's identifier is called the Slot ID or Widget ID, also typically numeric. The integration script is similar to RevContent's — <div data-type="_mgwidget" data-widget-id="..."></div> patterns. MGID's developer documentation covers the embed.

The conventions are similar to RevContent: numeric slot IDs that uniquely identify (publisher, placement) but don't structurally encode either. Reporting and bid modifiers in the MGID dashboard are at the slot level.

How buyers actually use this

The naive use is: pull the Sites/Placements report from your campaign, sort by net ROI, blacklist the bottom decile, scale bids on the top decile. Almost everyone does this. It is the table-stakes optimization.

The more sophisticated uses:

Cross-network identification of the same publisher. A given publisher might have an Outbrain widget at the article end, a Taboola widget in the sidebar, and a RevContent widget on the homepage. Knowing that the same publisher's audience is reachable through multiple networks at different prices is genuinely valuable. The extraction is manual — you visit the publisher page, see which widgets are present, and note the IDs. Building this map across the top 500 publishers in your vertical is a one-week project that pays back forever.

Detecting placement type from the ID alone. Outbrain SectionIDs have the human-readable codes I described. Taboola placement names are explicit. With enough exposure, you can guess from the ID what kind of placement you're bidding on — even before clicking through to the publisher page. This lets you filter in real-time when running automated bid management.

Identifying placements that are high-volume but not high-quality. Some publishers run "junk" placements — bottom-of-article infinite-scroll widgets that auto-render dozens of times per session and inflate impression counts without real attention. The widget IDs of these placements show up in your data with very high volume and very low conversion. Blacklisting them surgically (without blacklisting the publisher's higher-quality placements) is meaningful.

Tracking when a publisher rotates widgets. Publishers occasionally renumber or restructure their widget IDs — usually when they migrate CMS, change the network they primarily serve from, or run an A/B test of placement design. A widget ID disappearing and a new one appearing on the same publisher is signal that something changed; performance can shift meaningfully.

The advanced version: arbitrating across networks at the placement level

This is where it gets interesting. Suppose you've identified a particular publisher (call them "Publisher X") whose end-of-article rail converts well for your offer. Publisher X serves an Outbrain AR_1 widget on that page. You bid up your Outbrain campaign on that SectionID and you scale.

Then you notice Publisher X also has a Taboola Below Article Thumbnails placement on the same page (some publishers run both networks concurrently). You can also bid into that placement directly through your Taboola account. You can compare CPC and conversion rate side-by-side. Sometimes one network's auction will be artificially cheap relative to its delivery for that placement — usually because of demand-side imbalance — and you can extract the difference.

This is an underused arbitrage. Most buyers run one network or the other. Buyers who run both and reconcile at the placement level have access to a more efficient frontier of inventory.

What the IDs do not tell you

A few honest limits:

Audience composition by demographic. The widget ID gives you the publisher and placement; it does not give you the demographic of the user landing on it. That's inferred from publisher-level audience data (comScore, Similarweb) plus your own conversion data.
The exact creative that's being shown. Widget IDs are stable; the creative is dynamic and rotates per impression.
Bid floors. The networks set publisher-specific bid floors, sometimes placement-specific. These are not exposed in the public widget code.
Seasonal traffic patterns. A publisher's audience changes over time. Widget-level performance from six months ago is a stale signal.

A worked example: extracting widget IDs from a public page

Open a major publisher's article page. (I won't name a specific one — the technique is generic and you can confirm against your own browser.)

Open DevTools, Network tab. Reload the page.
Filter by network keyword: outbrain, taboola, revcontent, or mgid.
Look for requests to the network's CDN or API.
In the request URL or in the response payload, find the structured identifiers:

Outbrain: widgetId=..., psrc=..., permalink=...
Taboola: path segment /[publisher-publisher]/loader.js and placement field in the _taboola.push() calls.
RevContent: data-widget-id="..." in the embed script.
MGID: data-widget-id="..." in the embed.

Cross-reference against your campaign reporting. The same identifiers appear in the network's advertiser dashboard.

This is fully public information. It is not scraping in the legal-risk sense — it is reading the rendered DOM of a page you've loaded yourself, identifying public infrastructure identifiers that the network puts there for attribution. The IAB Tech Lab's transparency standards actually encourage this level of disclosure.

Where this gets uncomfortable

Two notes on ethics and policy.

First, building a cross-publisher widget-ID database is a gray area depending on how you collect it. Manually visiting public pages is fine. Running an automated scraper against many publishers, especially against their non-public API endpoints, runs into both their terms of service and the Computer Fraud and Abuse Act. The line is "respect robots.txt, respect rate-limits, don't bypass authentication." Most operators stay well inside that line and there isn't meaningful legal risk.

Second, sharing your widget-level performance data with your network AM is a normal part of the optimization conversation. Sharing it with a competitor of the network or with an advertiser who would use it to bypass the network is a different category and likely violates your advertiser agreement.

A worked walkthrough: arbitraging an Outbrain SectionID

Let me sketch out a worked example, with synthetic numbers that reflect realistic patterns. Suppose an operator running a clean fintech offer has been bidding broadly on Outbrain for 60 days and has accumulated placement-level performance data. They pull the placements report, sort by net ROI, and look at the top-quartile performers.

Among the top performers: a SectionID AR_2 on a tier-2 financial publisher. 14,000 clicks across the period. Net ROI of 1.45 — meaning every dollar of traffic spend on this placement returned $1.45 in monetized revenue. Average CPC of $0.18. The campaign-level blended ROI is 1.12.

The naive optimization is "scale spend on this placement." But the operator knows from the SectionID convention that AR_2 is "article-end rail position 2" — typically a higher-attention placement. They check: is AR_1 (position 1, even higher attention) also accessible on the same publisher? They look at the publisher's pages, identify the AR_1 SectionID, and find that they haven't been bidding on it.

They add a section-level bid modifier to bid 30% higher on both AR_1 and AR_2 on this publisher. Within a week, AR_1 becomes their top performer at $0.22 CPC and 1.6x ROI. The 30% bid lift was more than paid for by the higher-attention placement.

A second optimization: the operator notices that the same publisher has a Taboola widget on different pages. They build a parallel Taboola campaign targeting the same publisher's Below Article placement. The Taboola CPC comes in at $0.16 (cheaper than Outbrain's AR_1) and the conversion rate is somewhat lower — but the cheaper traffic compensates and net ROI is 1.4x.

The operator has now extracted three units of incremental value from the same publisher: existing AR_2 placement scaled up, new AR_1 placement opened, and parallel Taboola placement on the same publisher's traffic. The total cost of the analysis was a couple of hours of manual placement-level inspection. None of it required tooling beyond what's available in the standard Outbrain and Taboola advertiser dashboards.

This is the kind of optimization that scales with thought, not with spend. The operators who do it consistently outperform the operators who lean exclusively on the network's auto-bid algorithms.

A short note on widget-ID-based fraud signals

Beyond optimization, the placement-level data reveals fraud patterns. A few that show up reliably:

Sudden volume spikes from a single placement. A widget that has averaged 200 impressions/day for weeks suddenly serves 4,000 impressions/day. Sometimes legitimate (publisher launched a new traffic source); often a sign of bot traffic being stuffed through that placement.

Click-through-rate inconsistency at the placement level. A widget that consistently shows 0.6% CTR suddenly shows 3.2% CTR. Conversion rate often doesn't follow. The CTR spike is bot or fraud traffic gaming the impression-to-click ratio without producing real engagement.

Geographic distribution mismatch. A US-tier-1-named placement (Daily Mail US-edition end-of-article) suddenly serving 40% of clicks to non-US geo. The placement is leaking, either because the publisher is misconfigured or because traffic is being laundered through proxies that report origin geo incorrectly.

Identical creative coverage across mismatched placements. The same handful of creatives showing up at unusually high frequency on a specific placement. This can indicate that the placement is being used as a "dumping ground" for low-CPC creatives — not fraud per se, but a sign of low audience attention.

All four are visible in the placement-level reporting that Outbrain and Taboola provide to advertisers. The MGID and RevContent equivalents are noisier but still surface the patterns.

What we are building at mediabuyer.site

For the avoidance of doubt: mediabuyer.site's spy product (when it ships) will have widget-ID-level browse and reporting on the corpus we capture, with full methodological disclosure about how the IDs are extracted and normalized across networks. The piece you just read is, in a sense, the first installment of the user manual.

How widget-IDs interact with sellers.json and ads.txt

A technical adjacency worth a brief tour. The IAB's ads.txt specification and the related sellers.json specification are the industry's published transparency standards for declaring publisher-network relationships. Every legitimate publisher has an ads.txt file at their root URL declaring which networks are authorized to sell their inventory. Every legitimate ad network has a sellers.json file declaring which publishers they represent.

The relationship between widget IDs and these files: a network's sellers.json maps from a seller_id (the network-internal identifier for a publisher) to the publisher's domain. A publisher's ads.txt maps from network domain to the same seller_id. Cross-referencing these gives you a verified network-publisher relationship.

For widget-ID analysis, the practical use is verification. If you've extracted an Outbrain SectionID from a publisher page, you can verify the publisher-network relationship by checking the publisher's ads.txt for an Outbrain entry and Outbrain's sellers.json for the publisher domain. If both match, the relationship is legitimate. If either is missing, you may be looking at unauthorized inventory — sometimes a sign of supply-side fraud.

Most operators don't do this verification, but it's a useful tool when you're investigating suspicious placement-level performance. A placement that appears in your campaign data but doesn't have a corresponding sellers.json/ads.txt verification chain is suspicious by default.

A note on widget-ID rotation as an anti-spy-tool measure

A small but interesting trend: some publishers have begun rotating their widget IDs periodically as a soft anti-spy-tool measure. Spy tools that catalog widget IDs and use them as primary keys for placement-level data find their data degrading when publishers refresh IDs. The publisher's own reporting still works (they're using the new ID internally) but third-party analysis breaks.

This is a relatively new pattern and not yet widespread. It's worth tracking because it suggests publisher-side awareness of placement-level scrutiny — and any pattern of publisher behavior that disrupts third-party analysis is a signal that the inventory in question is performing well enough that the publisher cares to protect it.

For our own data pipeline, this is a known issue and we mitigate it with publisher-domain-level (rather than widget-ID-level) primary keys plus heuristic re-association of widgets that "appear" or "disappear" on the same publisher in the same week.