How to track competitor visibility in Google AI Overviews

To track competitor visibility in Google AI Overviews, run your category questions and record two things per rival: whether the overview names them in answerText, and whether their domain appears in sources[], and in what position. Do it once by hand to learn the shape of your category. Then do it on a schedule — and read every rival's count against how many of your queries produced an overview at all, not against all of them.

The manual way (and why it stops working)

For a first pass it really is simple. Search the question a buyer would ask — "best expense management software for a growing startup", not "is Acme any good" — find the AI Overview, and read the prose for every company it names. Then do the part that makes this surface worth checking: expand the reference chips beside the block and note whose domains are there, in order. Repeat across three or four phrasings and you'll know both the competitive set and the pages holding it up. It costs an hour, and that first hour is the most useful one you'll spend on this — as long as you note, as you go, which of those searches returned no overview at all.

It's the second pass where it stops being an hour and starts misleading you.

• One search per tab. A category hides twenty or thirty buying questions, and expanding and reading each overview's reference chips is slow. You'll quietly narrow the sweep to the three queries you like, which is exactly how a blind spot forms.
• Half your queries may show no overview. Google answers some searches inline and leaves the rest as plain results. By hand the no-overview ones get skipped and forgotten, so months later you can't tell whether a rival left the set or the overview it lived in did.
• No history, so no diff. The question worth answering is whether Globex now appears in four more of your overviews than it did in June — and a browser tab stores neither June nor the count you'd subtract it from.
• Citation order dies in the clipboard. Drag the reference chips into a sheet and the positions scramble or the URLs vanish behind their titles. Cited at 1 and cited at 6 are different results, and position is the first casualty of copy-paste.
• A typed list never reaches a report. A hand-copied set of names isn't a chart in a client deck, a row in a table, or a job that pings you the week a new rival enters the overviews.

Do it with one API call

AgentGEO fetches the overview and returns the raw record: the full prose, plus every cited reference with its title, URL and position. One POST through a managed-scraper engine that's maintained for you, and the same envelope across all six engines — here it's just google_ai_overview.

curl -X POST https://api.agentgeo.org/v1/fetches \
  -H "Authorization: Bearer ag_live_..." \
  -H "Content-Type: application/json" \
  -d '{"query": "best expense management software for a growing startup", "surfaces": ["google_ai_overview"], "country": "US", "language": "en"}'

What comes back is a plain JSON envelope — no HTML, no scraping artifacts. For competitor work the intelligence sits in two places: the names Google wrote into the prose, and — denser and more useful — the ordered list of pages it read in order to write it.

{
  "id": "run_5f2a9c07be41",
  "query": "best expense management software for a growing startup",
  "surfaces": ["google_ai_overview"],
  "status": "completed",
  "recordsDelivered": 1,
  "creditsCharged": 1,
  "answers": [
    {
      "surfaceKey": "google_ai_overview",
      "status": "delivered",
      "answerText": "For a growing startup, Globex is frequently highlighted for corporate cards paired with automatic receipt capture, while Initech is noted for tight QuickBooks and Xero syncing on smaller finance teams ...",
      "sources": [
        { "title": "Globex Expense - corporate cards & receipt capture", "url": "https://globex.com/expense", "position": 1 },
        { "title": "Globex vs Initech for startup finance teams", "url": "https://globex.com/compare/initech", "position": 2 },
        { "title": "Best expense management software in 2026", "url": "https://example.com/best-expense-management", "position": 3 }
      ],
      "fetchedAt": "2026-07-18T09:14:22Z",
      "latencyMs": 61840
    }
  ]
}

The scan itself is short. Keep the competitive set in one dict — display name to root domain — check both places a rival can surface, and carry two counters instead of one: the queries that produced an overview, and the ones that didn't.

import requests
from collections import defaultdict
from urllib.parse import urlparse

KEY = "ag_live_your_key_here"

# The competitive set you track: display name -> root domain.
RIVALS = {"Acme": "acme.com", "Globex": "globex.com", "Initech": "initech.com"}

QUERIES = [
    "best expense management software for a growing startup",
    "expense management with corporate cards and receipt capture",
    "expense software that syncs with QuickBooks",
    "how much does expense management software cost per user",
]


def host(url):
    # Normalise so globex.com and www.globex.com are the same company.
    h = urlparse(url).netloc.lower()
    return h[4:] if h.startswith("www.") else h


named = defaultdict(set)   # brand -> queries whose prose named it
cited = defaultdict(list)  # brand -> (query, position, url) it was cited on
overviews = 0              # queries that actually produced an overview
missing = []               # queries where Google showed no AI Overview

