2026-09-15 — Brand Monitoring · ChatGPT

How to measure brand mentions in ChatGPT answers

“Are we mentioned in ChatGPT?” is really three separate questions: does the answer name you, does it cite you as a source, and does it show your product. Each uses a different field of the response, and each needs a different sample size to trust. This post is the method, not a result — run it on your own prompt set.

Request the signals together

{
  "prompt": "What are the best running shoes for flat feet?",
  "country": "US",
  "include": { "searchQueries": true, "shopping": true }
}

include.searchQueries, include.ads and include.shopping share one add-on: turning on any of them adds the same cost once (pricing). Request them together so one call gives you every signal below.

Three signals, three fields

• Mention: your brand’s name appears in result.text (or result.markdown), or as an item in result.entities — an array of {type, name} pairs ChatGPT’s response extracts, most reliably populated for products. Matching entities catches a named product even when the surrounding prose paraphrases your brand; matching text catches everything entities misses.
• Citation: your domain appears in result.sources, the list of pages ChatGPT cites, each with a position. A citation is stronger evidence than a mention — the answer is pointing at a page you control, not just saying your name.
• Shopping presence: your product’s title appears under result.shoppingCards[].products[] or result.inlineProducts[].product, returned only when include.shopping is true and omitted (not an empty array) when there’s nothing to show. This is the signal that matters for commerce prompts and rarely applies to informational ones.

def brand_signals(result: dict, brand: str, domain: str) -> dict:
    text = (result.get("text") or "").lower()
    mentioned = brand.lower() in text or any(brand.lower() in e["name"].lower() for e in result.get("entities", []))
    cited = next((s["position"] for s in result.get("sources", []) if domain in s.get("url", "")), None)
    card_titles = [p["title"] for c in result.get("shoppingCards") or [] for p in c.get("products", [])]
    inline_titles = [ip["product"]["title"] for ip in result.get("inlineProducts") or [] if ip.get("product", {}).get("title")]
    shown = any(brand.lower() in t.lower() for t in card_titles + inline_titles)
    return {"mentioned": mentioned, "cited_position": cited, "shown_in_cards": shown}

Run this over result from a synchronous response or response.result of a completed task.

Turning signals into a rate

For a set of N prompts, mention rate is the share where mentioned is true, citation share is the share where cited_position is not null, and so on for shopping presence. Report each per market (country), since the same prompt set answers differently by market, and keep the prompt wording fixed across runs so a change in the rate reflects a change in the answers, not a change in what you asked.

How many prompts you need

A mention rate is an estimate of a proportion, and its precision depends on sample size, not on how the prompts were chosen. For a rate near p estimated from N prompts, the standard error is roughly sqrt(p(1-p)/N). Two consequences worth planning around:

• Precision improves slowly. Halving the standard error takes four times the prompts, not two. Going from 50 to 200 prompts roughly halves your margin of error; going from 200 to 800 halves it again.
• Rates near 50% need the most prompts. The p(1-p) term peaks at p = 0.5, so a mention rate you expect to be very high or very low is cheaper to measure precisely than one you expect to be middling.

In practice: use a small set (30–50 prompts) to check the method works and the fields populate as expected, then size the real run to the margin of error you need — a rough rate to spot a trend can run on 100–200 prompts, while a number you’ll defend to a customer needs 500 or more. Whatever size you land on, keep the same prompts across periods; comparing rates from two different prompt sets confounds the trend with the sampling.

Running it repeatably

Submit the set as async batches with an idempotency key per prompt and market, add a webhook, and record the raw signals alongside the run’s date — the rank-tracking pipeline post covers that plumbing end to end. Recompute the three rates from stored raw results rather than re-requesting them, so a method change doesn’t require re-running the API.

Keep reading