How to Measure Your Brand's Share of Voice Across ChatGPT, Claude, Perplexity, and Gemini: The AI Search Visibility Stack

By Sofía Salazar Mora, Founder of Agenticsis · Zurich, Switzerland · Last updated: July 25, 2026 · Fact-checked by senior AI consultants

Table of Contents

1. Why traditional SEO tools miss AI citations
2. The four surfaces and their measurement challenges
3. Query design: what to ask, how often
4. Citation extraction: parsing four different response formats
5. Share of voice: the math and its honest caveats
6. Brand disambiguation: catching wrong-brand confusions
7. Change detection: comparing weekly snapshots
8. What this methodology cannot measure well
9. How to replicate it: three levels of automation
10. Frequently Asked Questions
11. Conclusion

Why traditional SEO tools miss AI citations

Ahrefs, Semrush, and every other SEO tool built in the last fifteen years measures the same thing: your position in the classical blue-link SERP for a given keyword. That measurement was correct when the SERP was where users decided which link to click. It is incomplete now that the SERP has been extended by AI Overviews on Google, by Perplexity's cited-sources pane, by ChatGPT's browsing responses, and by Claude's and Gemini's search-augmented answers.

The thing that increasingly decides whether a prospect finds you is not your blue-link position. It is the sentence a language model generates when asked about your industry, your product, or your name. That sentence is retrieved from an entity graph and rewritten by a model. If your brand is not in the graph, or is confused in the graph with a competitor, that sentence describes someone else.

Traditional SEO tools cannot measure this because their crawlers are not the AI systems doing the retrieving. Even the newer SEO tools that added "AI Overview tracking" only measure the Google-generated overview, which is one of at least four AI surfaces that matter. To measure the full picture, you need a pipeline built for the actual surfaces users query.

The four surfaces and their measurement challenges

Each of the four dominant AI search surfaces has a different data model, a different citation format, and a different level of API accessibility. A measurement pipeline needs to handle all four.

ChatGPT (OpenAI)

ChatGPT's browsing surface returns a generated response with inline citations when browsing is triggered. There is no first-party API for measuring what ChatGPT retrieves at inference time. Measurement requires either running your own prompts via the ChatGPT interface (manual), scripting a browser session (fragile, terms-of-service adjacent), or approximating with the OpenAI API + a web search tool that mirrors what ChatGPT's browsing layer uses. None of these are perfect. The honest position is that ChatGPT is the hardest of the four to measure programmatically.

Perplexity

Perplexity is the friendliest to measurement. Its API returns a generated answer plus a structured list of cited source URLs for every query. This is the surface where you can build the highest-fidelity share-of-voice signal, because the citations are unambiguous and machine-readable. If you can only measure one AI surface to start, measure Perplexity.

Claude

Claude's web search is triggered on demand within a conversation. The Anthropic API supports web search as a tool, and when it fires, the response includes the URLs Claude fetched and used. Measurement via the API is possible and produces citation-level detail similar to Perplexity, though the trigger conditions (when Claude decides to search) mean the query set has to be designed to invite search-augmented answers.

Gemini and Google AI Overview

Gemini powers Google's AI Overview block, which appears on some (not all) branded and intent queries. Measurement of AI Overview requires either the SERP itself (parseable with a headless browser or a SERP API) or DataForSEO's ai_search endpoint, which returns AI Overview content for a given keyword at a given location. DataForSEO is the most stable programmatic path today for AI Overview measurement.

Query design: what to ask, how often

The single most important design choice in an AI visibility pipeline is the query set. Get this wrong and every downstream metric is wrong. The query set is the sample of user intent you are measuring visibility against.

A useful query set has four categories:

