# AI Visibility Tracker: ChatGPT, Perplexity, Gemini (`reliable_tools/ai-visibility-tracker`) Actor

Track if ChatGPT, Perplexity and Gemini mention and recommend your brand: answer text, cited URLs, rank, sentiment and competitors, via official APIs.

- **URL**: https://apify.com/reliable_tools/ai-visibility-tracker.md
- **Developed by:** [Reliable Tools](https://apify.com/reliable_tools) (community)
- **Categories:** SEO tools, AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.50 / 1,000 prompt analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Visibility Tracker: Brand Mentions in ChatGPT, Perplexity, Gemini

This AI visibility tracker shows what ChatGPT, Perplexity and Google Gemini answer when shoppers ask the questions that matter to your brand, and whether your brand makes the list. You give it your brand, your competitors and a few shopping prompts. It asks each assistant through its official API with your own keys and labels every answer: mentioned or not, recommended or not, rank among the products named, tone, cited URLs and the competitors that showed up instead. Run it on a schedule to see your AI share of voice change over time.

### Who it's for

- Brand and ecommerce teams who want to know if AI assistants recommend them
- SEO and content people working on "AI search" or "generative engine" visibility
- Agencies that report brand share of voice across AI answers for clients
- Founders checking how their product is described next to competitors

### What you get

One row per prompt and engine.

| Field | What it means |
|---|---|
| `prompt`, `engine`, `model` | The question, the engine (chatgpt, perplexity, gemini) and the exact model that answered |
| `answer` | The full answer text |
| `citedUrls`, `citedDomains` | The sources the engine cited (ChatGPT and Perplexity; Gemini runs without web search and returns none) |
| `brandSiteCited` | True if a page from your own domain was cited |
| `brandMentioned` + probability | Does the answer mention your brand or its products |
| `brandRecommended` + probability | Does the answer recommend your brand as a good choice |
| `brandRank` | Position of your brand among the products the answer names (1 = first), empty if not listed |
| `productsNamed`, `rankedProducts` | All products and brands the answer offers, in order |
| `sentiment` + confidence | positive, neutral, mixed or negative tone toward your brand |
| `competitorsMentioned` | Which of your competitors appear, with their rank |
| `error` | Why a row has no answer (bad key, engine error). These rows are free |

### How to run it

1. Enter your **brand**, optionally its website domain and other product line names.
2. Add your **competitors**.
3. Write your own **prompts**, or pick **templates** like "Best {category} under {price}", "{brand} vs {competitor}" or "Alternatives to {brand}" and fill in category and price.
4. Add at least one **API key**: OpenAI, Perplexity or Gemini. Each key you add turns on that engine.
5. Set the **country** (2-letter code) so answers fit the market you sell in.
6. Start the run. A few prompts finish in well under a minute.

#### Why your own API keys?

The answers come straight from the official APIs, billed by OpenAI, Perplexity or Google to your account. That keeps the price per result low and means nothing is scraped from a chat website. Keys are secret inputs: Apify stores them encrypted and the Actor only uses them to send your prompts.

The default models are the providers' fast, low-cost ones. ChatGPT and Perplexity answer with web search, and those search calls are billed by the provider too, so check their pricing page for current rates.

Gemini is queried without Google Search grounding, so its answers come from the model's own knowledge and include no cited links. Google's terms for Grounding with Google Search do not allow storing or analysing grounded results, so this Actor never uses that feature. If you are in the EU, EEA, Switzerland or UK, Google requires a paid-tier Gemini API key.

### Example output

Real result from a test run (answer and lists shortened):

```json
{
  "prompt": "What are the best alternatives to Allbirds?",
  "engine": "chatgpt",
  "model": "gpt-5.4-mini-2026-03-17",
  "country": "US",
  "answer": "If you like Allbirds for their comfort, minimalist style, and eco-friendlier materials, the best alternatives depend on what you want to optimize for: ...",
  "citedDomains": ["wired.com", "goodhousekeeping.com", "gearpatrol.com"],
  "brandSiteCited": false,
  "brandMentioned": true,
  "brandMentionedProbability": 0.99,
  "brandRecommended": false,
  "brandRecommendedProbability": 0.14,
  "brandRank": null,
  "productsNamed": 11,
  "sentiment": "positive",
  "sentimentConfidence": 0.91,
  "competitorsMentioned": [
    {"name": "Hoka", "rank": 5, "probability": 0.99},
    {"name": "Brooks", "rank": 6, "probability": 0.99}
  ],
  "rankedProducts": [
    {"rank": 1, "name": "Everlane Court Sneaker / Tread", "isYourBrand": false},
    {"rank": 2, "name": "Veja", "isYourBrand": false},
    {"rank": 3, "name": "Adidas Stan Smith / Clean Court styles", "isYourBrand": false},
    {"rank": 4, "name": "Ecco", "isYourBrand": false}
  ]
}
```

### How to use the AI visibility tracker via API

You can run the AI visibility tracker in the Apify Console, or call it from your own code through the Apify API. The **API** tab of this Actor has ready-to-copy examples for the JavaScript and Python API clients, the Apify CLI, plain HTTP and the OpenAPI definition. To use it from an AI assistant or agent, connect the Apify MCP server and add this Actor as a tool.

Send the same JSON input you would fill in the form, for example your brand, your competitors, your prompts and your API keys, start a run, and read the results from the run's default dataset as JSON, CSV or Excel. You can also schedule runs in Apify.

### Pricing

You pay per **prompt analyzed**: one prompt answered by one engine and fully labeled. Three prompts on two engines are six results. Rows that fail (wrong key, engine error, empty answer) are not charged. The API usage itself is billed by the AI provider on your own key.

### Tips

- Use the questions your customers really ask. "Best {category} under {price}" and "alternatives to {brand}" are good starting points.
- Run the same prompt set every week and compare `brandMentioned` and `brandRank` over time. AI answers change often, so one run is a snapshot, not a verdict.
- Add short product line names to "Other names for your brand" so a mention like "Tree Runner" counts.
- Short brand names (3 letters or less) are matched case sensitive, so "On" the brand is not confused with the word "on".
- `brandRank` counts distinct products in the order the answer lists them. For "{brand} vs {competitor}" prompts your brand is part of the question, so read `brandRecommended` and `sentiment` rather than rank.

### FAQ

**Does this scrape ChatGPT or other chat websites?**
No. It only uses the official APIs of OpenAI, Perplexity and Google. ChatGPT and Perplexity use their built-in web search. Gemini answers from model knowledge without web search.

**Is it legal?**
The Actor sends your prompts to the providers' public APIs under your own API account, so their API terms apply to you as the key owner. It does not target personal data, although AI answers can name people such as founders. Please check the providers' terms for your use case.

**Are the answers the same as in the ChatGPT or Gemini app?**
Not exactly. Apps can use different models, personalization and settings than the API. The API is the closest repeatable view, and it is the same for everyone who runs the same prompt. Gemini answers here come without web search, so they can differ more from the Gemini app.

**How are mentions and recommendations decided?**
Exact name matches count first. On top of that an AI check reads each answer and returns a probability for each label, which is included in the output so you can set your own cut-off.

**Which models are used?**
By default a fast, low-cost model per provider. You can choose another model in the Advanced section. For ChatGPT it must support the web search tool.

**What if I only have one API key?**
That works. Only the engines you added a key for are queried.

**How do I check if ChatGPT mentions my brand?**
Enter your brand, a few prompts your customers would ask, and your OpenAI API key. Each answer comes back with `brandMentioned`, `brandRecommended` and `brandRank`, each with a probability or position.

**How do I track AI search visibility over time?**
Run the same prompt set on a schedule, for example every week, and compare `brandMentioned` and `brandRank` between runs. AI answers change often, so one run is a snapshot.

### Disclaimer

This Actor is not affiliated with, endorsed or sponsored by OpenAI, Perplexity or Google. ChatGPT, Perplexity and Gemini are trademarks of their owners and are named only to describe which services the Actor queries with your own API keys.

### About Reliable Tools

Reliable Tools builds Apify Actors that do one job well and keep working. See all our Actors at [apify.com/reliable_tools](https://apify.com/reliable_tools).

# Actor input Schema

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

The brand (or product) to track, e.g. Allbirds.

## `brandAliases` (type: `array`):

Product line names or spellings that should also count as your brand, e.g. Tree Runner.

## `brandDomain` (type: `string`):

Optional. If set, each result tells you whether the AI answer cited a page from this domain.

## `competitors` (type: `array`):

Competitor brands to watch for in the answers. Also used by the "vs" template (first 5).

## `prompts` (type: `array`):

Questions a shopper might ask an AI assistant. Each prompt is sent to every engine you added a key for.

## `templates` (type: `array`):

Ready-made shopping prompts filled with your brand, category, price and competitors.

## `category` (type: `string`):

Used by the templates, e.g. running shoes, standing desks, protein powder.

## `price` (type: `string`):

Used by the "under {price}" template, e.g. $150 or 100 EUR.

## `useCase` (type: `string`):

Used by the "best for" template, e.g. flat feet, walking all day.

## `country` (type: `string`):

Where the shopper is, e.g. US, GB, DE. Sent to the engines as the user location.

## `language` (type: `string`):

Leave empty or English for English answers. Any other value asks the engines to answer in that language.

## `openaiApiKey` (type: `string`):

Your own OpenAI key. Stored encrypted, only used in this run, billed by OpenAI to your account.

## `perplexityApiKey` (type: `string`):

Your own Perplexity key. Stored encrypted, only used in this run.

## `geminiApiKey` (type: `string`):

Your own key from Google AI Studio. Gemini answers from its model knowledge without Google Search, so it returns no cited links. Users in the EU, EEA, Switzerland or UK must use a paid-tier key. Stored encrypted, only used in this run.

## `openaiModel` (type: `string`):

Any OpenAI model that supports the web search tool.

## `perplexityModel` (type: `string`):

e.g. sonar or sonar-pro.

## `geminiModel` (type: `string`):

Any Gemini model that supports generateContent. Runs without Google Search grounding.

## `maxPrompts` (type: `integer`):

Safety cap on the number of prompts per run (each prompt runs once per engine).

## Actor input object example

```json
{
  "brand": "Allbirds",
  "brandDomain": "allbirds.com",
  "competitors": [
    "Hoka",
    "Brooks"
  ],
  "templates": [
    "best_under_price"
  ],
  "category": "running shoes",
  "price": "$150",
  "country": "US",
  "openaiModel": "gpt-5.4-mini",
  "perplexityModel": "sonar",
  "geminiModel": "gemini-flash-latest",
  "maxPrompts": 50
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with one row per prompt x engine.

# 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": "Allbirds",
    "brandDomain": "allbirds.com",
    "competitors": [
        "Hoka",
        "Brooks"
    ],
    "templates": [
        "best_under_price"
    ],
    "category": "running shoes",
    "price": "$150"
};

// Run the Actor and wait for it to finish
const run = await client.actor("reliable_tools/ai-visibility-tracker").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": "Allbirds",
    "brandDomain": "allbirds.com",
    "competitors": [
        "Hoka",
        "Brooks",
    ],
    "templates": ["best_under_price"],
    "category": "running shoes",
    "price": "$150",
}

# Run the Actor and wait for it to finish
run = client.actor("reliable_tools/ai-visibility-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": "Allbirds",
  "brandDomain": "allbirds.com",
  "competitors": [
    "Hoka",
    "Brooks"
  ],
  "templates": [
    "best_under_price"
  ],
  "category": "running shoes",
  "price": "$150"
}' |
apify call reliable_tools/ai-visibility-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reliable_tools/ai-visibility-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0ram9A5HNQKN7FE9y/builds/06iuFtIedlBXtlujx/openapi.json