What is query fan-out, and how do you optimize for it?

What is query fan-out?

Query fan-out is a retrieval technique where an AI system breaks a user's prompt into several related sub-queries, sends them to a search index in parallel, and merges what comes back before writing the answer. One question in, many searches out. The word comes from computing, where "fan-out" means one input feeding several outputs.

Google gave the term to search marketers. When Elizabeth Reid, Google's head of Search, announced AI Mode on 20 May 2025, she said it uses a "query fan-out technique," breaking a question into subtopics and issuing many searches at once. In the same post she described Deep Search as fan-out taken further, a mode that "can issue hundreds of searches" for a single request (Google).

Google's documentation for site owners repeats it. The Search Central page on AI features says AI Overviews and AI Mode alike "may use" query fan-out, which it explains as running several related searches over different subtopics and data sources. The same page says there are no extra requirements and no special optimizations needed to appear in either feature: the page just has to be in the index and allowed to show a snippet in normal results (Google Search Central).

That last line matters more than it looks. If there's no special markup for AI features, the only lever is the one SEO always had: rank for what the engine searches. Fan-out simply changes what the engine searches. Your buyer's question is still in there, along with five or ten machine-written variations of it, most of which no human ever typed into Google. In the glossary we keep the one-line version.

How does query fan-out work, step by step?

Fan-out runs in four steps: the model reads the prompt and decides whether to search, writes a set of sub-queries, retrieves results for each in parallel, then picks the passages that support its answer and cites them. Each engine tunes these steps differently, but the shape is the same everywhere we've seen it documented.

1. Decide whether to search at all

Not every prompt triggers retrieval. Anthropic's documentation for Claude's web search tool lists the cases: recent events, current prices, facts about organizations or products that might have changed, and explicit requests to look something up. Stable knowledge, math and creative writing usually get answered without a search (Anthropic). A buyer asking "which invoicing tool should a 30-person firm pick" sits squarely in the search bucket, because product facts change.

2. Write the sub-queries

The model rewrites the prompt into search strings. Long conversational prompts become short queries. Amani et al. found that nearly 80% of real user prompts in their dataset ran past 20 terms, while almost all of the generated web queries stayed under 10 to 15 terms. The rewrite adds things the user never said, too. Profound reported that the words ChatGPT most often appends to fan-out queries include "best," "top," "reviews" and "2025" (Profound).

Google's patent filings show one way this can be built. A pending application titled "Search with stateful chat" (US20240289407A1) describes generating "synthetic queries" from a language model's output, including rewrites, supplemental queries and drill-down queries (Google LLC). A granted patent covered by Search Engine Journal, "Thematic Search" (US12158907), groups top results into themes named by a model and runs a new search per theme (Search Engine Journal). Google hasn't said either filing powers AI Mode, so read them as a plausible blueprint and nothing firmer.

3. Retrieve in parallel

Most engines send the sub-queries out together. The academic study above found ChatGPT, Grok and DeepSeek send parallel fan-outs at each step, while Claude generates one query per iteration and goes deeper over more iterations. Google grounds Gemini in its own Search index. Microsoft's Bing grounding tool for agents describes the same opening move, where the agent constructs search queries and the tool submits them (Microsoft Learn).

4. Select, merge and cite

The model reads the pooled results, keeps the passages that answer some part of the prompt, and links them. This is where a page that ranks for a sub-query, but not for the original question, can still get cited. It's also why AI engines choose sources that look odd from a classic rank-tracking view: the citation came from a search you never tracked.

Does every AI engine fan out the same way?

No. Google's Gemini fans out widest, with 8 to 11 queries per prompt in API studies; ChatGPT runs about 2 to 3 and rewrites heavily; Perplexity runs fewer and stays close to your wording; Claude searches one query at a time. The table below pulls the published numbers together, with each source's method, so you can see where they agree.

The rewrite style matters as much as the count. Profound ran 10,000 prompts over 14 days through ChatGPT, Perplexity and Copilot and measured how much each engine's queries reuse the prompt's own words. Perplexity kept 88%, Copilot 50% and ChatGPT 13%. A "how" question stayed a question only 31% of the time on ChatGPT, and Copilot turned 93% of "how" prompts into keyword strings (Profound).

In practice that means a page tuned to the literal question has a fair shot in Perplexity and a weak one in ChatGPT, which goes off and searches for something adjacent. If you've ever ranked first on Google for a question and still been ignored by ChatGPT, this is the likeliest reason.

