Most advice about getting cited in ChatGPT is guesswork dressed up as strategy. Write quality content, publish listicles, get active on Reddit. It might be right, but almost nobody checks. Suganthan Mohanadasan took a different route: instead of reading ChatGPT’s answers and guessing at the machinery behind them, he opened the browser’s network panel and read the traffic ChatGPT sends itself. What comes back is a much more mechanical picture of how the model chooses who to fetch, who to cite, and who it quietly ignores. For anyone trying to be visible in AI answers, the mechanics are more useful than the slogans.
First, a word on the method and its limits
This is one person’s read of roughly 1,240 source records, captured over a few days on a single Pro account, with queries skewed toward SaaS and tech. Suganthan is careful to split his findings into two confidence levels, and we will keep that split, because it is exactly the honesty this topic needs.
The structural facts are high confidence: they come straight off the wire, the same way every time. The internal field names, the pipeline labels, the fact that some questions never trigger a web search at all. The frequencies are directional only: the percentages and rankings come from a small, tech-heavy sample, and health or fashion queries would look different. So trust the mechanisms, and treat the exact numbers as a snapshot rather than a law.
Not every question even touches the web
Before ChatGPT searches anything, it files your question into a bucket. Suganthan saw six of these intent labels, including one that quietly settles a lot of arguments about AI visibility: the “text” bucket answers from the model’s training memory and never searches the web at all.
That has a blunt consequence. Some questions you simply cannot win with content, because no page is ever fetched to answer them. In his test, three of ten deliberately current, high-stakes questions were answered with no web search. And the bucket is decided by how you phrase the question, not the topic. “Best coffee near me” runs the local pipeline. “Best 4K TVs to buy” triggers shopping. “Best 4K TVs with reviews” stays in normal search. Same subject, three different machines, three different sets of winners.
The practical read: before you worry about ranking in an AI answer, work out whether the questions you care about even reach the web. Some never will.
Four pipelines decide who gets fetched
For the questions that do search, every web result carries an internal label saying which pipeline fetched it. Suganthan found four values, and others in the industry surfaced the same field independently. In plain terms:
- serp is the open-web baseline, mostly news.
- labrador looks like a licensed tier for established publishers (think Reuters, the Guardian, the WSJ, Wikipedia, arXiv), pulled in as near-complete article extracts rather than short snippets.
- bright and oxylabs are the names of commercial scraping firms, Bright Data and Oxylabs, and they do the heavy lifting on the open web. In his sample, Bright Data dominated shopping, finance and weather, while Oxylabs leaned toward regional and local press.
A single weather query, for example, split its sources across pipelines: the national forecasters came through one scraper, the regional papers through another. You do not control which pipeline picks you up, but the pattern is a reminder that ChatGPT is assembling an answer from several fetching systems at once, not searching one index like Google.
Fetched, cited, and mentioned are three different things
This is the distinction that reframes everything, and most visibility advice blurs it. There are three separate outcomes, each with its own win condition:
- Fetched means the model pulled your page into its working context. You never see this, and it earns you nothing on its own.
- Cited means your page is credited as the source for a specific sentence, the clickable footnote.
- Mentioned means your brand name appears in the answer, often as a chip, without being the source of any claim.
The gap between fetched and cited is where a lot of effort quietly dies. In Suganthan’s sample, Reddit was fetched 278 times and cited 11 times. YouTube was fetched 201 times and cited zero. The mechanical reason is simple: citations bind to text the model actually read, and a YouTube page returns metadata, not a transcript, while a Reddit thread is all readable text. This is not a small-sample fluke. Ahrefs, studying 1.4 million prompts, found Reddit cited only about 1.93% of the time it appeared, and that roughly two thirds of all fetched-but-uncited URLs were Reddit. The platform is used constantly to understand a topic and almost never credited for it.
One more mechanic hides in that list: results deduplicate by domain. Twenty thin pages from one site collapse into a single citation slot. Publishing more of the same page does not buy you more presence.
One question becomes dozens of searches
When ChatGPT uses its “thinking” mode on a comparison question, it does not run your query. It runs many. Suganthan watched single comparison tasks fan out into fifteen to forty sub-queries, and because those sub-queries are logged, you can read exactly what the model asked.
The behaviour is strikingly literal. It fires site: probes straight at vendors’ pricing pages. It guesses a price, then searches to confirm the guess. It goes off-script and pulls in competitors you never mentioned, then hunts for their pricing too. When it reads a page, it is grepping for dollar signs and specific words like “Agency” or a plan name.
The lesson for visibility is uncomfortable: you are not competing for the question a user typed. You are competing for a swarm of rewritten sub-queries you never see, many of them aimed at pages you may not have optimised, like your own pricing page.
It reads your page for facts, everyone else’s for opinion
When Suganthan looked at the thinking model’s own saved reasoning, the strategy was written out in plain language. For hard facts like pricing and specs, it prefers the official source and says so, choosing a current pricing page over an older third-party mention. For judgement calls like “which tool is best,” it sources the verdict to third parties: review hubs, comparison sites, communities.
That single sentence is the most useful summary of the whole piece, and it is his: ChatGPT “reads your own page for the facts, if it can parse them, and everyone else’s for the opinion.” Two different jobs, two different sources. You own the facts about yourself. You do not own the verdict.
The JavaScript wall
Here is the finding that should change how a lot of sites are built. When the model went to pull pricing off tools like Profound and Peec, it could not. It noted, in its own reasoning, that the prices were not in the result because the page loaded them with JavaScript. Unable to parse the official number, it fell back to quoting a third party instead, deciding to use figures from a review site because the official page was too hard to read.
Read that twice, because it is the whole game for facts. If your key numbers, your prices, your specs, your availability, are rendered by JavaScript after the page loads, the model may fetch your page, fail to read the fact, and hand the citation to whoever wrote about you in plain text. You can be the definitive source for a fact about your own business and still lose the citation to a comparison site, purely because of how your page is built.
What this means for your AI visibility
None of this rewards clever slogans. It rewards a page a machine can actually read, and a reputation other sites are willing to state. For the small and mid-sized businesses we work with across Poland, Ukraine and the wider EU, that turns into a short, unglamorous checklist:
- Put your facts in plain, server-rendered HTML. Prices, specs, locations, hours, plan names. If a fact matters, it should be in the page text, not painted in by JavaScript after load. This is the single highest-leverage fix here.
- Keep one strong page per fact, not a farm of thin ones. Deduplication by domain means volume does not help. A clear, canonical pricing or product page beats twenty near-duplicates.
- Earn the opinion elsewhere. You own the facts, but the “which is best” verdict comes from third parties. Genuine reviews, useful community presence, and inclusion in independent comparisons are what feed that half. This is the same earned-authority work behind real AI visibility, and it cannot be faked on your own site.
- Write plainly and label clearly. The model rewrites questions into literal sub-queries and matches on readable text, and Ahrefs found pages with clear, descriptive titles and URLs were cited far more often. Say what a page is, in words.
- Know which questions never search. If your buyers ask things the model answers from memory, no amount of content wins them. Aim your effort at the questions that actually trigger a fetch.
You can check your own, no special access needed
You do not need to be a researcher to see some of this. In ChatGPT, open your browser’s developer tools, switch to the Network tab, turn on “preserve log,” run a query, and search the responses for the field name result_source. You will see which pipeline fetched each result on your own sessions, and nothing leaves your machine. Suganthan documents the full method, and Olivier de Segonzac has published a free Chrome extension that captures the same fan-out and pipeline data and exports it to a spreadsheet. It is worth an hour to watch how a few of your own important queries actually get answered.
The honest caveat, and the takeaway
This is a snapshot, not a specification. It is one account, a few days, a tech-heavy set of queries, and a system OpenAI changes constantly. The exact numbers will drift, and Suganthan says as much. Treat the percentages as directional and the structure as the durable part.
But the structure is the part that should change what you do. ChatGPT is not a search engine, and optimising for one misses the point. It sorts your question into a bucket, fetches through pipelines you do not control, reads your page for facts only if it can parse them, and borrows everyone else’s page for the verdict. The businesses that get cited are the ones whose facts are readable and whose reputation is real. That is not a trick you can install. Like good SEO, it is the slow, honest work of being both legible to the machine and genuinely recommended by the web around you.
Sources
- Suganthan Mohanadasan, “How ChatGPT Actually Picks Sources (I Read the Network Traffic, Not the Outputs),” 24 June 2026: suganthan.com
- Ahrefs, “Why ChatGPT Cites One Page Over Another (Study of 1.4M Prompts)”: ahrefs.com
- Olivier de Segonzac, free ChatGPT search fan-out Chrome extension (writeup): think.resoneo.com