for query in QUERIES:
    resp = requests.post(
        "https://api.agentgeo.org/v1/fetches",
        json={"query": query, "surfaces": ["google_ai_overview"],
              "country": "US", "language": "en"},  # search gl= and hl=
        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"]:
        if answer.get("status") == "failed":
            # No overview here: zero credits, and NOT a rival leaving the set.
            # Keep it out of the denominator instead of scoring it as a loss.
            missing.append(query)
            continue

        overviews += 1  # the denominator a fair share must be read against
        text = (answer.get("answerText") or "").lower()
        for brand in RIVALS:
            if brand.lower() in text:
                named[brand].add(query)
        for src in answer.get("sources") or []:
            h = host(src["url"])
            for brand, domain in RIVALS.items():
                if h == domain or h.endswith("." + domain):
                    cited[brand].append((query, src["position"], src["url"]))

# Read every rival's coverage against the overviews that ran, not all queries.
for brand in RIVALS:
    hits = cited[brand]
    print(f"\n{brand}: named in {len(named[brand])}/{overviews}, "
          f"cited on {len({q for q, _, _ in hits})}/{overviews} overviews")
    for query, position, url in sorted(hits, key=lambda row: row[1]):
        print(f"  #{position}  {url}   ({query})")

print(f"\nno overview for {len(missing)}/{len(QUERIES)} queries: {missing}")

Run that over your query set and you get a per-rival grid: how many overviews named each rival, which pages carried them there, and — kept honestly apart — the queries that produced no overview to be counted in. Each delivered record costs one credit; a query with no overview comes back failed at zero, which is exactly why missing is a list rather than a silent skip. While you're shaping the parser, an ag_test_ key returns clearly labelled demo records at zero credits.

The URLs are the payoff. Read the column and each cited page tells you something specific about how you're losing the query:

Let your agent do it

Citations point at pages, and pages are something an agent can go and read — which is why this job belongs in an agent rather than a spreadsheet. Wire the server into Claude Code once:

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

agentgeo-mcp speaks MCP over stdio, ships with zero npm dependencies and needs Node.js 18+. It exposes exactly one tool, fetch_raw_answers, with query and surfaces required and country defaulting to "US". After that the sweep is a sentence:

Pull google_ai_overview for our four expense management queries. For Acme, Globex and Initech, tell me which overviews name them and which cite their domain — but read every count against how many of the four produced an overview, not against all four. Then open the page at position 1 for the first query and tell me what it covers that ours doesn't.

The records arrive raw. Whether Globex turning up in two extra overviews is a real gain or ordinary churn is a judgment your agent makes with your context — AgentGEO ranks nothing, scores nothing and draws no conclusions, by design. If you'd rather script it, the Python and curl paths hit the identical endpoint.

Common problems

Five things that make competitor data on this surface read wrong, all fixable in the parser or the schedule:

• A missing overview is not a rival leaving the set. When Google shows no AI Overview, the record returns status: "failed" with "Google returned no AI Overview for this query" at zero credits. Log those queries in their own list. Silently reading them as "cited nobody" makes every rival — and you — look like they're bleeding coverage.
• Every rate needs two denominators. Coverage is how many of your queries produced an overview; share is how many of those overviews cited a given rival. Divide by the query set and you understate a rival by about twenty points. Report cited on X of the overviews that ran, and keep the overview count visible next to it.
• A failed AI Overview record is not a snapshot to redeem. The chatbot surfaces hand back a providerFields.snapshot_id on a slow scrape, which you can retry against for free. AI Overviews come through a different SERP fetch path, so there is no snapshot id here — re-run the query later instead, and accept that it may honestly fail again.
• Match domains in sources[], brand names in answerText. A third-party review titled "Globex vs Initech" matches a title search for both and was written by neither. Compare the host in url for citations, and use a word-boundary regex — re.search(r"\bglobex\b", text, re.I) — for prose mentions.
• Locale changes the citation list — and whether there's an overview at all. country sets the search gl= and language sets hl=, so a US-English overview and a German one cite different rivals, and one market can show an overview where the other shows none. Keep a separate log per market rather than one file you can't disentangle later.

Summary

For a one-off read on who Google's overviews favour, run the search yourself — the reference chips are right there and it costs nothing. When the sweep has to cover a query set, repeat weekly, and produce something you can subtract last month from, fetch it instead: one call per query returns the prose and the ordered citation list, forty lines of Python turn that into a per-rival grid, and the URLs in that grid are the real output — a short list of pages you can go and beat. Just count each rival against the overviews that actually ran, and keep the no-overview queries apart, or a quiet week for Google will read as a rival's collapse.