1. Branded queries. Your brand name, your brand name plus modifier ("Agenticsis Zurich", "Agenticsis pricing"), founder name plus company. These measure whether the AI systems know you exist and can describe you correctly.
2. Category queries. The unbranded phrases a buyer types when they know the problem but not you. "AI consultancy Zurich", "AEO agency Switzerland", "answer engine optimization services". These measure whether the AI systems mention you when someone is buying the category.
3. Comparison queries. Your brand versus a competitor, or "best [category] tools". "Agenticsis vs Agentic.swiss", "best AI consultancies in Switzerland 2026". These surface where you are being ranked head-to-head.
4. Problem queries. The pain-language a prospect might use before they know the category exists. "How do I get my company cited by ChatGPT", "why doesn't my brand show up in AI Overview". These are the highest-intent queries, and often the most winnable because incumbents ignore them.

Cadence matters. Weekly is the sweet spot. Daily produces too much noise (query results fluctuate day to day for reasons unrelated to your work). Monthly is too slow to catch a regression in time. Weekly gives you enough signal to see trends over a quarter and enough resolution to catch a bad deploy within a week.

Volume matters. In our experience, 40 to 80 queries total, split roughly 3:1 intent:branded, gives a stable signal without burning excessive API budget. Below 20 queries the share-of-voice math is too noisy. Above 200 queries you are paying for statistical precision you cannot act on.

Citation extraction: parsing four different response formats

Each engine returns a different response shape. Your pipeline needs a normalization layer that converts all four into the same internal format so downstream analytics work uniformly.

A useful internal record looks like this:

{
  "engine": "perplexity" | "claude" | "gemini" | "chatgpt",
  "query": "AI consultancy Zurich",
  "query_type": "category",
  "run_at": "2026-07-25T02:00:00Z",
  "answer_text": "Several AI consultancies in Zurich offer...",
  "citations": [
    { "url": "https://agenticsis.ch/", "domain": "agenticsis.ch", "position": 3 },
    { "url": "https://agentic-swiss.ch/", "domain": "agentic-swiss.ch", "position": 1 }
  ],
  "brand_mentions": [
    { "brand": "Agenticsis", "in_answer": true, "in_citations": true, "position_in_answer": 142 }
  ],
  "raw_response": { ... }
}

The normalization work per engine:

• Perplexity: the API response already contains a citations array. Map directly.
• Claude: when a web search tool fires, the response includes tool_use and tool_result blocks. Extract URLs from the tool results and rank them by order of appearance in the final answer.
• Gemini / AI Overview: DataForSEO's ai_search endpoint returns an items array with source objects. Map items[].source_url and items[].source_domain.
• ChatGPT: if you are scripting via the interface, extract the inline citation footnote markers from the DOM. If you are approximating via the OpenAI API with browsing tools, extract from the tool call responses similarly to Claude.

Once normalized, every downstream calculation (share of voice, brand mention rate, competitor tracking, change detection) is engine-agnostic. This normalization step is worth spending real engineering time on. It is the foundation everything else sits on.

Share of voice: the math and its honest caveats

Share of voice, in this context, means: across the query set, what percentage of citations went to your brand versus your competitors versus the long tail?

The naïve calculation:

sov(brand, engine, week) =
  count of queries where brand.domain appeared in citations
  / total queries run against engine that week

This is the number to report. It is also the number that hides three subtleties you should surface honestly:

1. Position matters. A citation ranked first is worth more than a citation ranked fifth. A weighted variant that gives position-1 citations a higher score correlates better with click-through and prospect awareness.
2. Answer-body mentions are separate from citations. A brand can be named in the generated answer text without being in the citations list. Track both signals separately. Answer-body mentions signal that the model knows about the brand from training. Citation appearances signal that the model retrieved current content about the brand.
3. Query type dominates. A share of voice reported as a single number across all query types is misleading. Report it per query type at minimum. Branded queries always have inflated SoV; category queries always have deflated SoV. Comparing them without segmentation makes trend analysis meaningless.

The honest reporting shape:

              branded   category   comparison   problem
perplexity      92%       18%        41%          22%
claude          88%       12%        38%          15%
gemini          76%       9%         22%          8%
chatgpt         81%       11%        26%          14%

