How to Check Whether ChatGPT Recommends Your Brand

A prospect says they found you through ChatGPT. Another says it recommended your competitor. You try “best CRM for small business” yourself, see your brand near the top, and wonder which result to trust.

Neither answer tells you how often buyers see you. To measure that, you need the same buyer questions asked several times, from the countries you sell in, without your account history influencing the answers.

This guide shows you how to collect those answers, count brand mentions, and inspect the sites ChatGPT cites.

Why Your Own ChatGPT Check Is Misleading

Three things make a quick manual check unreliable:

• Your account can influence the answer. ChatGPT can use saved memory and past chats. If you regularly discuss your product, your answer may not resemble a new buyer’s answer. Temporary Chat switches memory off, but it does not solve the next two problems.
• One answer tells you only what can happen. The same question can include your brand once and leave it out next time. You need repeated answers to measure how often you appear.
• Your location matters. Someone asking for accounting software in the UK can get a different list from someone in the US.

You might consider using the OpenAI API, an interface that lets software send questions directly to a model. But that measures a different experience. It does not reproduce the ChatGPT app’s own instructions, and web search only runs when you enable it. Its answers and sources are not necessarily what buyers see on chatgpt.com.

For this check, measure what a fresh, signed-out visitor sees in each market. Repeat each question so you are not judging your visibility from one answer.

Step 1: Write Questions Your Buyers Actually Ask

Start with questions that do not mention your brand. Asking whether Pipedrive is good checks an existing interest in Pipedrive. It does not tell you whether someone who has never heard of it would discover it.

Build your prompt set, meaning the questions you will submit, around four types:

Type	Example
Category	best CRM software for small business
Situation	what CRM should a 5 person sales team use
Alternative	cheaper alternatives to HubSpot
Problem	how do I stop losing track of leads in spreadsheets

CRM means customer relationship management software: a tool for keeping track of prospects, customers, and sales conversations.

Use wording from sales call notes, support tickets, Google Search Console queries, and Reddit recommendation threads. A set of 10 to 30 prompts is workable.

Keep that set fixed. If you change the questions every week, you cannot tell whether your visibility changed or your wording caused a different answer.

For markets that do not speak English, write questions in the local language. An English question submitted from Germany is not the same test as a German buyer asking in German.

Step 2: Repeat Each Question While Signed Out

The ScrapeUnblocker ChatGPT plugin collects the answers. Each request opens a fresh signed-out session on chatgpt.com. You can choose a country, and the plugin waits until ChatGPT finishes before returning the result.

You do not need an OpenAI account. The following request submits a question and returns JSON, a structured text format that your script can read:

curl -X POST "https://api.scrapeunblocker.com/ai/chatgpt?prompt=best%20CRM%20software%20for%20small%20business&country=US" \
  -H "x-scrapeunblocker-key: YOUR_API_KEY" \
  --max-time 300

Here is a shortened response showing the fields you will use to measure mentions and inspect sources:

{
  "country": "US",
  "prompt": "best CRM software for small business",
  "answer": "For most small businesses, HubSpot, Zoho CRM, and Pipedrive are my top three recommendations in 2026...",
  "citations": [
    { "position": 1, "siteName": "G2", "domain": "g2.com", "moreSources": 2, "citedText": "..." }
  ],
  "links": [
    { "position": 1, "title": "HubSpot website", "url": "https://www.hubspot.com/products/crm", "domain": "hubspot.com" }
  ],
  "sources": [
    { "position": 1, "siteName": "G2", "domain": "g2.com" },
    { "position": 2, "siteName": null, "domain": "hubspot.com" }
  ],
  "webSearch": true
}

These fields serve different purposes:

• citations contains the source pills ChatGPT attaches to claims.
• links contains links included in the answer text.
• sources combines sites from those two lists without repeating them.
• webSearch tells you whether ChatGPT searched the web for that answer.

Save webSearch along with the answer. You will need it to interpret the sources in Step 4.