Google sits apart. Its fan-out runs against its own index with its own ranking systems, so the sub-searches behave like normal Google queries. Peec's analysis of more than 20 million ChatGPT fan-outs between October 2025 and January 2026 found the average query grew from about 6 words to about 12 over that window, while the count per prompt held between 2.3 and 2.8 (Peec AI). Longer strings mean narrower intent, which favors pages that answer one specific thing well.

Why do the fan-out counts disagree so much?

Because each study counts something different. Some only count turns where the engine searched, some average across every run, some use the API and others the consumer app, and model versions change month to month. Most of the gap between 1.4 and 8.52 queries per prompt comes from method.

Take ChatGPT. The academic paper reports 3.07 because it averages over turns that had web queries available, which drops every prompt answered without a search. Profound's 1.4 to 2 range pools engines and counts per prompt run. Peec's 2.1 comes from 5 million fan-outs collected in April 2026 by its own tracker. All three can be right at once.

Gemini looks high for a related reason. Seer measured the Gemini 3 API with Google Search grounding switched on, which is a developer setting, not AI Mode itself. Surfer used the same kind of setup as a stand-in for AI Overviews and AI Mode and saw about 5 fan-outs per run (Surfer). Google hasn't published a figure for its consumer products, so anyone quoting one exact number for AI Mode is quoting a proxy.

What does query fan-out do to rankings and citations?

It weakens the link between ranking for a question and being cited for it. AI answers now cite many pages that don't rank in the top 10 for the original query, because those pages ranked for one of the hidden sub-searches instead. Every large study since mid-2025 shows the overlap shrinking.

• For AI Overviews, Ahrefs looked at 863,000 keyword results and 4 million cited URLs. In March 2026, 37.9% of AI Overview citations sat in the query's own top 10, against about 76% in July 2025. Ahrefs attributes the drop to fan-out searches and the move to Gemini 3.
• In AI Mode, SE Ranking checked 10,000 US keywords, of which 9,734 triggered AI Mode. On average only 14% of AI Mode's URLs matched the organic top 10, and three runs of the same keyword on the same day shared just 9.2% of URLs (SE Ranking).
• Ahrefs ran about 15,000 prompts in an earlier study. Just 12% of the URLs that ChatGPT, Gemini and Copilot cited also sat on page one of Google for that prompt; Perplexity managed 28.6% (Ahrefs). That fits the rewrite data above: Perplexity searches closest to your words.
• Our own sample points the same way. In our study of AI Overview citations for B2B queries, the organic top 10 overlapped with cited URLs 28.7% of the time across a 40-query sample, and 10 of those 40 AI Overviews cited no top-10 URL at all.

Surfer adds a useful counterweight. In its 1,600 grounded runs, 84% of fan-out queries shared at least one URL with the original query's top 20. So the sub-searches aren't random; they orbit the same topic and often return pages that already rank nearby. The pages that get cited are usually close to the original results, just not in the slots a rank tracker watches.

Mike King of iPullRank made this point early. In May 2025 he described AI Mode as a reasoning system that runs synthetic queries, showed an example where AI Mode attempted 28 queries for one prompt, and released Qforia, a free tool that generates likely fan-out queries with Gemini (iPullRank). Digiday's explainer the following month quoted him on the "subintents" behind a query (Digiday). Both pieces predate Gemini 3, so the mechanics have moved since, but the core advice still holds.

How can you see the fan-out queries an AI engine runs?

Call the engine's API with web search turned on and read the search strings it returns. Gemini lists them in webSearchQueries, OpenAI in each web_search_call action, and Claude in each server_tool_use block. None of the consumer apps shows the full list, so the API is the cleanest public view you'll get.

A caveat first. API calls aren't the same as the consumer apps. They use different system prompts, no user memory, often no location, and sometimes different model versions. Treat API fan-outs as a strong sample of what the engine tends to search, not a recording of what a buyer's session did.

Gemini: groundingMetadata.webSearchQueries

With Grounding with Google Search enabled, Gemini's response carries a groundingMetadata object with four fields: webSearchQueries (the searches the model ran), groundingChunks (the web sources, each with a URI and title), groundingSupports (which part of the answer each source backs) and searchEntryPoint (markup for Google's search suggestions) (Google AI for Developers). Google's own example for "Who won the euro 2024?" returns two queries, "UEFA Euro 2024 winner" and "who won euro 2024". Vertex AI uses the same field names (Google Cloud).

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "What is the best invoicing software for a 30-person architecture firm?"}]}],
    "tools": [{"google_search": {}}]
  }' | jq '.candidates[0].groundingMetadata | {webSearchQueries, sources: [.groundingChunks[].web.uri]}'