A single 45% "overall SoV" number hides all the interesting information. The matrix tells you which surface to invest in and which query type to write content for.

Brand disambiguation: catching wrong-brand confusions

The subtlest failure mode in AI visibility measurement is a wrong-brand confusion counted as a right-brand mention. If your brand name has a phonetic neighbor (a look-alike domain, a similar-sounding company, a name shared with a person), the AI systems will occasionally cite the neighbor when the user meant you, or vice versa. Without disambiguation logic, your pipeline will over-report visibility.

Two techniques work in combination.

Domain matching first. Do not credit an answer as citing your brand unless the citation URL is on your canonical domain (agenticsis.ch, in our case) or an approved subdomain. This catches most confusions immediately: if the AI cited agentcis.com when the user asked about Agenticsis, the domain check catches it.

Context-window checks second, for answer-body mentions. When your brand name appears in the answer text but no citation points to your domain, the mention needs to be validated by context. The technique: scan a token window of ~30 words around the brand mention and check for co-occurring terms that only apply to your brand (headquarters city, founder name, industry, unique product name). If the window mentions your city and industry, the mention is you. If the window mentions a different city or a different industry, it is a confused mention that belongs to the phonetic neighbor.

def is_real_brand_mention(answer_text, brand, brand_signals):
    # brand_signals: e.g. ["Zurich", "Sofia Salazar Mora", "AEO", "Switzerland"]
    idx = answer_text.lower().find(brand.lower())
    if idx == -1:
        return False
    window = answer_text[max(0, idx - 200) : idx + 200]
    signal_hits = sum(1 for s in brand_signals if s.lower() in window.lower())
    return signal_hits >= 2  # require at least 2 disambiguating signals

This is not perfect. It will occasionally reject a legitimate mention that appeared in a low-context sentence. Better to under-count real mentions than to over-count confused ones. Reported numbers you can defend are worth more than optimistic numbers that fall apart when audited.

Change detection: comparing weekly snapshots

A single week's numbers are diagnostic. A series of weekly numbers is a trend. A trend is what tells you whether your work is compounding or eroding.

The storage pattern that makes this cheap: an append-only weekly snapshot table. Every week's run inserts one row per (engine, query_type) cell of the SoV matrix. Never update, never delete. The historical series is the primary artifact of the pipeline.

-- snapshot table
create table sov_snapshot (
  id               uuid primary key default gen_random_uuid(),
  brand_id         uuid not null,
  engine           text not null,
  query_type       text not null,
  week_of          date not null,
  sov_pct          numeric not null,
  citations_count  int not null,
  answer_mentions  int not null,
  captured_at      timestamptz default now()
);
create index on sov_snapshot (brand_id, engine, query_type, week_of desc);

Weekly diff is a simple SQL join against the prior row per (engine, query_type). The alerts that matter:

