# AI Search Visibility Tracker — ChatGPT, Gemini & More (`cheapapi/ai-search-visibility-tracker`) Actor

Check if ChatGPT, Gemini, Claude & Perplexity mention your brand: position, sentiment, cited sources, competitors & share of voice. No API keys.

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

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Search Visibility Tracker — ChatGPT, Gemini, Claude & Perplexity Brand Mentions

**Find out whether AI assistants recommend your brand.** Enter your brand and the questions your customers ask. The Actor asks ChatGPT, Gemini and Perplexity (Claude is optional) and tells you, for every answer, whether your brand was mentioned, where it ranked against your competitors, how it was described and which websites the AI cited. You also get a free share-of-voice summary per engine. You don't need any API keys or accounts.

### Why this Actor

- **4 AI engines in one run**: ChatGPT, Gemini, Claude and Perplexity, with 23 selectable models. Every prompt is asked once per engine, so you can compare engines side by side.
- **From $0.0045 per answer on Gold ($0.008 on Free)**: a standard-model answer costs $0.008 on the Free plan, $0.005 on Bronze and **$0.0045** on Silver, Gold and higher ($8 / $5 / $4.50 per 1,000). The default run (2 prompts × 3 engines) costs **$0.056**. **No start fee, no monthly subscription**: you pay per answer. Apify platform usage is billed separately by Apify (at the default 256 MB a small run typically uses about $0.001–$0.005).
- **38 fields per answer**, including a stable row `id`: mention, position among brands, list rank, excerpt, sentiment, "recommended" flag, 0–10 visibility score, share of voice, cited sources, whether your site and each competitor's site were cited, and the full answer text.
- **Two more tools in the same Actor**: a **mentions database** of real stored ChatGPT and Google AI Overview answers that name your brand or website ($0.002 per answer + $0.13 per lookup), and **AI keyword volume** with a 12-month trend ($0.515 per 1,000 keywords).
- **Analysis is free and instant**: brand detection, sentiment and scoring run locally on each answer. No extra AI calls are charged.

