2026-09-17, GEO · Analytics

AI grounding by engine: which index each assistant searches, and how to measure it

Grounding is the step where an AI engine retrieves content, usually from a search index, and writes its answer from it, linking the pages it used. The index behind that step decides which pages are even candidates for citation, so “which search engine does ChatGPT use?” has practical weight. Some of the answer is documented by each vendor and much of it isn’t.

The first half below lists, per engine, what the vendor states about its search provider and citation display, with source and check date, and marks the rest “not publicly documented”. The second half is a method for estimating, on your own prompts, how closely each engine’s citations track Google organic results.

It builds on two earlier posts without repeating them: how AI engines choose citations covers the retrieval-then-selection model and selection hypotheses, and ChatGPT query fan-out covers aggregating ChatGPT’s searches into a keyword list. This post covers the index layer and how to attribute citations to it.

Documented vs not documented, per engine

All sources checked 2026-09-17.

ChatGPT search

The two documented facts combine in a useful way: ChatGPT uses outside providers, and it also runs its own search crawler. Which of the two surfaced a given citation is not documented.

Perplexity

Gemini (app)

For developers, Google’s Grounding with Google Search docs say the model “automatically generates one or multiple search queries” and returns them. That describes the Gemini API tool, not necessarily the consumer app.

Microsoft Copilot (consumer)

The Bing Webmaster Tools report is the strongest public link between consumer Copilot citations and Bing: Microsoft reports those citations inside Bing’s publisher tool. It describes reporting, and says nothing directly about the retrieval pipeline.

Grok

Google AI Overviews and AI Mode

What follows from the documented part

The tables suggest three hypotheses. None is established, and each can be tested:

1. Engines documented as grounded in Google Search should overlap more with Google organic results. Gemini, AI Overviews and AI Mode are grounded in Google. If their cited domains don’t overlap with Google organic results for the same topic more than other engines’ do, the fan-out queries, which Google doesn’t show per answer, are diverging from the prompt.
2. Engines with their own or mixed providers should overlap less. Perplexity runs its own index; ChatGPT mixes providers and its own crawler; Copilot is tied to Bing through Microsoft’s reporting. Lower overlap with Google is expected, but its size is an empirical question per category.
3. Grok should cite x.com more than other engines. It is the only engine that documents X search. The share of x.com sources per engine is a direct test.

The measurement method

For each engine, estimate what share of its cited domains also appear on Google’s first organic results page (and first two pages) for the searches behind the answer, on your prompt set, with a margin of error.

Step 1: choose the fields per engine

Where an answer has no search queries, run the prompt itself through Google and record that you did. It is a weaker comparison, so report those rows separately.

Step 2: normalize to registrable domains

Compare at domain level (www. stripped, lower case). The index question is about sites: did this engine’s retrieval reach the sites Google ranks for the same searches?

Step 3: collect and compute

import os
from urllib.parse import urlsplit

import requests

API = "https://api.answerline.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['ANSWERLINE_API_KEY']}"}

ENGINES = {
    "chatgpt": ("/v1/monitor/chatgpt", {"include": {"searchQueries": True}}),
    "copilot": ("/v1/monitor/copilot", {}),
    "grok": ("/v1/monitor/grok", {}),
    "gemini": ("/v1/monitor/gemini", {}),
}


def post(path: str, body: dict) -> dict:
    resp = requests.post(API + path, json=body, headers=HEADERS, timeout=360)
    resp.raise_for_status()
    return resp.json()["result"]


def domain(url: str) -> str:
    return (urlsplit(url).hostname or "").lower().removeprefix("www.")


def organic_by_page(query: str, country: str) -> tuple[set[str], set[str]]:
    serp = post("/v1/monitor/google", {"query": query, "country": country, "pages": 2})
    results = [r for r in serp.get("organicResults", []) if r.get("link")]
    page1 = {domain(r["link"]) for r in results if r.get("page") == 1}
    pages12 = {domain(r["link"]) for r in results}
    return page1, pages12


def measure(prompt: str, country: str = "US") -> list[dict]:
    rows = []
    for name, (path, extra) in ENGINES.items():
        result = post(path, {"prompt": prompt, "country": country, **extra})
        cited = {domain(s["url"]) for s in result.get("sources", []) if s.get("url")}
        queries = result.get("searchQueries") or result.get("search_model_queries") or []
        basis = "engine_queries" if queries else "prompt_fallback"
        top10, top20 = set(), set()
        for q in queries or [prompt]:
            page1, pages12 = organic_by_page(q, country)
            top10 |= page1
            top20 |= pages12
        rows.append({
            "engine": name,
            "basis": basis,
            "cited": len(cited),
            "in_top10": len(cited & top10),
            "in_top20": len(cited & top20),
            "x_com": sum(1 for d in cited if d in ("x.com", "twitter.com")),
        })
    return rows

top10 and top20 here mean Google result pages 1 and 1–2, read from each organic result’s page field. The example is synchronous for readability. In a real study, deduplicate queries across engines and prompts, cache each query’s organic results, and submit everything as async batches with webhooks.

Report per engine, aggregated over the prompt set:

• Overlap on page 1: sum of in_top10 / sum of cited, and the same for pages 1–2 with in_top20.
• x.com share: sum of x_com / sum of cited.
• The count of answers on prompt_fallback, reported separately from engine_queries.

Step 4: size the sample

Treat each cited domain as an observation for the overlap rate, but remember observations within one answer are correlated. The conservative unit is the answer: compute overlap per answer, then average across answers. Standard margins for a proportion at 95% confidence:

These use 1.96 × √(p(1−p)/n). To detect a difference between two engines, or a before/after change, the requirement is larger: moving from 20% to 30% at 80% power and 5% significance needs about 290 observations per group, and from 30% to 40% about 360. If your prompt set is 50 prompts, plan several runs per prompt across days and analyze the prompt as a cluster, rather than pretending 50 × 5 runs are 250 independent draws. Sampling vs census and answer volatility cover the repeated-runs side.

Step 5: interpret with care

• Higher overlap for Gemini than for ChatGPT on your prompts is consistent with the documented providers. It does not prove the pipeline.
• Low overlap on prompt_fallback rows mostly measures the gap between the prompt and the engine’s hidden searches, not the index.
• A high x.com share for Grok on news-like prompts and a low one on product prompts is plausible; measure prompt categories separately.
• Overlap with Google says nothing about Bing. For Copilot, pair this measurement with Bing Webmaster Tools’ AI Performance report for your own site.

What it costs

As async tasks: ChatGPT with searchQueries 7 credits, Copilot 5, Grok 5, Gemini 4, so 21 per prompt for these four engines. Each Google query costs 3 credits for the first page and 2 per extra page, so 5 with pages: 2. Synchronous calls add 2 credits each.

An illustrative study: 60 prompts, 3 runs each, 4 engines is 60 × 3 × 21 = 3,780 credits. If the engines’ searches plus fallback prompts yield 900 unique queries at 5 credits each, add 4,500, for 8,280 in total. That is beyond the free tier’s 500 monthly credits, so validate the pipeline on five prompts first. See credits and cost planning.

Pitfalls

• A pooled organic set flatters every engine. Keep each engine’s queries and organic results separate.
• Several vendor pages above changed during 2026. Re-check them and date the check in your report.
• ChatGPT documents location-aware query rewriting, so keep country fixed per comparison.
• “Not publicly documented” means unknown. It doesn’t mean no.

Field details per engine are on the engine pages; the first call takes a few minutes with the quickstart.

Keep reading