• SoV dropped more than 15 percentage points week-over-week on a single engine (usually a bug on that engine's side or a recent competitor content push).
• Brand-name mention rate in citations dropped to zero on any engine (often a disambiguation regression).
• A new phonetic-neighbor domain appeared in your citations set with more than one hit (add it to the confusion registry immediately).
• Category-query SoV crossed a milestone up or down (30% is a psychological reporting threshold both internally and to customers).

What this methodology cannot measure well

Honest limits are more useful than optimistic claims. Four things this pipeline does not measure well, and does not pretend to:

• Private conversations. When a real user asks ChatGPT about your brand in a private thread, that instance never enters any measurement pipeline. All measurement is of automated queries approximating what a user would type. The proxy is useful. It is not the ground truth.
• On-device and local models. Apple Intelligence, on-device Gemini Nano, and locally-run Llama or Mistral variants do not touch the public web at inference time. Their "answers" come from model weights trained months ago. No live-query pipeline can see into them. The only lever is being present in the training data cutoff.
• Voice assistants. Voice-assistant responses have different retrieval logic than text queries and different citation surfaces. Measuring them requires separate infrastructure (voice API access is uneven across providers).
• Multilingual variants outside the query set. A pipeline measures exactly the queries you designed. Every language you do not query is a language you cannot measure. Expand the query set per language if you sell in multiple markets.

These limits are worth naming out loud in every internal or client-facing report. They protect the credibility of the numbers you can defend.

How to replicate this methodology: three levels of automation

The methodology is the same at every level of automation. What changes is the tooling and the maintenance cost.

Level 1: Manual weekly spreadsheet (2 hours per week)

Pick 20 queries. Every Monday morning, run each query manually against Perplexity, Claude, and ChatGPT. For each response, note whether your brand appeared in the answer and whether your domain appeared in the citations. Log to a Google Sheet with columns: date, query, engine, brand_in_answer, brand_in_citations, competitor_1_in_citations, competitor_2_in_citations. After four weeks, chart the columns as time series. You have a working AI search visibility signal, powered by human labor and a spreadsheet.

This level is enough to catch regressions and validate that your entity establishment work is having an effect. It is not enough to scale beyond one brand.

Level 2: Semi-automated Python notebook (one afternoon of engineering)

A Colab or Jupyter notebook with roughly 100 lines of Python: the Perplexity SDK for that engine, the Anthropic SDK for Claude with web search tool, and a simple SoV calculation over a query list stored in a JSON file. Run the notebook manually every Monday and log results to a Google Sheet or a Supabase table. This is where most technical founders should start.

import json, requests
from anthropic import Anthropic

QUERIES = json.load(open("queries.json"))
BRAND_DOMAIN = "agenticsis.ch"

def query_perplexity(q):
    r = requests.post(
        "https://api.perplexity.ai/chat/completions",
        headers={"Authorization": f"Bearer {PPLX_KEY}"},
        json={"model": "sonar-pro", "messages": [{"role": "user", "content": q}]},
    )
    data = r.json()
    citations = data.get("citations", [])
    hit = any(BRAND_DOMAIN in c for c in citations)
    return {"engine": "perplexity", "query": q, "hit": hit, "citations": citations}

results = [query_perplexity(q) for q in QUERIES]
sov = sum(1 for r in results if r["hit"]) / len(results)
print(f"Perplexity SoV this week: {sov:.1%}")

Add Claude and DataForSEO with a similar pattern. You have a working pipeline for the cost of an afternoon.

Level 3: Fully automated weekly pipeline with change detection

Scheduled job (n8n, Vercel Cron, GitHub Actions) that runs the queries weekly, normalizes results, calculates SoV per engine per query type, writes to an append-only snapshot table, diffs against the previous week, alerts on regressions, and renders a client-facing dashboard. This is what the Agenticsis Visibility Program automates. It costs engineering time to build and ongoing API budget to run. For teams that measure visibility for more than one brand (agencies, portfolios, holding companies), the fully-automated version pays for itself quickly.

All three levels use the same methodology. Pick the level that matches your current time and budget. Upgrade when the manual work becomes the constraint.

Frequently Asked Questions

What is the difference between SEO and AEO?

SEO (Search Engine Optimization) optimizes for the classical blue-link results page: ranking factors, backlinks, on-page keywords, technical crawlability. AEO (Answer Engine Optimization) optimizes for the sentence a language model generates when asked about your brand or category: structured data, entity establishment (Wikidata, GitHub, Crunchbase, LinkedIn), disambiguating branding, and content that is directly quotable. The methodology in this article is an AEO measurement pipeline. It measures the AEO surface, not the SEO surface.

Do I need to measure all four AI engines from day one?

No. Start with Perplexity because its API returns clean citations. Add Claude second because the Anthropic API supports web search as a tool. Add Google AI Overview via DataForSEO third. Add ChatGPT last because it is the hardest to measure programmatically and adds the most fragility to your pipeline. Each addition doubles your maintenance surface. Add engines when you need them, not preemptively.

How often should I run the pipeline?

Weekly is the sweet spot for most brands. Daily produces too much noise, monthly is too slow to catch a bad deploy or a competitor content push. Weekly gives you enough resolution to graph trends over a quarter and enough signal to catch a regression within a week. If your product ships weekly, the pipeline should ship weekly.

What size query set do I need?

Forty to eighty queries total, split roughly three intent queries per one branded query. Below twenty queries the share-of-voice math is too noisy to trust. Above two hundred queries you are paying for statistical precision that does not change the actions you would take.

How do I handle brand-name confusion with a similarly-named competitor?

Two layers. First, only credit a citation to your brand when the citation URL is on your canonical domain (this catches most confusions immediately). Second, for answer-body mentions where no citation points to your domain, run a context-window check: scan the tokens around the brand mention and require at least two disambiguating signals (your city, your founder name, your industry, a unique product name) before counting the mention as yours. Maintain an explicit registry of known look-alike brands and their canonical domains.

What can this methodology not measure?

Private ChatGPT conversations, on-device model responses (Apple Intelligence, on-device Gemini Nano, local Llama), voice-assistant queries, and any language you did not include in your query set. Any AI visibility number is a proxy for the ground truth of user experience, not the ground truth itself. Naming this limit in your reports protects the credibility of the numbers you can defend.

Is there a free tier for the APIs I need?

Perplexity has a pay-as-you-go API with a small free tier. Anthropic's API has a free tier for new accounts and web search is billed as a tool call. DataForSEO is pay-per-request with no free tier but individual queries cost cents. For a Level-2 semi-automated pipeline with 40 queries per week across three engines, total API cost is typically under 20 USD per month.

How does this relate to the Agenticsis Visibility Program?

The Agenticsis Visibility Program is the productized version of exactly this methodology. It runs the four-engine query set weekly, calculates SoV per engine per query type, tracks brand-mention disambiguation against a confusion registry, and delivers a report with change detection. It is CHF 40 for four weekly credits. If you would rather run the methodology yourself, everything in this article is the recipe.

Conclusion: The Diagnostic Is Not the Fix

Measuring AI search visibility does not, by itself, make your brand visible. Measurement is the diagnostic. The fix is entity establishment, content quality, and disambiguating branding, all of which we have covered elsewhere. But without measurement, the fix work happens blind. Founders end up optimizing for the wrong number, celebrating vanity metrics that do not move pipeline, or missing regressions that would compound if left unwatched.

The methodology in this article is the minimum viable measurement stack for a serious brand in 2026. Whether you run it weekly on a spreadsheet, in a Colab notebook, or through a productized pipeline, the underlying math is the same. What matters is that you run it, that you segment by engine and query type, that you disambiguate honestly, and that you graph the trend.

What you learn will surprise you. It surprised us.

The companion piece to this one, the field report on how we discovered we needed this pipeline in the first place (three SEO resets, a redirect bug that nearly killed our brand SERP, and the day Google's AI Overview finally described Agenticsis correctly), is on the blog: The Invisible Consultancy.

About the Author: Sofía Salazar Mora, Founder of Agenticsis (Zurich)

Zurich-based AI Consultancy · Founded 2026

Sofía Salazar Mora is the founder of Agenticsis, a Swiss AI consultancy based in Zurich. Engineer with an MBA, she works in English, German, and Spanish across DACH and Latin America. Agenticsis partners with enterprises to design, deploy, and scale autonomous AI agents, agentic workflows, and Answer Engine Optimization systems across 850+ integrated tools.

Areas of Expertise: Autonomous agent architecture · AI search visibility (AEO / GEO) · EU AI Act & Swiss FADP compliance · Multilingual DACH deployments · Event-driven agent design.

Zurich, Switzerland · agenticsis.ch · Fact-checked by senior AI consultants · Last Updated: July 25, 2026