What is **not** included: live Google AI Overview and Google AI Mode answers (our [Google SERP Scraper](https://apify.com/cheapapi/google-serp-scraper) covers both), and built-in dashboards or alerts. See [Not included](#not-included) for the full list.

### Compared with alternatives

Typical run: **10 prompts × ChatGPT + Gemini + Perplexity = 30 AI answers**. Prices are shown for the Free plan and, in brackets, the Gold plan.

| Alternative | Price per AI answer | Typical run (30 answers) | Claude | Live Google AI Overview |
|---|---|---|---|---|
| Most-used AI brand monitor in the Store (~240 users) | $0.08 (same on Gold) | **$2.40** ($2.40) | ✓ | ✗ |
| 5-platform AI rank tracker (~110 users) | $0.05 ($0.04 on Gold) + $0.001 per run | **$1.50** ($1.20), + $0.25 ($0.20) for its optional aggregated report | ✓ | ✓ |
| LLM visibility & citation tracker with live web search in every check (~110 users) | $0.09 (same on Gold) | **$2.70** ($2.70) | ✓ | ✗ |
| Per-question bundle (~4 variants × 5–7 fixed engines per question, ~110 users) | $0.30 per question ($0.18 on Gold) | **$3.00** ($1.80) for 10 questions | ✗ | ✓ |
| Flat per-run brand analysis, ChatGPT + Gemini only (~110 users) | one $0.30 fee per run ($0.15 on Gold), + Apify platform usage | **$0.30** ($0.15) per run; its listing does not say how many prompts or answers one analysis covers | ✗ | ✗ |
| **This Actor** | **$0.008–$0.012** ($0.0045–$0.0093 on Gold), + Apify platform usage | **$0.28** ($0.18); **$1.48** ($1.38) with live web search on for ChatGPT and Gemini | ✓ | ✗ ([use our SERP scraper](https://apify.com/cheapapi/google-serp-scraper)) |

Platform usage: the flat per-run brand analysis and this Actor both bill Apify platform usage to the user on top of their event prices (here, at the default 256 MB a small run typically uses about $0.001–$0.005); the other four listings do not. Prices from public Apify Store listings, checked September 2026. Where the others are ahead: the flat per-run brand analysis costs $0.15 per run on Gold, less than our $0.18 for 30 answers, though it covers only ChatGPT and Gemini (the same 10 prompts on ChatGPT + Gemini cost $0.16 on Free and $0.09 on Gold here); two of the others include live Google AI Overview answers, the per-question bundle rewrites each question into several variants for you, and one runs live web search in every check. Here you choose each engine and model yourself, web search is optional (Perplexity always searches), and the share-of-voice summary row is free.

### What data you get

One row per **prompt × AI engine** (`rowType: "answer"`):

| Field | Type | Example |
|---|---|---|
| `prompt` | string | `What is the best CRM software for a small business?` |
| `promptType` | string | `unbranded` (or `branded` if the prompt names your brand) |
| `promptGenerated` | boolean | `false` (`true` when created from a topic) |
| `engine` / `engineName` | string | `chatgpt` / `ChatGPT` |
| `model` / `modelVersion` | string | `gpt-4.1-mini` / `gpt-4.1-mini-2025-04-14` |
| `mentioned` | boolean | `true` |
| `answerStatus` | string | `ok` (or `empty` / `noResponse`: charged answer without text, see [Pricing](#pricing)) |
| `mentionCount` | integer | `3` |
| `mentionPosition` | integer | `1` (rank among all tracked brands by first appearance) |
| `listRank` | integer | `1` (item number in the AI's numbered or bulleted list) |
| `excerpt` | string | `1. **HubSpot CRM** – Free to start, very easy to use…` |
| `sentiment` / `sentimentScore` | string / number | `positive` / `1` (−1 to 1) |
| `recommended` | boolean | `true` ("I recommend", "best choice", …) |
| `visibilityScore` | number 0–10 | `10` |
| `shareOfVoice` | number 0–1 | `0.6` (your share of all brand mentions in the answer) |
| `brandDomainCited` / `brandCitationPosition` | boolean / integer | `true` / `1` |
| `competitorsMentioned` | array | `["Salesforce", "Pipedrive"]` |
| `brandsInOrder` | array | `["HubSpot", "Salesforce", "Pipedrive"]` |
| `competitorMentions` | array | `[{ "name": "Salesforce", "mentioned": true, "mentionCount": 1, "position": 2, "domainCited": false }]` |
| `citationCount` / `citedDomains` | integer / array | `2` / `["hubspot.com", "g2.com"]` |
| `citations` | array | `[{ "position": 1, "title": "HubSpot pricing", "url": "https://www.hubspot.com/pricing", "domain": "hubspot.com" }]` |
| `webSearchRequested` / `webSearchUsed` | boolean | `false` / `false` |
| `followUpSearches` | array | web searches the AI ran, when it searched |
| `answer` / `answerLength` | string / integer | full answer text / `545` |
| `webSearchCountry` / `webSearchCity` | string | `US` / `null` |
| `answeredAt` / `scrapedAt` | ISO date | `2026-09-27T16:16:13.000Z` |
| `brand` / `rowType` | string | `HubSpot` / `answer` |
| `id` | string | `62a8ca3184f069b6` (stable: same brand + prompt + engine + model + run date → same id) |

`domainCited` (per competitor) and `brandDomainCited` are `true` when one of the answer's cited sources is that brand's website. If you give a domain (`"Pipedrive | pipedrive.com"`), it is matched exactly, subdomains included. If you give only a name, the cited site's main name must equal the name without spaces (`Salesforce` → `salesforce.com`).

Plus one free **summary row** (`rowType: "summary"`, also saved as `SUMMARY` in the key-value store) with mention rate, share of voice, average position, average sentiment, average visibility score, answers recommending or citing you, each competitor's mention rate and share of voice, and the 10 most-cited domains. You get these numbers for the whole run and per engine (`byEngine`).

### How to use

1. Open the Actor in Apify Console and go to the **Input** tab.
2. Enter your **Brand name** and, optionally, your **Website domain** (used to detect when AI answers cite your site).
3. Add a few **Competitors** (name, domain, or `Name | domain.com`).
4. Add the **Prompts** your customers ask AI assistants. No prompts yet? Leave the list empty and enter a **Topic** in the Advanced section, and 5–10 natural questions are generated for free.
5. Set **Maximum cost per run** if you want a hard budget, then click **Start**.
6. Rows show up in the **Output** tab in the "Brand visibility per answer" view. Export them as JSON, CSV, Excel or HTML.
7. To track changes over time, save the input as a task and add a weekly **Schedule**.

Input you can paste:

```json
{
    "brandName": "HubSpot",
    "brandDomain": "hubspot.com",
    "competitors": ["Salesforce", "Pipedrive", "Zoho CRM | zoho.com"],
    "prompts": [
        "What is the best CRM software for a small business?",
        "Which CRM is easiest to use for a startup sales team?"
    ],
    "engines": ["chatgpt", "gemini", "perplexity", "claude"]
}
```

**API (curl)**

```bash
curl -X POST "https://api.apify.com/v2/acts/cheapapi~ai-search-visibility-tracker/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"brandName":"HubSpot","brandDomain":"hubspot.com","competitors":["Salesforce","Pipedrive"],"prompts":["What is the best CRM software for a small business?"]}'
```

**JavaScript (apify-client)**

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

const client = new ApifyClient({ token: '<YOUR_TOKEN>' });
const run = await client.actor('cheapapi/ai-search-visibility-tracker').call({
    brandName: 'HubSpot',
    brandDomain: 'hubspot.com',
    competitors: ['Salesforce', 'Pipedrive'],
    prompts: ['What is the best CRM software for a small business?'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const row of items.filter((i) => i.rowType === 'answer')) {
    console.log(row.engineName, row.mentioned, row.mentionPosition, row.sentiment);
}
```

**Python (apify-client)**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("cheapapi/ai-search-visibility-tracker").call(run_input={
    "brandName": "HubSpot",
    "brandDomain": "hubspot.com",
    "competitors": ["Salesforce", "Pipedrive"],
    "topic": "CRM software",
})
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
print(summary["brandMentionRate"], summary["shareOfVoice"])
```

### Use cases

- **Generative engine optimization (GEO)**: measure how often AI assistants name your brand for buyer questions, and whether your content changes move the numbers.
- **Competitor benchmarking**: compare share of voice, position and sentiment against up to 20 competitors, per engine.
- **Source and PR strategy**: see which domains the AI cites (review sites, media, your own pages) and where you should be present.
- **Weekly monitoring**: schedule the same prompts and chart mention rate and visibility score over time.
- **Agency reporting**: run one task per client and send the summary row to a spreadsheet or dashboard.
- **Market research**: use the mentions database and AI keyword volume to find which questions people actually ask AI about your category.

### Advanced options

All of these are in the collapsed "Advanced" sections of the input form.

| Option | Default | Meaning |
|---|---|---|
| What to run (`mode`) | `visibility` | Brand visibility check, Mentions database lookup, or AI keyword volume. |
| Topic (`topic`) | – | Used only when Prompts is empty: generates natural buyer questions from templates, free. |
| Number of generated prompts (`promptCount`) | 8 | 5–10. From 8, questions that name your brand are added after the neutral ones. |
| Other names of your brand (`brandAliases`) | – | Extra spellings or product names that count as a mention. |
| AI engines (`engines`) | ChatGPT, Gemini, Perplexity | Add Claude, or remove any. |
| ChatGPT model (`chatgptModel`) | GPT-4.1 mini | Also GPT-4o mini, GPT-5 mini/nano (standard); GPT-4.1, GPT-4o, GPT-5, GPT-5.1, GPT-5.2, o4-mini (premium). |
| Gemini model (`geminiModel`) | Gemini 2.5 Flash | Also Flash-Lite (standard); 3 Flash preview (plus); 2.5 Pro, 3.1 Pro preview (premium). |
| Claude model (`claudeModel`) | Claude Haiku 4.5 | Also Sonnet 4.5/4.6, Opus 4.5/4.6 (premium). |
| Perplexity model (`perplexityModel`) | Sonar | Also Sonar Pro, Sonar Reasoning Pro (premium). |
| Live web search (`webSearch`) | off | Lets ChatGPT, Gemini and Claude browse and cite sources. Perplexity always searches. Adds a `web-search` event. |
| Always search the web (`forceWebSearch`) | off | Forces a search every time (ChatGPT GPT-4o/GPT-4.1 models and Claude). |
| Search from country / city (`webSearchCountry`, `webSearchCity`) | – | Localizes web search, e.g. `GB` / `London` or `DE` / `Berlin` (two-letter code or English country name). ChatGPT and Claude support both, Perplexity country only, Gemini neither. |
| Max answer length (`maxAnswerTokens`) | 1,024 | 256–4,096 tokens. Each started 1,024 tokens counts as one answer event. Reasoning and Pro models use at least 1,024. |
| Temperature (`temperature`) | engine default | Number 0–2. Leave empty to get what real users see. Ignored by reasoning models. |
| Top-p (`topP`) | engine default | Number 0–1. Ignored by reasoning models. |
| System message (`systemMessage`) | – | Optional role instruction, max 500 characters. Using a system message or conversation history counts as one more answer event per answer (the AI provider bills the extra text). |
| Conversation history (`conversationHistory`) | – | Up to 10 earlier messages (max 500 characters each) to simulate follow-up questions. +1 answer event per answer (shared with the system message). |
| Include full answer text (`includeFullAnswer`) | on | Turn off for smaller datasets. The excerpt is always kept. |
| Parallel requests (`maxConcurrency`) | 6 | 1–20 answers requested at the same time. |
| Targets to look up (`mentionsTargets`) | your domain or brand | Mentions database: domains or names, up to 20 per run. |
| Also look up competitors | off | Runs a separate mentions lookup for each competitor. |
| AI platform (`mentionsPlatform`) | all | ChatGPT and Google AI Overview, or only one of them. |
| Where a domain must appear | anywhere | Anywhere, in cited sources, or in the web results the AI looked at. |
| Where a name must appear | anywhere | Question, answer, brands named in the answer, or the AI's follow-up searches. |
| Keyword matching | whole words | Or partial match. |
| Include subdomains | on | For domain targets. |
| Minimum AI search volume | 0 | Only questions asked at least this often per month. |
| Only answers based on web search | off | Only answers where the AI searched the web. |
| Only answers seen since | – | Date (YYYY-MM-DD). |
| Sort by | most asked first | Or least asked, most recently seen, first seen. |
| Max answers per target (`mentionsMaxResults`) | 100 | 1–10,000. |
| Extra filters (experts) | – | Up to 8 raw conditions, e.g. `[["ai_search_volume", ">", 1000]]`. |
| Keywords (`keywords`) | – | AI keyword volume: up to 10,000 keywords per run. |
| Country / Language (`country`, `language`) | US / en | For the mentions database and AI keyword volume, e.g. `GB` / `en`, `DE` / `de`, `TR` / `tr`. |

### Output example

Example output: an answer row (a real ChatGPT answer analyzed by the current code):

```json
{
    "id": "62a8ca3184f069b6",
    "rowType": "answer",
    "answerStatus": "ok",
    "brand": "HubSpot",
    "prompt": "What is the best CRM software for a small business?",
    "promptType": "unbranded",
    "promptGenerated": false,
    "engine": "chatgpt",
    "engineName": "ChatGPT",
    "model": "gpt-4.1-mini",
    "modelVersion": "gpt-4.1-mini-2025-04-14",
    "mentioned": true,
    "mentionCount": 3,
    "mentionPosition": 1,
    "listRank": 1,
    "excerpt": "1. **HubSpot CRM** – Free to start, very easy to use and great for marketing teams. I recommend it for most small teams.",
    "sentiment": "positive",
    "sentimentScore": 1,
    "recommended": true,
    "visibilityScore": 10,
    "shareOfVoice": 0.6,
    "brandDomainCited": true,
    "brandCitationPosition": 1,
    "competitorsMentioned": ["Salesforce", "Pipedrive"],
    "brandsInOrder": ["HubSpot", "Salesforce", "Pipedrive"],
    "competitorMentions": [
        { "name": "Salesforce", "mentioned": true, "mentionCount": 1, "position": 2, "domainCited": false },
        { "name": "Pipedrive", "mentioned": true, "mentionCount": 1, "position": 3, "domainCited": false },
        { "name": "Zoho CRM", "mentioned": false, "mentionCount": 0, "position": null, "domainCited": false }
    ],
    "citationCount": 2,
    "citedDomains": ["hubspot.com", "g2.com"],
    "citations": [
        { "position": 1, "title": "HubSpot pricing", "url": "https://www.hubspot.com/pricing", "domain": "hubspot.com", "excerpt": null },
        { "position": 2, "title": "G2 reviews", "url": "https://www.g2.com/categories/crm", "domain": "g2.com", "excerpt": null }
    ],
    "webSearchRequested": false,
    "webSearchUsed": false,
    "followUpSearches": [],
    "answerLength": 545,
    "answer": "Here are some of the best CRM tools for small businesses:\n\n1. **HubSpot CRM** – Free to start, very easy to use and great for marketing teams. I recommend it for most small teams.\n2. **Salesforce** – Extremely powerful, but it can be expensive and complex for small teams.\n3. **Pipedrive** – …",
    "webSearchCountry": null,
    "webSearchCity": null,
    "answeredAt": "2026-09-27T16:16:13.000Z",
    "scrapedAt": "2026-09-28T09:00:00.000Z"
}
```

An answer that was charged but brought no text (`answerStatus` `empty` or `noResponse`) keeps the same fields: prompt, engine, model and search settings are filled, the analysis fields are `null` and the lists are empty, for example:

```json
{
    "id": "e55481a24d2e6a69",
    "rowType": "answer",
    "answerStatus": "noResponse",
    "brand": "HubSpot",
    "prompt": "Which CRM is easiest to use for a startup sales team?",
    "engine": "gemini",
    "engineName": "Gemini",
    "model": "gemini-2.5-flash",
    "modelVersion": null,
    "mentioned": null,
    "mentionCount": null,
    "sentiment": null,
    "visibilityScore": null,
    "competitorMentions": [],
    "citationCount": 0,
    "citations": [],
    "webSearchRequested": false,
    "webSearchUsed": null,
    "answerLength": 0,
    "answer": null,
    "answeredAt": null,
    "scrapedAt": "2026-09-28T09:00:04.000Z"
}
```

(shortened: the other analysis fields are also `null` or empty.)

Example output: the summary row (shortened; the numbers are illustrative):

```json
{
    "id": "f33d6b5c6bea92c7",
    "rowType": "summary",
    "brand": "HubSpot",
    "brandDomain": "hubspot.com",
    "prompts": 2,
    "engines": ["chatgpt", "gemini", "perplexity"],
    "answers": 6,
    "answersMentioningBrand": 4,
    "brandMentionRate": 0.667,
    "brandMentions": 9,
    "shareOfVoice": 0.41,
    "averageMentionPosition": 1.5,
    "averageSentimentScore": 0.62,
    "averageVisibilityScore": 6.17,
    "answersRecommendingBrand": 2,
    "answersCitingBrandDomain": 1,
    "competitors": [{ "name": "Salesforce", "answersMentioning": 5, "mentionRate": 0.833, "mentions": 7, "shareOfVoice": 0.32 }],
    "topCitedDomains": [{ "domain": "g2.com", "answersCiting": 3 }],
    "byEngine": { "chatgpt": { "answers": 2, "brandMentionRate": 1, "shareOfVoice": 0.5 }, "gemini": { "…": "…" }, "perplexity": { "…": "…" } }
}
```

### Pricing

**Typical cost:** 10 prompts × ChatGPT + Gemini + Perplexity (30 answers) costs **$0.28** on the Free plan and **$0.18** on Gold; Apify platform usage is billed separately.

**Apify Free plan:** Apify does not pay developers for usage on its Free plan, so on the Free plan this Actor can be used for up to **$0.25 of results per calendar month** — enough to try it on a small input. When the allowance is used up, the run ends with a clear message (not an error). Any paid Apify plan removes the limit; prices are the same.

Pay per event. There is no start fee, and the run stops cleanly when it reaches your **maximum cost per run**. Your Apify plan's price is applied automatically. Apify platform usage is billed separately by Apify (at the default 256 MB a small run typically uses about $0.001–$0.005).

Answers the AI engine rejects (an error) are not charged. An answer the engine did produce but that came back **empty**, or that was **lost in transit** after the question was sent, is charged like a normal answer, because the AI provider bills it too; you get a row with `answerStatus` `empty` or `noResponse` so you can see it (it is left out of the summary).

| Event | Free | Bronze | Silver | Gold and higher | When it is charged |
|---|---|---|---|---|---|
| `answer-standard` | $0.008 | $0.005 | $0.0045 | $0.0045 | Each answer from ChatGPT (GPT-4.1 mini, GPT-4o mini, GPT-5 mini/nano) or Gemini (2.5 Flash, Flash-Lite) |
| `answer-plus` | $0.012 | $0.012 | $0.010 | $0.0093 | Each answer from Perplexity Sonar (always web-searched, with sources), Claude Haiku 4.5 or Gemini 3 Flash |
| `answer-premium` | $0.05 | $0.05 | $0.05 | $0.05 | Each answer from a flagship or reasoning model (GPT-4o, GPT-4.1, GPT-5.x, o4-mini, Gemini Pro, Claude Sonnet/Opus, Sonar Pro/Reasoning Pro) |
| `web-search` | $0.06 | $0.06 | $0.06 | $0.06 | Per answer with live web search on: 1 event for ChatGPT and Gemini, 2 for Claude Haiku, 4 for Claude Sonnet/Opus. Never for Perplexity. |
| `mentions-lookup` | $0.13 | $0.13 | $0.13 | $0.13 | Each database search for one target (up to 1,000 answers), also when it finds nothing |
| `mention` | $0.002 | $0.002 | $0.002 | $0.002 | Each stored AI answer returned by the mentions lookup |
| `keyword-batch` | $0.015 | $0.015 | $0.015 | $0.015 | Each AI keyword volume request (up to 1,000 keywords), also when none of the keywords has data |
| `keyword` | $0.0005 | $0.0005 | $0.0005 | $0.0005 | Each keyword with AI search volume |

Answer events cover answers up to 1,024 tokens. If you raise "Max answer length", each started 1,024 tokens counts as one more answer event (2,048 = 2 events). A system message or conversation history adds one more answer event per answer (1,024 tokens + history = 2 events).

The mentions database and AI keyword volume bill every search, so `mentions-lookup` and `keyword-batch` are charged even when nothing is found. If the connection is lost after a lookup or keyword request was sent, it is charged as if the requested answers or keywords had been delivered (it may already have been processed and billed), and it is not resent automatically.

**Worked examples**

| Run | Free plan | Gold plan |
|---|---|---|
| Default: 2 prompts × ChatGPT + Gemini + Perplexity (6 answers) | 4 × $0.008 + 2 × $0.012 = **$0.056** | 4 × $0.0045 + 2 × $0.0093 = **$0.037** |
| **50 prompts × 3 engines** (ChatGPT + Gemini + Perplexity, 150 answers) | 100 × $0.008 + 50 × $0.012 = **$1.40** | 100 × $0.0045 + 50 × $0.0093 = **$0.915** |
| 50 prompts × all 4 engines (adds Claude Haiku, 200 answers) | $1.40 + 50 × $0.012 = **$2.00** | $0.915 + 50 × $0.0093 = **$1.38** |
| 20 prompts × 3 engines, weekly for 4 weeks (240 answers) | 4 × $0.56 = **$2.24 per month** | 4 × $0.366 = **$1.46 per month** |
| 10 prompts × ChatGPT + Gemini with live web search (20 answers) | 20 × ($0.008 + $0.06) = **$1.36** | 20 × ($0.0045 + $0.06) = **$1.29** |
| Mentions database, 1 target, 100 answers | $0.13 + 100 × $0.002 = **$0.33** | **$0.33** |
| AI keyword volume, 1,000 keywords | $0.015 + 1,000 × $0.0005 = **$0.515** | **$0.515** |
| 1 prompt × ChatGPT with a system message (1,024 tokens) | 2 × $0.008 = **$0.016** | 2 × $0.0045 = **$0.009** |
| Mentions database, 1 target that no stored answer mentions | **$0.13** | **$0.13** |

All examples exclude Apify platform usage, which Apify bills separately (at the default 256 MB a small run typically uses about $0.001–$0.005).

### Integrations

- **Make and Zapier**: use the Apify app to start a run and pass the summary row (mention rate, share of voice) to the next step.
- **Google Sheets**: use the Apify Google Sheets integration, or export the dataset as CSV, to keep a weekly visibility log.
- **Webhooks**: add a webhook on "Run succeeded" to notify Slack or your own endpoint, for example when `brandMentionRate` drops.
- **Schedules**: run the same prompts daily or weekly in Apify Console. Every run keeps its own dataset, so you can compare runs.
- **API and MCP**: start runs and read results with the Apify API (examples above), or let an AI agent call the Actor through the Apify MCP server.

### FAQ

**Is there a limit on the Apify Free plan?** Yes: up to $0.25 of this Actor's results per calendar month, enough to try it. Apify pays developers nothing for Free-plan usage while our data costs are real, so this keeps the Actor sustainable. Runs that reach the allowance stop cleanly and keep everything collected so far; the allowance resets on the 1st of the month. Any paid Apify plan has no limit.

**Do I need OpenAI, Google, Anthropic or Perplexity API keys?**
No. The Actor asks the AI engines through its own paid access, and that cost is already included in the per-answer price. You only need an Apify account.

**Is it legal?**
The Actor sends your questions to AI assistants and analyzes the answers, just as a person typing the same questions would see them. It does not log in to anyone's account or collect private data. You are responsible for how you use the results.

**How fresh is the data?**
Visibility checks are live: every answer is generated when you run the Actor, and `answeredAt` shows the exact time. The mentions database contains stored answers with `firstSeenAt` and `lastSeenAt` dates. AI keyword volume is a monthly estimate.

**Why did I get fewer results than expected?**
Answers the AI engine rejects are not delivered and not charged. Empty or lost answers get a row with `answerStatus` `empty` or `noResponse` (charged, see below). The run also stops when it reaches your maximum cost per run. The `RUN_SUMMARY` record in the key-value store lists skipped and failed answers. In the mentions lookup, strict filters or a small brand can return few stored answers.

**Why was I charged for an answer without text, or for a lookup that found nothing?**
The AI providers and the answers database bill every request they process, also when the result is empty. So: an answer that came back empty (for example, a reasoning model used its whole length limit for thinking; raise "Max answer length") or was lost in transit after the question was sent is charged like a normal answer and shown with `answerStatus` `empty` or `noResponse`; a mentions lookup that finds no stored answers is charged `mentions-lookup` ($0.13); a keyword request where no keyword has data is charged `keyword-batch` ($0.015). A lost lookup or keyword request is charged as if the requested rows had arrived. `RUN_SUMMARY` shows the count as `chargedWithoutAnswer`. Errors (a rejected question, an unavailable model) are never charged. A system message or conversation history counts as one more answer event per answer because it is sent with every question and the AI provider bills it as input.

**How do I control my budget?**
Set **Maximum cost per run** when you start the Actor. The Actor checks the price before it asks for each answer and never starts work it cannot pay for within that limit. Use the worked examples above to estimate a run.

**Can I monitor visibility over time?**
Yes. Save your input as a task and add a weekly schedule. Every run asks the AI engines again, so every answer is new and is charged once. To see changes, compare `brandMentionRate`, `shareOfVoice` and `averageVisibilityScore` in the `SUMMARY` record of each run (for example with the Google Sheets integration). Answer rows carry a stable `id` (brand + prompt + engine + model + run date), so you can join the same prompt across runs. For the mentions database, the `id` of a stored answer stays the same in every run: keep the ids you have seen and filter them out downstream to get only new answers. AI answers vary from run to run. Track trends over several runs rather than relying on one answer. A low temperature makes answers more stable, but less like what real users see.

**Why is live web search off by default?**
Without web search you see what the model itself "knows" about your brand. Live web search adds citations but costs more, because each answer then includes a live web search. Perplexity always searches, so the default run already includes cited sources.

**How are sentiment and position calculated?**
Sentiment is a heuristic, not a trained model: it counts positive and negative words, with negation handling ("not good" is negative), in the sentences around each mention. It runs locally and costs nothing. We do not publish an accuracy figure, because we have not measured it against human labels. Treat it as a quick signal and check the `excerpt` when a result matters. `mentionPosition` ranks your brand among all tracked brands by first appearance, and `listRank` is the item number when your brand appears in a list.

**Which export formats are available?**
JSON, CSV, Excel, XML, HTML and RSS, from the Output tab or the API. The "Brand visibility per answer" and "Share of voice summary" views give you ready-made tables.

**Where do I get help?**
Open an issue on the Actor's **Issues** tab in Apify Console. Include the run ID so we can look at the log.

### Limitations

- Brand detection matches your brand name, the extra names you give, your domain and its main part (for example "hubspot" from hubspot.com). Very generic brand names (for example "Apple" used as a fruit) can produce false matches.
- A competitor given only by name is matched to cited sites by its main name (`Salesforce` → `salesforce.com`). If its website has a different name, add the domain (`Zoho CRM | zoho.com`).
- Sentiment and "recommended" are word-list heuristics with no measured accuracy figure. They can misread sarcasm, mixed verdicts or complex comparisons, so read the `excerpt` before acting on a single answer.
- Answers can differ from the consumer chat apps, which add personalization, memory and their own instructions.
- Some advanced settings are not supported by every engine: Gemini has no search location or forced search, Perplexity has no city, and reasoning models ignore temperature and top-p. The Actor then uses the engine default and logs a note.
- At most 200 prompts and 20 competitors per run. Model lists change often, and new models are added after testing.
- In the mentions database, stored ChatGPT answers cover the United States in English only. Google AI Overview answers cover many more countries. AI search volume figures are estimates.

### Not included

- **Live Google AI Overview and Google AI Mode answers.** This Actor asks the AI assistants directly; Google's AI answers appear on the search results page. Use our [Google SERP Scraper](https://apify.com/cheapapi/google-serp-scraper): it returns the AI Overview with every cited source and your domain's citation position, and has a separate Google AI Mode search type. This Actor's mentions database still covers stored Google AI Overview answers.
- **Microsoft Copilot, Meta AI, Grok and DeepSeek.** Only ChatGPT, Gemini, Claude and Perplexity are asked live.
- **Automatic prompt variants.** Each prompt is asked exactly as you write it. Add rephrased versions yourself, or use a topic to generate 5–10 questions for free.
- **Dashboards, alerts and run-to-run comparison inside the Actor.** Results go to a dataset and a `SUMMARY` record; use schedules, webhooks and the stable `id` to compare runs in your own tools.
- **Classic keyword research and rankings.** For search volume, difficulty and ideas use our [Keyword Research Tool](https://apify.com/cheapapi/keyword-research-tool); for your domain's Google rankings, the [Google SERP Scraper](https://apify.com/cheapapi/google-serp-scraper) or [Domain SEO Analyzer](https://apify.com/cheapapi/domain-seo-analyzer).

### Privacy

The Actor only processes the brand names, domains and prompts you enter and the AI answers it receives. It does not collect personal data about individuals. Anything you put into prompts, the system message or the conversation history is sent to the AI engines as part of the question, so please do not include personal data there. Results are stored in your own Apify account, and you decide how long they are kept.

# Actor input Schema

## `brandName` (type: `string`):

Required for the brand visibility check (the default mode): the brand you want to track, exactly as people write it (e.g. "HubSpot"). Matching is case-insensitive and ignores legal suffixes like "Inc". The mentions lookup uses it when no targets are given; AI keyword volume does not need it.

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

Your website (e.g. "hubspot.com"). Used to detect when AI answers cite your site as a source.

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

Competitor brands to compare against for share of voice. Write a name ("Salesforce"), a domain ("salesforce.com") or both ("Salesforce | salesforce.com"). Up to 20.

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

Questions your customers ask AI assistants, max 500 characters each. Every prompt is sent to every selected AI engine. Leave empty and fill "Topic" below to have 5–10 natural questions generated for you.

## `mode` (type: `string`):

Brand visibility check asks the AI engines live. Mentions database lookup searches a large index of real ChatGPT and Google AI Overview answers already collected. AI keyword volume returns AI search demand for your keywords.

## `topic` (type: `string`):

Used only when "Prompts" is empty. Write what you sell as a short noun phrase, e.g. "CRM software", "running shoes", "dentist in Austin". We turn it into natural buyer questions ("What is the best CRM software?", "Is HubSpot a good choice for CRM software?", …) using templates — no extra charge.

## `promptCount` (type: `integer`):

How many questions to generate from the topic (5–10). With 8 or more, questions that name your brand are added after the neutral ones.

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

Extra spellings or product names that count as a mention of your brand (e.g. "HubSpot CRM", "Hubspot Sales Hub").

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

Which AI assistants to ask. Default: ChatGPT, Gemini and Perplexity. Every prompt is asked once per engine.

## `chatgptModel` (type: `string`):

Model used when ChatGPT is selected.

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

Model used when Gemini is selected.

## `claudeModel` (type: `string`):

Model used when Claude is selected.

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

Model used when Perplexity is selected. Perplexity always searches the web and cites sources.

## `webSearch` (type: `boolean`):

Off: the AI answers from its own knowledge (how it "remembers" your brand). On: the AI may browse the web first and cite sources, like ChatGPT Search. Costs an extra web-search event per answer. Perplexity always searches.

## `forceWebSearch` (type: `boolean`):

With live web search on, make the AI search every time instead of deciding by itself.

## `webSearchCountry` (type: `string`):

Country the web search should act from, as a two-letter code or English name, for example US, GB, DE, FR, TR or "Germany". Applies to live web search (ChatGPT, Claude) and Perplexity; Gemini ignores it. Leave empty to search without a location.

## `webSearchCity` (type: `string`):

Optional city for local results, for example "Austin", "London" or "Berlin". Applies to live web search on ChatGPT and Claude; Perplexity and Gemini ignore it.

## `maxAnswerTokens` (type: `integer`):

Upper limit for the length of each AI answer (1,024 tokens ≈ 750 words, enough for a full recommendation list). Each started block of 1,024 tokens counts as one answer event, so 2,048 = 2 events per answer. Reasoning models always use at least 1,024. An answer that comes back empty because a reasoning model spent the whole limit on thinking is still charged (the AI provider bills it), so do not set this too low.

## `temperature` (type: `number`):

Optional, 0–2 (e.g. 0.3). Lower = more predictable answers, higher = more varied. Leave empty for the engine default (recommended, closest to what real users see). Ignored by reasoning models (GPT-5.x, o4-mini, Sonar Reasoning Pro).

## `topP` (type: `number`):

Optional, 0–1 (e.g. 0.9). Alternative way to control answer variety. Leave empty for the engine default. Ignored by reasoning models.

## `systemMessage` (type: `string`):

Optional instruction that sets the AI's role (max 500 characters), e.g. "You are a helpful assistant for a small business owner in Germany." Leave empty to get answers like a normal user would. Using a system message or conversation history counts as one more answer event per answer (the AI provider bills the extra text).

## `conversationHistory` (type: `array`):

Optional earlier messages to simulate a follow-up question, max 10. Format: \[{"role": "user", "message": "I run a 5-person agency."}, {"role": "assistant", "message": "Great, how can I help?"}]. Each message max 500 characters. Adds one answer event per answer (shared with the system message).

## `includeFullAnswer` (type: `boolean`):

Save the complete AI answer in each row. Turn off for smaller datasets (the mention excerpt is always included).

## `maxConcurrency` (type: `integer`):

How many answers are requested at the same time.

## `mentionsTargets` (type: `array`):

Domains ("hubspot.com") or brand/keyword names ("HubSpot"). Leave empty to use your website domain (or brand name) from the top of the form. Each target costs one mentions-lookup event ($0.13), also when no stored answer mentions it.

## `mentionsIncludeCompetitors` (type: `boolean`):

Run a separate lookup for every competitor listed above (one mentions-lookup event each, also when nothing is found).

## `mentionsPlatform` (type: `string`):

Which AI platform's stored answers to search.

## `mentionsDomainScope` (type: `array`):

For domain targets only.

## `mentionsKeywordScope` (type: `array`):

For name/keyword targets only.

## `mentionsMatchType` (type: `string`):

For name/keyword targets: match whole words only, or also inside longer words.

## `mentionsIncludeSubdomains` (type: `boolean`):

For domain targets: also count blog.example.com etc.

## `mentionsMinAiSearchVolume` (type: `integer`):

Only return questions asked at least this often per month (estimated).

## `mentionsOnlyWebSearchBased` (type: `boolean`):

Only return answers where the AI searched the web.

## `mentionsSeenSince` (type: `string`):

Only return answers that were last seen on or after this date (YYYY-MM-DD).

## `mentionsSort` (type: `string`):

Order of the returned answers.

## `mentionsMaxResults` (type: `integer`):

How many stored AI answers to return per target.

## `mentionsFilters` (type: `array`):

Optional raw filter conditions (experts), e.g. \[\["model\_name", "like", "%gpt-5%"]] or \[\["ai\_search\_volume", ">", 1000], "and", \["platform", "=", "chat\_gpt"]]. Filterable fields: ai\_search\_volume, is\_web\_search\_based, platform, model\_name, first\_response\_at, last\_response\_at. Up to 8 conditions; operators =, <>, <, >, <=, >=, in, like.

## `keywords` (type: `array`):

Used when "What to run" = AI keyword volume. Up to 10,000 keywords; returns estimated monthly AI search volume and a 12-month trend for each. Each request of up to 1,000 keywords costs one keyword-batch event, also when none of them has data.

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

Country for the mentions lookup and AI keyword volume, as a two-letter code or English name, for example US, GB, DE, FR or TR. Stored ChatGPT answers exist for US only; Google AI Overview answers cover many countries.

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

Language for the mentions lookup and AI keyword volume, as an ISO code, for example en, de, fr or tr.

## Actor input object example

```json
{
  "brandName": "HubSpot",
  "brandDomain": "hubspot.com",
  "competitors": [
    "Salesforce",
    "Pipedrive",
    "Zoho CRM"
  ],
  "prompts": [
    "What is the best CRM software for a small business?",
    "Which CRM is easiest to use for a startup sales team?"
  ],
  "mode": "visibility",
  "promptCount": 8,
  "engines": [
    "chatgpt",
    "gemini",
    "perplexity"
  ],
  "chatgptModel": "gpt-4.1-mini",
  "geminiModel": "gemini-2.5-flash",
  "claudeModel": "claude-haiku-4-5",
  "perplexityModel": "sonar",
  "webSearch": false,
  "forceWebSearch": false,
  "maxAnswerTokens": 1024,
  "includeFullAnswer": true,
  "maxConcurrency": 6,
  "mentionsIncludeCompetitors": false,
  "mentionsPlatform": "all",
  "mentionsDomainScope": [
    "any"
  ],
  "mentionsKeywordScope": [
    "any"
  ],
  "mentionsMatchType": "word",
  "mentionsIncludeSubdomains": true,
  "mentionsOnlyWebSearchBased": false,
  "mentionsSort": "volumeDesc",
  "mentionsMaxResults": 100,
  "country": "US",
  "language": "en"
}
```

# Actor output Schema

## `answers` (type: `string`):

No description

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

No description

## `summary` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# 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 = {
    "brandName": "HubSpot",
    "brandDomain": "hubspot.com",
    "competitors": [
        "Salesforce",
        "Pipedrive",
        "Zoho CRM"
    ],
    "prompts": [
        "What is the best CRM software for a small business?",
        "Which CRM is easiest to use for a startup sales team?"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cheapapi/ai-search-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 = {
    "brandName": "HubSpot",
    "brandDomain": "hubspot.com",
    "competitors": [
        "Salesforce",
        "Pipedrive",
        "Zoho CRM",
    ],
    "prompts": [
        "What is the best CRM software for a small business?",
        "Which CRM is easiest to use for a startup sales team?",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("cheapapi/ai-search-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 '{
  "brandName": "HubSpot",
  "brandDomain": "hubspot.com",
  "competitors": [
    "Salesforce",
    "Pipedrive",
    "Zoho CRM"
  ],
  "prompts": [
    "What is the best CRM software for a small business?",
    "Which CRM is easiest to use for a startup sales team?"
  ]
}' |
apify call cheapapi/ai-search-visibility-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cheapapi/ai-search-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/bGLkneDyHsSJOCB5D/builds/7giREs8eTeUSnZopt/openapi.json