How to check if Perplexity recommends your product

To check whether Perplexity recommends your product, ask the questions a buyer asks while deciding — "best X for Y", "X alternatives", "X vs Y" — and look for your name in the answer. Then do the part that decides the outcome: read the sentence around the mention, and read the sources underneath it. Being listed is not being recommended, and on a search-grounded engine the difference is usually traceable to one cited page.

The manual way (and why it stops working)

Open Perplexity and ask like a buyer, not like a marketer. "Best expense management software for a 50-person company." "Acme alternatives." "Is Acme worth it for a finance team of three?" Find your name, read the sentence it sits in — that sentence is the actual result — and then glance at the numbered sources, because one of them is where the sentence came from. Five or six phrasings, ten minutes, no cost, and you'll know roughly where you stand today.

Then the ceiling arrives, and it arrives fast.

• Buying intent fans out. "Best", "cheapest", "alternatives to", "X vs Y", and one variant per segment and use case — each is a separate answer with its own shortlist and its own framing of you. Covering that honestly is a morning, and it's a morning you owe again next month.
• The wording moves between asks. Perplexity retrieves fresh every time, so Tuesday's flattering sentence and Thursday's lukewarm one can both be real. One reading can't separate a genuine slip from ordinary churn.
• You will read yourself into a conclusion. Skimming prose for your own name, "also worth a look" files itself under win with remarkable ease. Extracting the sentence and judging it deliberately is a different exercise from scanning for a highlight.
• The source behind the sentence gets lost. The citation that produced an unflattering claim is sitting right there in the numbered list, and it is the single most useful thing on the page — but only if you note which one it was before you close the tab.
• Nothing is stored and nothing is scheduled. In two months you'll want to know whether the framing improved after you rewrote the pricing page. Chat history is not a dataset, and it can't page you the week a competitor takes your slot.

Do it with one API call

One POST to AgentGEO returns the raw record for a query: the full answer text and every source cited, structured. No headless browser, no selectors to keep alive — the managed-scraper engine is maintained for you.

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

Now write the check that matters. Instead of testing whether the brand is present, split the answer into sentences and keep the ones your brand appears in — then print the sources alongside them, so the framing and its evidence stay attached to each other:

import re
import requests
from urllib.parse import urlparse

KEY = "ag_live_your_key_here"
BRAND = "Acme"

# Buying intent - the questions asked immediately before a decision.
QUERIES = [
    "best expense management software for a 50-person company",
    "Acme alternatives for expense management",
    "Acme vs Globex for expense reports",
    "cheapest expense tracking tool with receipt scanning",
]

MENTION = re.compile(rf"\b{re.escape(BRAND)}\b", re.I)


def sentences(text):
    # Split prose and bullet lines alike into quotable units.
    parts = re.split(r"(?<=[.!?])\s+|\n+", text)
    return [p.strip(" -*\t") for p in parts if p.strip()]


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": ["perplexity"]},
        headers={"Authorization": f"Bearer {KEY}"},
        timeout=200,  # the API waits up to 180s for live surfaces
    )
    resp.raise_for_status()

    for answer in resp.json()["answers"]:
        if answer.get("status") == "failed":
            print(f"{query!r}: no record this run")
            continue

        text = answer.get("answerText") or ""
        hits = [s for s in sentences(text) if MENTION.search(s)]

        print(f"\n{query!r}")
        for line in hits:
            print(f"  says: {line}")
        if not hits:
            print("  not named at all")

        # Perplexity searched before it wrote. These are the pages it read.
        sources = sorted(answer.get("sources") or [], key=lambda s: s["position"])
        print(f"  written from ({len(sources)} source(s)):")
        for src in sources:
            print(f"    {src['position']:>2}. {host(src['url'])} - {src['url']}")

The output isn't a score, it's evidence: for each buying query, the exact sentences Perplexity wrote about you and the ranked list of pages it wrote them from. Four queries against one surface is four delivered records — four credits, with failed records costing nothing. An ag_test_ key returns labelled demo records at zero credits while you shape the parser.

Read the two columns together and the fix usually names itself:

Let your agent do it

This job suits an agent better than a script, because the interesting step is the second one: fetch the answer, then go read the page that produced it. One command connects the server:

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

That's the install: agentgeo-mcp over stdio, zero npm dependencies, Node.js 18+, and a single tool called fetch_raw_answers. From there you describe the task rather than implement it:

Fetch Perplexity's answer for "best expense management software for a 50-person company". Quote the sentence that mentions Acme, then open the source it most likely came from and tell me whether that page actually says it.

Notice where the judgment sits. AgentGEO hands back the record and stops; your agent — which knows your positioning, your pricing and what you'd consider a fair description — decides what counts as a recommendation and whether the cited page needs correcting or out-writing. That split is the whole argument for a data layer rather than a dashboard.

Common problems

Five things that will make this check lie to you, in rough order of how often they do:

• Substring matching over-reports. A bare "acme" in text also fires on "AcmeBank", "Acme Freight" and the phrase "the acme of design". Use a word-boundary regex and keep an explicit ignore list for the namesakes you already know live in your category.
• Branded queries flatter you. "Acme alternatives" contains your name, so it will almost always produce a mention — the query guaranteed it. Keep branded and unbranded queries in separate buckets, or you'll report a mention rate that mostly reflects your own query set.
• One run is not a verdict. Perplexity re-searches on every ask, so a mention that disappears once has probably not disappeared. Re-fetch two or three times before you tell anyone the framing got worse.
• The cited page is a lead, not proof. The model paraphrases and merges several sources, so the sentence about you may be assembled from two of them rather than lifted from one. Treat the citation list as where to start reading, not as a citation in the academic sense.
• Slow scrapes come back failed. Requests wait up to 180 seconds; a scrape that runs longer returns status: "failed" at zero credits with a providerFields.snapshot_id. Retry with that id and the same single surface to redeem the finished answer instead of paying to re-scrape it.

Summary

For a one-off answer to "does Perplexity recommend us?", ask it yourself and read the sentence. When the question has to be asked every month, across the queries that actually drive revenue, and answered with quotes instead of impressions — fetch the records, keep the sentences, and keep the sources next to them. The sentence tells you how you're described; the citation tells you which page to go and fix.