How to check if Google AI Overviews mention your brand

The shortest honest answer: run the query in Google, find the AI Overview block, and read it for your brand. To do that repeatedly, across a query set, with a record you can compare next month, POST the query to https://api.agentgeo.org/v1/fetches with "surfaces": ["google_ai_overview"] and branch on three outcomes — delivered with your brand in answerText, delivered without it, and failed because Google showed no AI Overview for that search at all.

The manual way (and why it stops working)

Open an incognito window so your own history doesn't colour the result, type the question a buyer would type — "best help desk software for small teams" — and look at the top of the page. If an AI Overview is there, read it end to end and check for your name; expand the reference chips on the right and check for your domain. If there's no overview, note that: you've just learned that Google doesn't answer this particular question inline, which is a genuinely useful thing to know about a query you were planning to compete on.

It's free, it's fast, and it collapses the moment you need row two:

• One query at a time. Real category coverage is twenty to fifty phrasings. Nobody types those by hand every week, so the check silently shrinks to the three queries you happen to like — which are rarely the three that matter.
• You can't tell absence from non-existence at a glance. "No overview appeared" and "an overview appeared and skipped us" look similar in a browser and mean opposite things. Conflate them once in a spreadsheet and every rate you derive afterwards is wrong.
• Your results are personalised and localised. Signed-in history, location and language all shape what you see. Two colleagues checking the same query honestly disagree, and neither is looking at the market you actually sell into.
• No history to diff. The interesting question — did we enter the overview for these six queries since we rewrote the docs? — needs last month's overviews stored. A screenshot folder isn't a series.
• It can't go anywhere. A browser reading can't feed a weekly report, a client dashboard or an alert without a human retyping it, so it stops happening the first week that human is busy.

Do it with one API call

AgentGEO fetches the AI Overview for you and returns it as JSON: the overview prose in answerText, and its references as sources[] with title, URL and position. Unlike the chatbot surfaces, this one goes through a search path rather than a chat scrape — an AI Overview is a block on a results page, not a conversation — so country and language genuinely matter here. They drive the search's gl= and hl= parameters, which is to say they change which market's overview you're reading.

curl -s https://api.agentgeo.org/v1/fetches \
  -H "Authorization: Bearer ag_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"query": "best help desk software for small teams", "surfaces": ["google_ai_overview"], "country": "US", "language": "en"}' \
  | jq '.answers[0] | {status, answerText, sources}'

Now the real version, which is mostly about branching correctly. Check status before you touch answerText, and keep the three outcomes in separate counters:

import re
import requests
from urllib.parse import urlparse

KEY = "ag_live_your_key_here"
BRAND = "Acme"
DOMAIN = "acme.com"

QUERIES = [
    "best help desk software for small teams",
    "what is a shared inbox for customer support",
    "help desk software with SLA tracking",
    "how much does help desk software cost",
]

MENTION = re.compile(rf"\b{re.escape(BRAND)}\b", re.I)
tally = {"named": 0, "absent": 0, "no_overview": 0}


def host(url):
    h = urlparse(url).netloc.lower()
    return h[4:] if h.startswith("www.") else h


for query in QUERIES:
    resp = requests.post(
        "https://api.agentgeo.org/v1/fetches",
        json={
            "query": query,
            "surfaces": ["google_ai_overview"],
            "country": "US",   # drives the search gl= parameter
            "language": "en",  # drives the search hl= parameter
        },
        headers={"Authorization": f"Bearer {KEY}"},
        timeout=200,  # an AI Overview SERP round-trip alone runs 40-90s
    )
    resp.raise_for_status()

    for answer in resp.json()["answers"]:
        print(f"\n{query!r}")

        # Outcome 3, and it goes first: Google showed no AI Overview for this
        # search. A real finding, not a bug - and it costs zero credits.
        if answer.get("status") == "failed":
            tally["no_overview"] += 1
            reason = (answer.get("providerFields") or {}).get("error", "")
            print(f"  no AI Overview  ({reason})")
            continue

        text = answer.get("answerText") or ""
        hosts = {host(s["url"]) for s in answer.get("sources", [])}
        cited = any(h == DOMAIN or h.endswith("." + DOMAIN) for h in hosts)

        if MENTION.search(text):
            tally["named"] += 1
            print(f"  overview shown - {BRAND} named (cited: {cited})")
        else:
            tally["absent"] += 1
            print(f"  overview shown - {BRAND} absent (cited: {cited})")
            print(f"  cited instead: {', '.join(sorted(hosts)) or 'nothing'}")

print(
    f"\n{tally['named']} named / {tally['absent']} absent"
    f" / {tally['no_overview']} with no AI Overview"
)

Three counters, three different jobs to do about them. Note what the last line gives you almost for free: the share of your query set that Google answers inline at all. That number moves on its own schedule, independently of anything you publish, and knowing it is what stops you from reading a Google product decision as a drop in your own visibility.

Let your agent do it

If the check belongs in a conversation rather than a script — which it usually does when you're mid-edit on the page you're hoping will get cited — install the MCP server and ask in plain language:

claude mcp add agentgeo -- npx -y agentgeo-mcp --key ag_live_...

The server talks over stdio, installs nothing beyond itself, and wants Node.js 18+. Its lone tool, fetch_raw_answers, passes records straight through — status included, which is what lets the agent tell an absence apart from a missing overview. Then describe the check:

Fetch google_ai_overview for our four help desk queries. For each one tell me whether an AI Overview appeared at all, whether Acme is named in it, and whether acme.com is in the sources. List the queries with no overview separately — I don't want them mixed into the count.

The win isn't the twenty lines of Python you didn't write. It's that the agent is already sitting inside your codebase, so it can travel from "this overview cites three competitors and none of them are you" to "here is the section of your docs that should have earned the reference" without anyone hand-assembling the context in between. The same server drops into Cursor, Zed and any other MCP client.

Common problems

• A failed AI Overview record is not a snapshot to redeem. On the chatbot surfaces, a slow scrape returns a providerFields.snapshot_id you can retry against. AI Overviews come through a different fetch path entirely, so there is no snapshot id to collect — if the record failed because no overview existed, re-running later is the only move, and it may well fail again for the same honest reason.
• Coverage varies by query, so measure it instead of assuming it. Some intents produce an overview nearly every time and others almost never. Rather than guessing which of your queries are which, keep the no_overview counter and look at it — a query that has never once produced an overview is a query where this whole check doesn't apply.
• Locale actually changes the result here. country sets the search gl= and language sets hl=, so a US-English overview and a German one are different answers with different sources and possibly different existence. This is unlike the chatbot surfaces, where language isn't forwarded at all. Keep one market per series and never average two.
• Don't fold "no overview" into a zero. It's the single most common way this data goes wrong. A query with no AI Overview told you nothing about your brand's presence; counting it as an absence drags every percentage down for a reason that has nothing to do with your content.
• Match the brand on a word boundary, and the domain on the host. A substring test for a short name catches unrelated words and companies that merely share a prefix. And check your domain against sources[].url rather than sources[].title: a title belongs to whoever wrote the page, so a rival's "Acme vs Globex" write-up will satisfy a brand-name search and credit you with a reference you didn't earn.

Summary

For a one-off, search the query and read the block — it's free and it takes a minute. The moment the check has to repeat or cover a real query set, fetch it as data and branch on all three outcomes. Named, absent, and no overview at all are three different results with three different responses, and the third one is the one every simpler tracker gets wrong. Handle it properly and you end up with two numbers instead of one: whether Google mentions you, and how often Google answers your category inline at all.