A request takes 15 to 60 seconds because the plugin waits for the finished answer. Set your HTTP timeout, the time your software will wait before giving up, to 300 seconds.

Step 3: Collect and Score the Answers

The script below asks each question five times from two countries. It checks which brands appear, records their order, and saves a CSV file you can open in a spreadsheet. Pipedrive is the example brand; replace it with yours.

It uses ScrapeUnblocker’s official Python package, a ready-made library for sending requests. Install it with pip install scrapeunblocker. You need version 0.17.0 or later for the chatgpt method. The package reads your API key, the credential that authorizes requests, from the SCRAPEUNBLOCKER_KEY environment variable.

import asyncio
import csv
import re
from collections import Counter, defaultdict

from scrapeunblocker import AsyncClient, ScrapeUnblockerError

BRAND = "Pipedrive"
OUR_DOMAIN = "pipedrive.com"
NAMES = {  # every brand you want to rank, with the spellings ChatGPT uses
    "Pipedrive": [r"pipedrive"],
    "HubSpot": [r"hubspot"],
    "Zoho CRM": [r"zoho"],
    "Salesforce": [r"salesforce"],
}
PROMPTS = [
    "best CRM software for small business",
    "what CRM should a 5 person sales team use",
    "cheaper alternatives to HubSpot",
    "simple CRM for a B2B startup",
]
COUNTRIES = ["US", "GB"]
SAMPLES = 5


def first_hit(text, patterns):
    hits = [m.start() for p in patterns for m in re.finditer(rf"\b{p}\b", text, re.I)]
    return min(hits) if hits else None


def brand_rank(text):
    found = sorted(
        (pos, name)
        for name, patterns in NAMES.items()
        if (pos := first_hit(text, patterns)) is not None
    )
    order = [name for _, name in found]
    return order.index(BRAND) + 1 if BRAND in order else None


def is_ours(domain):
    return domain == OUR_DOMAIN or domain.endswith("." + OUR_DOMAIN)


async def ask(su, sem, prompt, country):
    row = {"prompt": prompt, "country": country, "error": "",
           "web_search": "", "rank": "", "cited_us": "", "domains": ""}
    async with sem:
        try:
            r = await su.chatgpt(prompt, country=country)
        except ScrapeUnblockerError as e:
            row["error"] = type(e).__name__
            return row
    domains = sorted({s["domain"] for s in r["sources"]})
    row.update(
        web_search=r["webSearch"],
        rank=brand_rank(r["answer"]) or "",
        cited_us=any(is_ours(d) for d in domains),
        domains=" ".join(domains),
    )
    return row