Billing proves the point on its own. For Gemini 3 and newer models, Google bills each search query the model decides to run, so one prompt that fires two queries counts twice. The first 5,000 queries a month are free across Gemini 3 models, then it's $14 per 1,000. Gemini 2.5 and older models are billed per prompt instead (Google AI for Developers).

OpenAI: web_search_call actions

In the Responses API, every search ChatGPT's models run appears as an output item of type web_search_call. Its action has a type of search, open_page or find_in_page, and a search action usually, though not always, carries the query text. Add web_search_call.action.sources to the include list to get every URL the model consulted, not only the ones it cited (OpenAI). OpenAI's docs show both a query field and a queries field in different places, so the filter below prints the whole action.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "YOUR_MODEL",
    "tools": [{"type": "web_search"}],
    "include": ["web_search_call.action.sources"],
    "input": "What is the best invoicing software for a 30-person architecture firm?"
  }' | jq '.output[] | select(.type == "web_search_call") | .action'

Use any current model that supports the web search tool. OpenAI prices web search at $10 per 1,000 tool calls plus tokens for most models (OpenAI).

Claude: server_tool_use blocks

Claude's web search tool returns each search as a server_tool_use block whose input.query holds the exact string, followed by a web_search_tool_result block with the URLs. The max_uses parameter caps searches per request, and usage.server_tool_use.web_search_requests counts them. Anthropic's docs say simple factual questions typically use 1 to 3 searches, while comparative or multi-entity research can use 10 or more.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 2048,
    "tools": [{"type": "web_search_20250305", "name": "web_search", "max_uses": 10}],
    "messages": [{"role": "user", "content": "What is the best invoicing software for a 30-person architecture firm?"}]
  }' | jq '[.content[] | select(.type == "server_tool_use") | .input.query]'

Anthropic charges $10 per 1,000 searches on top of tokens, and a failed search isn't billed.

Perplexity and Copilot

Neither gives you the strings as cleanly. Perplexity's API returns a search_results list with each result's title, URL, snippet and date, which tells you what it found but not what it typed (Perplexity). Microsoft's Bing grounding tool for agents returns URL citations, and Microsoft hasn't documented how consumer Copilot builds its queries. For these two, the commercial trackers that capture fan-outs in the interface are the practical route. Our guide on measuring AI visibility covers which tools expose them.

What does it cost to capture fan-outs yourself?

For a 50-prompt set run three times a week, roughly $31 a month in search fees across Gemini, Claude and OpenAI, plus model tokens. The math is simple once you know each engine's average query count and its price per search, and it's a fraction of a tracker subscription.

Assumptions, all published figures: 50 prompts, 3 runs per prompt per pass (to separate recurring queries from one-offs), 4 passes a month. Query averages come from the studies above. Treat this as an estimate. Your prompts will fan out more or less than average.

The OpenAI line is a ceiling. OpenAI bills tool calls, and one call can hold more than one query, so the real figure is likely lower. Gemini is nearly free at this volume because the first 5,000 queries cost nothing. Double the prompt set and Gemini jumps to 10,224 queries, of which 5,224 are billable at $14 per 1,000, or $73.14. That's the line to watch as you scale.

What you don't get for $31: Google AI Mode and AI Overviews themselves, Perplexity's query strings, and anything personalized. For those, you either pay for a tracker or accept the Gemini API as a proxy for Google.

Worked example: mapping fan-outs for one buyer prompt

This is a hypothetical walkthrough. The company, the prompt and the queries below are our own illustrations of the method, not output we captured. The point is the process, which you can run on your own prompts with the API calls above.

Say you sell invoicing software built for architecture firms. Your most valuable prompt is "What's the best invoicing software for a 30-person architecture firm that bills by project phase?" You run it 10 times through the Gemini API and 10 times through Claude, then pool the query strings. After normalizing (lowercase, strip the year, merge near-duplicates) you sort them by how many of the 20 runs they showed up in.

We use three tiers as a rule of thumb. Core queries show up in at least 5 of 10 runs per engine, recurring ones in 2 to 4, and one-offs once. The thresholds are our own, but the reason behind them comes from the data. Surfer found only about 27% of fan-outs stayed consistent across runs and 66% appeared once. Seer saw just 8 of 11,029 queries in all 13 runs. If you build a page for every string, two thirds of your work targets searches that may never happen again.

