How to check if ChatGPT recommends your product

To check whether ChatGPT recommends your product, ask it the questions a buyer asks at the moment of choosing — "best X for Y", "X alternatives", "X vs Y" — and see whether your name appears in the answer. Then do the part that actually decides the outcome: read the sentence around the mention. Being listed is not being recommended, and the difference lives in that one sentence, not in a boolean.

The manual way (and why it stops working)

Open ChatGPT and ask like a buyer, not like a marketer. "Best CRM for small business." "Acme alternatives." "Is Acme worth it for a ten-person sales team?" Read the whole answer, find your name, and read the sentence it sits in — that sentence is the actual result. Do it for the five or six phrasings that matter most to your pipeline and you'll know roughly where you stand today, for free, in about ten minutes.

Then the ceiling arrives, and it arrives quickly:

• Buying intent fans out. "Best", "cheapest", "alternatives to", "X vs Y", "for [segment]", "for [use case]" — each is a different answer with a different shortlist. Covering that by hand is a morning you'll need to repeat every month.
• The answers wobble. The same prompt on Tuesday and on Thursday can produce a different shortlist and a different framing of you. One reading can't distinguish a real slip from ordinary variation.
• You'll read yourself into a conclusion. Scanning prose for your own name, it's genuinely easy to file "also worth a look" under win. Extracting the sentence and judging it deliberately is a different exercise from skimming for a highlight.
• Nothing is stored. In two months you'll want to know whether the framing improved after you rewrote the pricing page. Chat history is not a dataset.
• It doesn't fit a workflow. No alert when a competitor takes your slot in the shortlist, no row in the board deck, no check that runs before a positioning change ships.

Do it with one API call

One POST to AgentGEO returns the raw record for that query: the full answer text and every source cited, structured. No headless browser, no selectors to maintain — 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", "surfaces": ["chatgpt"]}'

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 — you get the framing, quoted, ready to read or to judge:

import re
import requests

KEY = "ag_live_your_key_here"
BRAND = "Acme"

# Buying intent, not brand awareness — these are the queries that decide deals.
QUERIES = [
    "best CRM for small business",
    "Acme alternatives",
    "Acme vs Globex for a 10-person sales team",
    "cheapest CRM with email integration",
]

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


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


for query in QUERIES:
    resp = requests.post(
        "https://api.agentgeo.org/v1/fetches",
        json={"query": query, "surfaces": ["chatgpt"]},
        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} — {len(hits)} mention(s) of {BRAND}")
        for s in hits:
            print(f"   {s}")
        if not hits:
            print("   not named at all")

The output isn't a score, it's evidence: for each buying query, the exact sentences ChatGPT wrote about you. Four queries against one surface is four delivered records — four credits, with failed records costing nothing. While you're building the script, an ag_test_ key returns clearly labelled demo records at zero credits so you can shape the parser before spending anything.

Let your agent do it

If you'd rather not write the parser at all, hand the whole job to an agent — it can fetch the answers and read the framing in the same turn. The MCP server is one command away:

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+, one tool called fetch_raw_answers. From there the ask is just the task in plain language:

• "Fetch ChatGPT's answer for 'best CRM for small business'. Quote the sentence that mentions Acme and tell me honestly whether that reads as a recommendation."
• "Run our four buying-intent queries through ChatGPT and rank them by how favourably Acme is described."
• "Pull 'Acme alternatives' from ChatGPT. If a competitor is described more warmly than us, find the source page behind it and draft the page that would answer it."

Notice where the judgment sits. AgentGEO returns answerText and nothing more; your agent — which knows your positioning, your pricing and what you'd consider a fair description — decides what counts as a recommendation. That split is deliberate, and it's 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 know exist in your category.
• "Best" and "top" are different queries. They pull different shortlists and different framings. Freeze the query set that mirrors how your buyers actually phrase it, then hold it steady — a casual rewording quietly invalidates every comparison to last month.
• One run is not a verdict. Answers vary between identical calls, so a mention that disappears once has probably not disappeared. Re-fetch two or three times before you act, especially before you tell anyone the framing got worse.
• Named in the prose is not cited as a source. If your brand appears in answerText but your domain is nowhere in sources[], the model is describing you without reading you today — so the description is coming from elsewhere. That's a positioning problem with a different fix from a content gap.
• Some chatbot fetches exceed the sync budget. 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 ChatGPT 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 rather than impressions — fetch the answers through the API or let an agent do it, keep the sentences, and judge the framing with a rubric you wrote down.