async def main():
    sem = asyncio.Semaphore(5)
    async with AsyncClient(timeout=300) as su:
        rows = await asyncio.gather(*(
            ask(su, sem, p, c)
            for p in PROMPTS for c in COUNTRIES for _ in range(SAMPLES)
        ))
    with open("chatgpt_visibility.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=rows[0].keys())
        writer.writeheader()
        writer.writerows(rows)
    return rows


rows = asyncio.run(main())

groups = defaultdict(list)
for row in rows:
    if not row["error"]:
        groups[(row["country"], row["prompt"])].append(row)

for (country, prompt), runs in groups.items():
    named = [r["rank"] for r in runs if r["rank"]]
    cited = sum(1 for r in runs if r["cited_us"])
    print(f"{country} | {prompt}: named {len(named)}/{len(runs)}, "
          f"best rank {min(named, default='-')}, cited {cited}/{len(runs)}")

searched = Counter(
    d for r in rows if r["web_search"] is True for d in r["domains"].split()
)
print(searched.most_common(15))

Before relying on the scores, check three details:

Check How Brand Names Match

The script uses \b...\b to look for whole words and re.I to ignore capitalization. That prevents a brand name from matching letters inside a longer word.

It does not resolve every ambiguity. For example, the ordinary word “notion” can still look like a mention of Notion. Read a few raw answers to check the matches and find any alternative brand spellings you need to add to NAMES, the script’s brand list.

Treat Rank As Relative to Your Brand List

The script orders brands by where each is first mentioned, counting only brands in NAMES.

Rank 2 therefore means one other tracked brand appeared first. It does not necessarily mean your brand was second in ChatGPT’s recommendation list.

Include Your Subdomains

A source may be listed as legal.hubspot.com rather than hubspot.com. The first is a subdomain, a separate address under the main domain.

The script’s is_ours() check includes subdomains. An exact-match check against only the main domain would miss them.

The example run makes 40 requests: 4 prompts x 2 countries x 5 answers. It runs five requests at a time. Keep the semaphore, the setting that controls how many requests run together, within your plan’s concurrency limit.

The Python package retries busy 503 responses automatically. A 503 is not billed.

Step 4: Look at Sources, Not Just Mentions

Your mention rate is the share of answers that name your brand. “Named in 2 of 5 US answers and 0 of 5 UK answers” is more useful than “I saw us in ChatGPT.”

To investigate why you appear or do not appear, separate the results using webSearch.

When webSearch Is true

ChatGPT searched the web before answering. The domains in sources show the sites returned with that answer.

Look for sites that appear repeatedly. If g2.com and two “best of” articles keep appearing, check whether your brand is represented on those sites. You might find an incomplete review profile, a comparison that excludes you, or an outdated roundup.

Those are specific places to investigate. Getting included on pages ChatGPT uses can be a faster lever than rewriting your homepage.

When webSearch Is false

ChatGPT answered without a web search, using what the model learned during training. Do not expect something you publish this week to change those answers quickly.

Keep tracking these prompts, but separate them from searched answers when deciding where to focus your work.

The script ends with a Counter, which tallies how often each source domain appears in searched answers. Use that list to find the sites that recur across your buyer questions. For many categories, this short list is the most useful output of the whole exercise: it shows which sites ChatGPT reads when your buyers ask.

What This Method Does Not Measure

Keep these limits alongside your results:

• Signed-in experiences. A signed-in user with memory enabled, and possibly a different model, can get another answer. Your signed-out results are a baseline, not a complete view of every buyer.
• Every exact source page. Signed-out ChatGPT reveals a citation’s full page URL only when you hover over it. The citation data therefore gives you the site and domain, not the exact page. Links written into the answer text do include their full url.
• The model that answered. The model field is always null, meaning no value is available, because signed-out ChatGPT does not display it. If results shift overnight, a model change on OpenAI’s side is one possible cause you cannot verify from this data.

Run the Same Check on Gemini and Google AI Mode

You can submit the same question set through the Gemini and Google AI Mode plugins. Both return answers and cited pages, so you can compare brand visibility across all three services.

Their response formats differ. For example, Gemini citations include page URLs. Adjust ask(), the function that sends a question and reads the response, for each plugin rather than assuming the ChatGPT fields will work unchanged.

FAQ

How often should I run the check?

Weekly is a reasonable starting point. Compare several runs rather than reacting to one result. Keep the questions and number of answers per question the same so the runs remain comparable.

How many samples per prompt do I need?

Start with five answers per question and country to distinguish “always named,” “sometimes named,” and “never named” in that set. Collect more answers if you want to detect smaller changes. Each answer is one request, so collecting more increases cost in direct proportion.

Does this need an OpenAI account or API key?

No. The plugin uses signed-out ChatGPT sessions. You only need a ScrapeUnblocker API key.

Why does ChatGPT give different answers to the same question?

Each request starts a new conversation. ChatGPT generates a fresh answer and may run another web search. People asking the same question can get different answers too, which is why repeated samples are more useful than one check.

Try Your First Question Set

Take ten questions from last month’s sales calls and support tickets. Run them from your main market, then inspect the source-domain list and check whether your brand appears on those sites.

If you want to test one question before using the script, try it in the ScrapeUnblocker dashboard. Each answer is billed as one request. The ChatGPT plugin docs include the full response field list and request examples for Node.js, PHP, and Ruby.