How generative engines actually fetch, cite, and mention sources — and what that means for the way you build AI search visibility.

Most of what gets said about "ranking in ChatGPT" is repeated on faith. Write good content. Do listicles. Get on Reddit. It's not wrong, but almost none of it explains why — because the studies behind it only ever see the finished answer.

There are two ways to study this. The first is the one most visibility tools (including us) run at scale: fire thousands of prompts, record which brands surface, and roll it up into share-of-voice. Large sample, but a black box — you infer the machinery from the output. The second is the opposite: read the raw network traffic ChatGPT sends your browser and lift out the engine's own internal labels. Small sample, but you see the machine's actual plumbing.

A recent teardown by Suganthan Mohanadasan took that second route, reading a couple of days of ChatGPT's own JSON to document how it labels and pulls sources. His structural findings line up almost perfectly with what we see on the aggregate side at Indexly — so we wanted to walk through the mechanics and, more importantly, what each one means for anyone trying to get cited.

A note on confidence before we start, because it matters: the structure below (the fields, the buckets, the pipelines) is solid — you only need to see a field once on the wire to know it's real. The percentages come from a small, tech-skewed batch of queries. Treat those as direction, not measurement.

Every source carries a hidden label

On the wire, every web result ChatGPT pulls carries a field called result_source. You never see it in the answer, and it takes one of four values:

• labrador — an allowlist of established publishers: Reuters, The Guardian, WSJ, FT, Wikipedia, even arXiv. Snippets run to full-article length. This looks like a licensed tier, and several of those publishers have signed content deals with OpenAI.
• bright — Bright Data, a commercial web scraper. Dominant for shopping, finance, weather, and local.
• oxylabs — Oxylabs, a rival scraper. Skews regional and local press.
• serp — the open-web baseline, mostly seen on news.

The takeaway is uncomfortable but clarifying: most brands are competing in the scraped tier. The licensed tier is effectively shut unless you own a national newspaper. So the levers you actually control are (1) being cleanly scrapable, and (2) earning third-party coverage that lands on the pages the scrapers reach.

Practically, "cleanly scrapable" means your facts and numbers sit in plain HTML text — never behind a script, never trapped in a PDF or an image.

Some questions never touch the web

Before ChatGPT searches, it files your question into a bucket in a field called turn_use_case. There appear to be six: instant search, shopping, text, local, thinking, and image generation.

The one to care about is text. When a question lands here, ChatGPT doesn't search at all — it answers from its training corpus and stops. The obvious cases end up here (how-tos, code, translation), but so do some you'd assume it researches. In the teardown, "latest treatment guidelines for type 2 diabetes" — current, high-stakes — was answered from training with an empty network tab.

And the wording decides the bucket, not the topic. "Best 4K TVs to buy" turns on shopping; "best 4K TVs with reviews" stays a normal search.

The lesson for content planning: before you spend a rupee on a page, check whether the query even triggers a search. If it's answered from training, no page can get in today, however good it is — your only route there is long-term authority and eventual presence in training data. Spend your effort where the engine actually fetches.

One question becomes forty

On the fast model, a query gets reworded once and searched. On the thinking model, a single "compare these tools" question fanned out into roughly 15–40 sub-queries. And they're revealing:

• It fires site: probes straight at vendor pricing pages.
• It guesses a price, then searches to confirm it.
• It keeps widening — picking up competitors you never named and chasing their pricing too.
• When reading a page, it literally greps for $, €, and specific numbers.

So two things follow. First, you need to survive a site:yourdomain.com/pricing probe — which means no JavaScript toggles, no dynamically loaded numbers. Second, you should write for the cleaned-up query the machine actually runs, not the messy phrase a human types.

Fetched, cited, and mentioned are three different things

This is the distinction most people muddle, and it's the one Indexly is built around. Three separate things can happen to your page:

• Fetched — the model pulls your page into context. This is the result_source object. The reader never sees it.
• Cited — your page becomes the clickable footnote behind a specific sentence.
• Mentioned — your brand name appears in the answer, often as a chip, but isn't the source of the claim.

You can win or lose each independently. In the teardown's sample, Reddit and YouTube were both fetched heavily — 278 and 201 times — but Reddit was cited 11 times and YouTube not once. The reason looks mechanical: a citation has to bind to text the model actually pulled, and a fetched YouTube page hands over metadata, not the transcript. A Reddit thread is all there on the page. That gap isn't just one person's sample either — Ahrefs, across 1.4M prompts, found Reddit cited far more often than YouTube.

Two more mechanics sit underneath:

• Citations bind to a specific sentence, not the whole answer. Being topically relevant isn't enough — you have to be the best support for a precise claim.
• Results dedupe by domain. Twenty thin pages from your site collapse into one. One strong page per claim beats a pile of weak ones — which is the exact opposite of spinning up thousands of thin programmatic pages for every fan-out query.

And the hardest rule to internalize: you can't cite yourself. Vendor pages get cited for their own facts — pricing, specs. But the verdict on which product is best almost always gets sourced from a third party. Own your facts; earn your opinion elsewhere.

The model narrates its own strategy

The thinking model's chain of thought is saved in the conversation, and it describes its own sourcing in plain words. For facts, it goes to the official page first. But when pricing is hidden behind JavaScript, it says so — notes it "can't parse" the page — and falls back to a third party like G2.

That's the whole game in one trace. When your own numbers won't parse, the model doesn't abandon the answer — it just sources those numbers from someone else. Your facts, a competitor's citation. A JavaScript pricing table doesn't only rank badly; it quietly hands your data to G2.

What you can't optimize for

Some of this is out of your hands, and it's worth naming so you don't chase it:

• There's no visible ranking logic. Domain authority weights, trust scores, formulas — if they exist, they stay server-side. Anyone selling you "ChatGPT's ranking factors" is selling you a story.
• Personalization is real and selective. On queries that overlapped the researcher's own history, ChatGPT pulled from personal_sources like past conversations, Gmail, and files. Part of some answers is built from private data no one can optimize for.
• Local is capped. A config value limited local results to two. For "near me" queries, you're in the top two or you're nowhere.

Together these are exactly why two people get different answers, and why a visibility score measured once is noise. You have to measure across many runs and many engines to see the real signal — a single snapshot tells you almost nothing.

What to actually do about it

Strip away the plumbing and the playbook is tight:

1. Be scrapable. Facts and numbers in plain, crawlable HTML — never in JS, PDFs, or images.
2. Own your facts, earn your opinion. Your pricing and specs live on your page; the recommendation gets cited from Reddit and review hubs. Invest in both.
3. One strong page per claim. It dedupes by domain, so depth beats a pile of thin pages.
4. Win on text, not video. Citations bind to text the model can pull.
5. Check the bucket first. If a query is answered from training, no page wins it today.
6. Measure fetched vs. cited vs. mentioned — across every engine, over many runs. One number on one day is variance, not visibility.

That last point is the whole reason Indexly exists. We track not just whether you appear, but which of those three outcomes is happening — across ChatGPT, Claude, Gemini, Perplexity, Grok, and Google AI Overviews — so you can tell the difference between being read, being cited, and being recommended, and fix the right gap.

The engines change by the week. The structure holds; the numbers move. Build for the machinery, not for the search engine it isn't.

Structural findings on ChatGPT's network traffic via Suganthan Mohanadasan's research. Aggregate patterns and framing by Indexly.