How to check if Perplexity mentions your brand

To check whether Perplexity mentions your brand, ask it the question your customers ask and look in two places: the answer text, for your name, and the numbered citation list, for your domain. Those are different results and they need different fixes. One query is a browser tab; a query set on a schedule is one API call per query and a dozen lines of code.

The manual way (and why it stops working)

Open Perplexity, ask the question a buyer would ask, and read the answer. Then scroll to the sources, because the numbered citations are the real payload. Search the page for your brand name and for your domain separately — the prose can name you without citing you, and it can cite you without naming you. Do that across your five most valuable queries and you have an honest baseline in about fifteen minutes, at no cost.

It's a good first hour. It's a bad process:

• One question per tab. Thirty queries means thirty reads, and Perplexity's source lists are long enough that scanning them carefully is slow work.
• The answer is re-searched every time. Perplexity searches fresh on each ask, so the set of cited pages genuinely shifts between runs. What you read once is a sample of a moving target.
• Nothing is diffable. You can screenshot a source list. You cannot subtract last week's screenshot from this week's and get the two domains that changed.
• Positions die in transcription. Cited at 1 and cited at 9 are very different outcomes, and a hand-copied list almost never keeps the order intact.
• It stops at the browser. No CSV, no row in a client report, no weekly job, and no way to hand a colleague the result as data rather than a description of it.

Do it with one API call

Send the query to AgentGEO with perplexity in the surfaces array and you get the same thing the browser shows you, structured: the answer text, and every cited source with its title, URL and position.

curl -X POST https://api.agentgeo.org/v1/fetches \
  -H "Authorization: Bearer ag_live_..." \
  -H "Content-Type: application/json" \
  -d '{"query": "best CRM for small business", "surfaces": ["perplexity"]}'

The record comes back as clean JSON — no HTML to parse, no selectors to keep alive as the frontend changes:

{
  "id": "run_84c1f2ab91d3",
  "query": "best CRM for small business",
  "surfaces": ["perplexity"],
  "status": "completed",
  "recordsDelivered": 1,
  "creditsCharged": 1,
  "answers": [
    {
      "surfaceKey": "perplexity",
      "status": "delivered",
      "answerText": "Several CRMs suit small businesses. Globex is most often recommended for automation, while Acme is favoured for how quickly it sets up ...",
      "sources": [
        { "title": "Best CRM software for small business", "url": "https://example.com/best-crm", "position": 1 },
        { "title": "Acme CRM — pricing and plans", "url": "https://acme.com/pricing", "position": 2 },
        { "title": "Globex vs Initech", "url": "https://globex.com/compare/initech", "position": 3 }
      ],
      "fetchedAt": "2026-08-13T10:02:41Z",
      "latencyMs": 9260
    }
  ]
}

From there the check is two independent tests. Keep them independent — collapsing "named" and "cited" into a single boolean throws away the most actionable distinction this engine gives you:

import requests
from urllib.parse import urlparse

BRAND = "Acme"
DOMAIN = "acme.com"
QUERY = "best CRM for small business"

resp = requests.post(
    "https://api.agentgeo.org/v1/fetches",
    json={"query": QUERY, "surfaces": ["perplexity"]},
    headers={"Authorization": "Bearer ag_live_your_key_here"},
    timeout=200,  # the API waits up to 180s for live surfaces
)
resp.raise_for_status()
answer = resp.json()["answers"][0]

if answer.get("status") == "failed":
    raise SystemExit("no record this run — retry the same single surface later")

text = answer.get("answerText") or ""
sources = answer.get("sources", [])

# 1. Named in the prose?
named = BRAND.lower() in text.lower()

# 2. Cited in the source list — and at what position?
cited_at = None
for src in sources:
    h = urlparse(src["url"]).netloc.lower()
    h = h[4:] if h.startswith("www.") else h
    if h == DOMAIN or h.endswith("." + DOMAIN):
        cited_at = src["position"]
        break

print(f"query:  {QUERY}")
print(f"named:  {named}")
print(f"cited:  {'position ' + str(cited_at) if cited_at else 'no'}")
print(f"sources ({len(sources)}):")
for src in sources:
    print(f"  {src['position']:>2}. {src['title']} — {src['url']}")

That prints three facts per query: whether you were named, whether you were cited and at what position, and the full list of pages that fed the answer. Loop it over your query set and you have a visibility table. One delivered record is one credit; a failed record costs nothing.

Let your agent do it

The same records are available over MCP, which means the check can be a sentence instead of a script — and the agent that fetches the answer can also go read the page that beat you. Wire it in with one command:

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

The agentgeo-mcp package runs over stdio with zero npm dependencies on Node.js 18+, exposing a single tool: fetch_raw_answers. query and surfaces are required; country defaults to "US" and language to "en", so say "in Germany, in German" when you want a different market. Then ask for the work:

• "Fetch Perplexity's answer for 'best CRM for small business'. Is acme.com in the sources, and at what position?"
• "Run our five category queries through Perplexity and give me a table: named, cited, citation position."
• "For every query where we're not cited, list the domains that were — and tell me which page of ours is closest to competing with them."

The tool returns records and nothing else — no visibility score, no sentiment, no ranking. Your agent already knows your site and your competitors, so it's the right place for the conclusions to be drawn. If you'd rather script it, the Python API hits the identical endpoint.

Common problems

Five failure modes worth designing around before you trust the numbers:

• `www.` and subdomains. www.acme.com, docs.acme.com and acme.com/blog are all you. Normalise the host before comparing — lowercase it, strip a leading www., accept any suffix match on your root domain — or you'll systematically under-count your own citations.
• Named is not cited. Test answerText and sources[] separately and store both columns. The four combinations mean four different things and only one of them is "you're fine".
• Phrasing moves the source list more than you'd expect. "Best CRM for small business" and "CRM for a small business" can retrieve different pages. Fix a query set, keep it stable across runs, and treat any edit to it as the start of a new baseline.
• Locale is a different question, not noise. country defaults to "US" and language to "en". If you sell in Germany, the German-language answer is its own answer with its own cited domains — measure it as a separate query set rather than averaging it into a number that describes nowhere.
• One run is a sample. Because Perplexity re-searches on every ask, the citation list moves. Fetch on a schedule and judge the trend; a single absence isn't a verdict, and a single appearance isn't a win.

Summary

For a one-off look, search Perplexity yourself and read both the answer and its sources — the free path is genuinely informative here because the citations are always there. When the check has to repeat across a query set, land in a report, or run on a schedule, fetch it: one call per query returns the text and the structured citation list, and the named-versus-cited split tells you which of two very different problems you actually have.