# AI Visibility Tracker — ChatGPT, Perplexity, Gemini & Claude (`samstorm/ai-visibility-tracker`) Actor

Monitor brand visibility across ChatGPT, Perplexity, Gemini, and Claude in one run. Track mentions, citations, and share of voice in AI search answers (GEO/AEO). Bring your own free API keys — you control engine costs.

- **URL**: https://apify.com/samstorm/ai-visibility-tracker.md
- **Developed by:** [Sam Kleespies](https://apify.com/samstorm) (community)
- **Categories:** SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 visibility checks

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## AI Visibility Tracker — ChatGPT, Perplexity, Gemini & Claude

**Know exactly where your brand stands across every major AI search engine.** This actor queries ChatGPT, Perplexity, Gemini, and Claude with your chosen prompts, detects brand mentions, measures share of voice across source citations, and outputs structured per-engine data ready for dashboards, spreadsheets, or CRM workflows.

Built for SEO agencies, brand managers, and CMOs who need to measure and improve **AI search visibility** — also called GEO (Generative Engine Optimization) or Answer Engine Optimization (AEO).

> **Quick start:** select your engines, paste the matching API keys (free tiers available — links below), add your brands and prompts, and run. You stay in full control of your API usage and costs.

---

### Why Multi-Engine AI Brand Monitoring Matters

Your customers no longer ask just one engine. When they ask "best CRM for a startup?", ChatGPT, Perplexity, Gemini, and Claude each give a different answer citing different sources — and your visibility can vary wildly between them. Single-engine tools miss that. This actor checks all four in one run and tells you exactly where you're strong and where you're invisible.

---

### What It Does

- Queries up to **four AI engines** (ChatGPT, Perplexity, Gemini, Claude) with your prompts, using each engine's native web search / grounding
- Detects brand mentions in answers and measures **share of voice** as a percentage of source citations — per engine
- Records citation position, mention count, and answer snippets so you know exactly how each engine presents your brand
- Compare engines side-by-side: the `engine` column makes pivot tables trivial in Sheets, Airtable, Power BI, or Looker Studio

---

### Why Use This Instead of Dedicated Tools

| Tool | Starting Price |
|-|-|
| Otterly.ai | $29–$489/mo |
| Profound | $499/mo |
| Peec AI | $90+/mo |
| This actor | Pay only per check produced |

This actor talks directly to each engine's official API — no browser automation, no scraping, no anti-bot risk. Results are reliable and reproducible. You pay a small per-check fee plus your own API token costs (you control the keys, so you control the spend).

---

### Getting API Keys (only for engines you select)

| Engine | Where to get a key | Free tier? |
|-|-|-|
| ChatGPT | [platform.openai.com/api-keys](https://platform.openai.com/api-keys) | $5 trial credit (new accounts) |
| Perplexity | [perplexity.ai/settings/api](https://www.perplexity.ai/settings/api) | Yes |
| Gemini | [aistudio.google.com/apikey](https://aistudio.google.com/apikey) | Yes — generous free tier |
| Claude | [console.anthropic.com](https://console.anthropic.com) | Trial credit (new accounts) |

Keys are stored as encrypted secrets, never logged or exposed.

---

### How It Works

1. **Validate input** — checks that each selected engine has its API key, plus at least one brand and one prompt
2. **Query each engine** — uses native web search / grounding (OpenAI `web_search`, Perplexity Sonar, Gemini Google Search grounding, Claude `web_search` tool) so answers reflect what real users see
3. **Analyze each answer** — exact-match brand detection with word boundaries, domain matching against cited source URLs
4. **Save structured results** — one dataset row per engine × prompt × brand

#### Input Example

```json
{
  "engines": ["chatgpt", "perplexity", "gemini"],
  "openaiApiKey": "sk-...",
  "perplexityApiKey": "pplx-...",
  "geminiApiKey": "AIza...",
  "brands": ["HubSpot (hubspot.com)", "Salesforce (salesforce.com)"],
  "prompts": ["best CRM for small businesses 2026"],
  "maxPrompts": 10
}
````

#### Output Example

```json
{
  "engine": "chatgpt",
  "prompt": "best CRM for small businesses 2026",
  "brand": "HubSpot",
  "mentioned": true,
  "mentionCount": 3,
  "citedInSources": true,
  "sourcePosition": 2,
  "totalSources": 8,
  "shareOfVoice": 25.0,
  "answerSnippet": "...HubSpot is one of the most popular CRM tools for small businesses, offering a generous free tier...",
  "allSources": ["https://...", "https://hubspot.com/..."],
  "checkedAt": "2026-06-12T10:30:00.000Z"
}
```

***

### Scheduling

Use Apify Schedules to run weekly or daily and build a longitudinal visibility dataset. Recommended cadence: weekly for most brands, daily during launches or campaigns. Track trends rather than single data points — AI answers vary between runs.

***

### Limitations

- **BYO API keys** — each selected engine needs a valid key; engine-level failures are logged and skipped, and the run fails only if every call fails
- **Non-deterministic answers** — the same prompt returns different sources across runs; track trends
- **String-based brand detection** — exact name matching with word boundaries; add abbreviations or alternate spellings as separate brand entries
- **Snapshot only** — captures answers at run time; no historical backfill
- **Domain matching for citations** — citation tracking requires a domain in parentheses; third-party mentions (e.g. a G2 listicle) count toward the citing domain, not your brand

***

### Feedback & Support

Found this actor useful? **A short review on the actor page helps other teams discover it** and keeps it actively maintained. Hit a problem or have a feature request? Open an issue on the Issues tab — issues are typically answered within a day or two.

***

### Related Keywords

AI visibility tracker, ChatGPT brand monitoring, Perplexity brand monitoring, Gemini brand tracking, Claude brand tracking, AI search visibility, brand mentions in AI search, GEO generative engine optimization, answer engine optimization AEO, AI citation tracking, share of voice AI, LLM visibility, AI SEO tool, multi-engine brand monitoring, competitive intelligence AI search.

# Actor input Schema

## `engines` (type: `array`):

Which AI answer engines to query. Each selected engine requires its own API key below.

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

Required for the ChatGPT engine. Get one at platform.openai.com/api-keys. Stored securely; never logged.

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

Required for the Perplexity engine. Get one at perplexity.ai/settings/api (free tier available). Stored securely; never logged.

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

Required for the Gemini engine. Get a free key at aistudio.google.com/apikey. Stored securely; never logged.

## `anthropicApiKey` (type: `string`):

Required for the Claude engine. Get one at console.anthropic.com. Stored securely; never logged.

## `brands` (type: `array`):

Brand names to monitor. To also track domain citations, append the domain in parentheses: 'HubSpot (hubspot.com)'. Add competitors for a full share-of-voice picture.

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

The questions to ask each AI engine. Use high-intent queries your customers actually ask — e.g. 'best CRM for small businesses 2026'.

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

Maximum prompts to process per engine in this run. Set low (e.g. 2) for testing, then increase.

## Actor input object example

```json
{
  "engines": [
    "perplexity"
  ],
  "brands": [
    "Apify (apify.com)",
    "Zapier (zapier.com)"
  ],
  "prompts": [
    "best web scraping tools 2026",
    "top workflow automation platforms"
  ],
  "maxPrompts": 2
}
```

# 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 = {
    "engines": [
        "perplexity"
    ],
    "brands": [
        "Apify (apify.com)",
        "Zapier (zapier.com)"
    ],
    "prompts": [
        "best web scraping tools 2026",
        "top workflow automation platforms"
    ],
    "maxPrompts": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("samstorm/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 = {
    "engines": ["perplexity"],
    "brands": [
        "Apify (apify.com)",
        "Zapier (zapier.com)",
    ],
    "prompts": [
        "best web scraping tools 2026",
        "top workflow automation platforms",
    ],
    "maxPrompts": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("samstorm/ai-visibility-tracker").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 '{
  "engines": [
    "perplexity"
  ],
  "brands": [
    "Apify (apify.com)",
    "Zapier (zapier.com)"
  ],
  "prompts": [
    "best web scraping tools 2026",
    "top workflow automation platforms"
  ],
  "maxPrompts": 2
}' |
apify call samstorm/ai-visibility-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=samstorm/ai-visibility-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Visibility Tracker — ChatGPT, Perplexity, Gemini & Claude",
        "description": "Monitor brand visibility across ChatGPT, Perplexity, Gemini, and Claude in one run. Track mentions, citations, and share of voice in AI search answers (GEO/AEO). Bring your own free API keys — you control engine costs.",
        "version": "1.0",
        "x-build-id": "5ienSlYYaWHuHab7e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/samstorm~ai-visibility-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-samstorm-ai-visibility-tracker",
                "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/samstorm~ai-visibility-tracker/runs": {
            "post": {
                "operationId": "runs-sync-samstorm-ai-visibility-tracker",
                "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/samstorm~ai-visibility-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-samstorm-ai-visibility-tracker",
                "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": [
                    "engines",
                    "brands",
                    "prompts"
                ],
                "properties": {
                    "engines": {
                        "title": "AI Engines to Check",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which AI answer engines to query. Each selected engine requires its own API key below.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "chatgpt",
                                "perplexity",
                                "gemini",
                                "claude"
                            ],
                            "enumTitles": [
                                "ChatGPT (OpenAI)",
                                "Perplexity",
                                "Gemini (Google)",
                                "Claude (Anthropic)"
                            ]
                        }
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API Key",
                        "type": "string",
                        "description": "Required for the ChatGPT engine. Get one at platform.openai.com/api-keys. Stored securely; never logged."
                    },
                    "perplexityApiKey": {
                        "title": "Perplexity API Key",
                        "type": "string",
                        "description": "Required for the Perplexity engine. Get one at perplexity.ai/settings/api (free tier available). Stored securely; never logged."
                    },
                    "geminiApiKey": {
                        "title": "Google Gemini API Key",
                        "type": "string",
                        "description": "Required for the Gemini engine. Get a free key at aistudio.google.com/apikey. Stored securely; never logged."
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API Key",
                        "type": "string",
                        "description": "Required for the Claude engine. Get one at console.anthropic.com. Stored securely; never logged."
                    },
                    "brands": {
                        "title": "Brands to Track",
                        "type": "array",
                        "description": "Brand names to monitor. To also track domain citations, append the domain in parentheses: 'HubSpot (hubspot.com)'. Add competitors for a full share-of-voice picture."
                    },
                    "prompts": {
                        "title": "Search Prompts",
                        "type": "array",
                        "description": "The questions to ask each AI engine. Use high-intent queries your customers actually ask — e.g. 'best CRM for small businesses 2026'."
                    },
                    "maxPrompts": {
                        "title": "Max Prompts",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum prompts to process per engine in this run. Set low (e.g. 2) for testing, then increase.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
