# ChatGPT Brand Mentions Checker (`nikhonit/chatgpt-brand-mentions-checker`) Actor

Check if ChatGPT mentions or recommends your brand for the queries your customers ask. Returns mentioned/not, rank, context, and cited sources per query.

- **URL**: https://apify.com/nikhonit/chatgpt-brand-mentions-checker.md
- **Developed by:** [Nikhil Kumar](https://apify.com/nikhonit) (community)
- **Categories:** AI, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / fresh chatgpt check (api)

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ChatGPT Brand Mentions Checker

### What does ChatGPT Brand Mentions Checker do?

**Check whether ChatGPT mentions or recommends your brand** when people ask it the questions your customers actually type. Paste your brand name and a list of queries (e.g. *"best CRM for small business"*), and for each query this Actor returns:

- **Mentioned or not** — does your brand appear in ChatGPT's answer?
- **Rank** — where your brand sits among the recommendations
- **Context** — the exact sentence ChatGPT used around your brand
- **Citations** — the sources ChatGPT relied on (the pages you need to be on)

No ChatGPT account, no OpenAI API key, no setup. Runs on the Apify platform, so you get scheduling, an API endpoint, webhooks, and export to JSON, CSV, or Excel out of the box.

### Why check your brand's visibility in ChatGPT?

More buying research now starts in AI chat instead of Google. If ChatGPT recommends your competitor and not you, you're invisible at the exact moment of decision — and traditional SEO tools can't see it. This is the core measurement of **Generative Engine Optimization (GEO)** / **Answer Engine Optimization (AEO)**:

- Track whether ChatGPT recommends you for your money keywords
- See which sources ChatGPT cites, so you know where to earn coverage
- Monitor movements after content or PR pushes (schedule daily/weekly runs)
- Report AI visibility to clients if you're an SEO or PR agency

### How to use it

1. Enter your **brand name** (e.g. `Notion`).
2. Add **queries** — the questions your buyers ask ChatGPT, one per line.
3. Optionally turn on **live ChatGPT UI** to check the real chat interface (ground truth, including ChatGPT's fan-out searches) instead of the API.
4. Click **Start** and read the results table, or export it.

### Input example

```json
{
    "brand": "Notion",
    "queries": ["best note taking app for teams", "Notion alternatives"],
    "liveUi": false
}
````

### Output example

```json
{
    "query": "best note taking app for teams",
    "brand": "Notion",
    "surface": "chatgpt",
    "mentioned": true,
    "rank": 2,
    "context": "Notion is a strong pick for teams that want docs, wikis and tasks in one place...",
    "citations": [{ "url": "https://example.com/best-note-apps", "title": "12 Best Note Apps" }],
    "cached": false,
    "checkedAt": "2026-07-12T10:15:00.000Z"
}
```

You can download the dataset in JSON, CSV, Excel, or HTML, or fetch it via the Apify API.

### How much does it cost?

You pay **per checked query** — no subscription, no monthly minimum, and failed checks are never charged:

| Event | What it covers |
| --- | --- |
| Fresh API check | One query answered fresh by ChatGPT |
| Cached check | Same query checked recently — much cheaper |
| Live UI check | One query against the real ChatGPT interface |

Repeated tracking of the same queries is cheap because of caching.

### Tips

- Start with 10–20 queries that map to real buying intent, not vanity keywords.
- Schedule a weekly run and diff the `mentioned`/`rank` columns to catch drops early.
- Use **live UI mode** for reports where you need to show exactly what a user sees.
- Checking competitors is the same input with a different `brand` — run it once per competitor and compare mention rates.

### FAQ

**Does this use my ChatGPT account?** No. Checks run through MentionsAPI's infrastructure; you don't need any account or API key.

**Is this legal?** The Actor queries AI assistants the same way a user would and stores only the answers about the brands you ask for.

**Can I check Claude, Gemini, Perplexity, or Google AI Overviews too?** Yes — use the companion Actors: **AI Visibility Tracker** (all four LLMs + live surfaces) and **Google AI Overviews Brand Tracker**.

**Need this as a raw API instead?** The same engine is available at [mentionsapi.com](https://mentionsapi.com) for direct integration.

Found a problem or want a feature? Open an issue on the **Issues** tab.

# Actor input Schema

## `brand` (type: `string`):

The brand, product, or company name to look for in ChatGPT's answers (matched case-insensitively).

## `queries` (type: `array`):

The questions your potential customers ask ChatGPT — one per line. Example: "best note taking app for teams".

## `liveUi` (type: `boolean`):

When on, checks the real ChatGPT web interface instead of the API — slower and pricier, but shows exactly what users see, including fan-out queries.

## `region` (type: `string`):

Optional ISO country code (e.g. "us", "gb", "de") to localize the check.

## Actor input object example

```json
{
  "brand": "Notion",
  "queries": [
    "best note taking app for teams",
    "Notion alternatives"
  ],
  "liveUi": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "brand": "Notion",
    "queries": [
        "best note taking app for teams",
        "Notion alternatives"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nikhonit/chatgpt-brand-mentions-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "brand": "Notion",
    "queries": [
        "best note taking app for teams",
        "Notion alternatives",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("nikhonit/chatgpt-brand-mentions-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "brand": "Notion",
  "queries": [
    "best note taking app for teams",
    "Notion alternatives"
  ]
}' |
apify call nikhonit/chatgpt-brand-mentions-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nikhonit/chatgpt-brand-mentions-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ChatGPT Brand Mentions Checker",
        "description": "Check if ChatGPT mentions or recommends your brand for the queries your customers ask. Returns mentioned/not, rank, context, and cited sources per query.",
        "version": "0.1",
        "x-build-id": "iWo7L2hSgRFvjPxce"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nikhonit~chatgpt-brand-mentions-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nikhonit-chatgpt-brand-mentions-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nikhonit~chatgpt-brand-mentions-checker/runs": {
            "post": {
                "operationId": "runs-sync-nikhonit-chatgpt-brand-mentions-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nikhonit~chatgpt-brand-mentions-checker/run-sync": {
            "post": {
                "operationId": "run-sync-nikhonit-chatgpt-brand-mentions-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "brand",
                    "queries"
                ],
                "properties": {
                    "brand": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "The brand, product, or company name to look for in ChatGPT's answers (matched case-insensitively)."
                    },
                    "queries": {
                        "title": "Queries to check",
                        "type": "array",
                        "description": "The questions your potential customers ask ChatGPT — one per line. Example: \"best note taking app for teams\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "liveUi": {
                        "title": "Use live ChatGPT UI (ground truth)",
                        "type": "boolean",
                        "description": "When on, checks the real ChatGPT web interface instead of the API — slower and pricier, but shows exactly what users see, including fan-out queries.",
                        "default": false
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Optional ISO country code (e.g. \"us\", \"gb\", \"de\") to localize the check."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