Then audit coverage. For each core and recurring query, search it on Google in a logged-out window and note whether you rank in the top 10. In this example, say you rank for the first query but not for "phase-based billing software architects" or the pricing query. Those two gaps are your work for the quarter: a phase-billing explainer with a sample invoice, and a pricing page with real numbers. The QuickBooks and AIA queries come next.

Notice what you didn't do. You didn't create a page per query, and you didn't stuff "2026" into titles because some fan-outs included a year. Seer's earlier Gemini 3 research found 21.3% of fan-outs contained a year, which tells you engines care about freshness. It doesn't tell you a year in your H1 will get you picked.

How do you optimize content for query fan-out?

Cover the recurring sub-questions of your best prompts with direct, self-contained answers, make sure those answers rank on Google and Bing for the sub-query wording, and keep facts like pricing, integrations and fit on pages engines can read. There's no fan-out markup. It's ordinary ranking, aimed at more queries.

• A core fan-out query with its own intent gets its own section, usually not its own page. One strong page with a clear H2 per sub-question usually beats eight thin pages. Split it out only if the sub-query is big enough to rank as a head term by itself, like pricing.
• ChatGPT rewrites hard, so match the topic rather than the wording. With 13% word overlap, exact-match phrasing won't carry you. Make sure the page covers the adjacent facts the rewrite goes looking for: comparisons, prices, reviews.
• Perplexity stays close to the prompt, so the literal question as an H2 does help there. Its 88% word overlap means a heading that mirrors the buyer's phrasing lines up with what it searches.
• When fan-outs pair your brand with a competitor, you need a comparison page. Seer's earlier Gemini 3 work found 26.4% of fan-outs named a brand. If the engine searches "[you] vs [rival]" and the only results are the rival's pages, that's the version it reads.
• Can't rank for a sub-query yourself? Get named on the pages that do. Fan-outs with commercial words ("best," "top," "reviews") return listicles and review sites. Being named there counts as much as ranking yourself.
• Put the answer to each sub-question in the first 40 to 60 words under its heading. Engines lift passages, and a section that buries the answer under three sentences of context loses to one that leads with it.

Two technical checks sit under all of this. The page must be indexable and allowed to show a snippet, which is Google's only stated requirement. For ChatGPT, Claude and Perplexity, their search crawlers also need access, since those engines search their own or partner indexes. If you haven't checked recently, our list of AI crawler user agents shows what to allow.

Which fan-out tactics waste your time?

Chasing individual query strings, judging fan-outs by keyword volume, and generating pages in bulk from a fan-out tool's output. Each one treats a list that changes on every run as if it were a stable keyword list.

Tracking exact strings is the most common one. ChatGPT almost never fires the same search string twice for the same prompt, per Profound's data, with 91% unique per run. A dashboard that reports "we now rank for 14 of ChatGPT's fan-out queries" is measuring a moving target. Track topics and tiers, not strings.

Filtering by search volume kills good queries. Seer found 99% of Gemini 3 fan-outs had zero monthly search volume. Run them through a keyword tool and they all look worthless. They're machine queries, so they never show up in human search data in the first place. Judge them by how often they recur and how close they sit to revenue.

Then there are generators. Several free tools now produce plausible fan-out lists from a seed query. They're useful for brainstorming, but they're guesses from one model at one moment. Building twenty pages from one tool's output creates thin, overlapping content, which is the opposite of what any engine picks.

One engine doesn't speak for the rest, either. Gemini at 8.52 queries and Claude at one query per iteration behave nothing alike. If your buyers use ChatGPT more than anything else, a fan-out map built only on Gemini will point you at the wrong gaps.

And patents aren't manuals. The "Search with stateful chat" filing is a pending application, and the often-cited "prompt-based query generation" patent is about training retrieval models, not live answers. Patents show what Google has explored. They don't confirm what ships.

Is query fan-out a new kind of SEO?

No. It's classic SEO applied to more queries than you can see. Google says outright that AI features need nothing beyond an indexed, snippet-eligible page. What changed is the query set: you used to optimize for what people typed, and now you also optimize for what a model types on their behalf.

For the engine-by-engine version of this, our playbook for ranking in Google AI Mode turns the sub-query idea into an eight-step plan with done criteria.

Frequently asked questions