# AI Brand Visibility Tracker (`dbott23/ai-visibility-tracker`) Actor

Track how AI assistants (ChatGPT, Perplexity, Gemini, Claude) mention your brand vs. competitors. Get mention rates, position scores, share of voice, and run-over-run trend deltas. Pay per check — no subscription.

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

## Pricing

from $50.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Brand Visibility Tracker — ChatGPT, Perplexity, Gemini & Claude

**Find out if AI recommends you — or your competitor.**

Run real buyer-intent queries across ChatGPT, Perplexity, Gemini, and Claude. Get mention rates, position scores, share of voice vs. competitors, cited sources, and automatic **week-over-week trend deltas** in a single run. No API keys needed.

---

### What it does

For each combination of brand × query × engine, the actor:

1. Sends the query to the AI engine (using its real web-search mode)
2. Detects whether your brand is mentioned, how early, and how often
3. Measures your share of voice vs. every competitor you list
4. Collects the URLs the AI cited as sources
5. Compares results to your previous run and reports the delta

All checks run in one batch — track a whole client roster or your brand + every competitor in a single run.

---

### Why this tracker

| Feature | This actor | Most trackers |
|---|---|---|
| Multi-brand batches | ✅ unlimited | ❌ one brand per run |
| Built-in trend deltas | ✅ automatic | ❌ manual export |
| 4 engines (incl. web-search) | ✅ | ❌ 1–2 engines |
| No API keys needed | ✅ | ❌ requires your keys |
| Pay only for what you run | ✅ per-check pricing | ❌ flat subscription |

---

### Who uses it

- **SEO / GEO agencies** building AI visibility reports for clients
- **Brand & comms teams** monitoring how LLMs describe them vs. the competition
- **Founders** checking whether AI search recommends them or their rival
- **Product marketers** tracking share of voice across AI channels

---

### Input

The default input works out of the box — just swap in your brand name:

```json
{
  "brands": [
    {
      "name": "Asana",
      "aliases": [],
      "competitors": ["Trello", "Monday.com", "ClickUp"]
    }
  ],
  "queries": [
    "best project management tool for small teams",
    "what project management software should a startup use"
  ],
  "engines": ["chatgpt", "perplexity", "gemini"],
  "trackTrends": true
}
````

**Input fields:**

| Field | Required | Description |
|---|---|---|
| `brands` | ✅ | List of brands. Each has `name`, optional `aliases`, optional `competitors`. |
| `queries` | ✅ | Buyer-intent questions your customers ask AI assistants. |
| `engines` | — | `chatgpt`, `perplexity`, `gemini`, `claude`. Default: first three (search-backed). |
| `trackTrends` | — | Save this run's summary and report deltas vs. the previous run. Default: `true`. |
| `trendKey` | — | Label to keep separate trend series (e.g. one per client). |

***

### Output

#### Dataset — one row per (brand × query × engine) check

```json
{
  "brand": "Asana",
  "engine": "chatgpt",
  "query": "best project management tool for small teams",
  "brand_mentioned": true,
  "mention_count": 2,
  "position_score": 9,
  "share_of_voice": 0.4,
  "competitor_mentions": { "Trello": 2, "Monday.com": 1, "ClickUp": 0 },
  "cited_domains": ["g2.com", "blog.asana.com"],
  "response_snippet": "For small teams, Asana offers a generous free tier...",
  "response_truncated": false
}
```

**Key fields:**

- `position_score` — 1–10; 10 = brand named first, 1 = named last, 0 = not mentioned
- `share_of_voice` — brand mentions ÷ (brand + all competitor mentions)
- `cited_domains` — domains the AI cited as sources for its answer
- `response_truncated` — `true` if the AI hit its token limit (treat that row as inconclusive)

#### SUMMARY key-value — per-brand rollup + trend deltas

```json
{
  "summary": {
    "Asana": {
      "mention_rate": 0.67,
      "avg_position_score": 7.5,
      "avg_share_of_voice": 0.42,
      "engines": {
        "chatgpt":    { "mention_rate": 1.0, "responses": 2 },
        "perplexity": { "mention_rate": 0.5, "responses": 2 }
      }
    }
  },
  "trends": {
    "Asana": {
      "mention_rate":       { "current": 0.67, "previous": 0.5,  "delta":  0.17 },
      "avg_position_score": { "current": 7.5,  "previous": 6.0,  "delta":  1.5  },
      "avg_share_of_voice": { "current": 0.42, "previous": 0.38, "delta":  0.04 }
    }
  }
}
```

***

### Pricing

Pay per event — a small flat fee per visibility check (brand × query × engine). All upstream AI API costs are included; you don't need your own keys.

**Example:** 1 brand × 3 queries × 3 engines = 9 checks.

***

### Scheduling for weekly trend reports

1. Set up a **Schedule** in Apify (Actors → Schedules → New schedule)
2. Point it at this actor with your saved input
3. Keep `trackTrends: true` (the default)
4. Every run automatically compares to the previous one and writes deltas to `SUMMARY`

Use `trendKey` to maintain separate trend series per client — e.g. `"trendKey": "client-acme"`.

***

### Use as an MCP tool

Add this actor to Claude Desktop, Cursor, or any MCP-compatible client via [Apify's MCP server](https://apify.com/apify/actors-mcp-server) and let your agent check AI brand visibility on demand.

***

### FAQ

**Do I need OpenAI / Anthropic / Google API keys?**
No. All API calls are made server-side and the cost is bundled into the per-check price.

**Which engine uses real web search?**
All four: `chatgpt` uses `gpt-4o-search-preview`, `perplexity` uses `sonar` (always web-backed), `gemini` uses `gemini-2.5-flash`, and `claude` uses `claude-sonnet-5` via OpenRouter.

**What if a response is truncated?**
The actor flags `response_truncated: true` on that row. A brand absent from a truncated response may simply not have been reached yet — treat it as inconclusive rather than a true "not mentioned."

**Can I track multiple clients without their data mixing?**
Yes — set a unique `trendKey` per client (e.g. `"client-acme"`, `"client-beta"`). Each series is stored separately.

**What's the difference between `mention_count` and `position_score`?**
`mention_count` is how many times the brand appeared in the response. `position_score` (1–10) measures *where* it first appeared — being named first scores 10, being buried at the end scores 1.

***

### More from dbott23

| Actor | What it does |
|---|---|
| [AI Citation Auditor](https://apify.com/dbott23/ai-citation-auditor) | Check if your website is cited by ChatGPT, Perplexity, and Gemini |
| [App Store & Google Play Reviews Scraper](https://apify.com/dbott23/appstore-reviews-scraper) | Export iOS and Android app reviews by keyword or app ID |
| [Trustpilot Reviews Scraper](https://apify.com/dbott23/trustpilot-reviews-scraper) | Export Trustpilot reviews to CSV or JSON — no API key needed |
| [B2B Reviews Scraper](https://apify.com/dbott23/b2b-reviews-scraper) | Pull reviews from G2, Capterra, and Trustpilot in one run |
| [Bluesky Posts Scraper](https://apify.com/dbott23/bluesky-posts-scraper) | Search and export Bluesky posts by keyword or user profile |

# Actor input Schema

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

One or more brands to track. Each: {"name": "Asana", "aliases": \[], "competitors": \["Trello", "Monday.com"]}. Batch as many brands as you like in one run.

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

Questions your customers ask AI assistants (e.g. "best project management tool for small teams").

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

Which engines to check.

## `trackTrends` (type: `boolean`):

Store this run's summary and report deltas vs your previous run — schedule weekly for automatic trend reports.

## `trendKey` (type: `string`):

Optional label to keep separate trend series (e.g. per client).

## Actor input object example

```json
{
  "brands": [
    {
      "name": "Asana",
      "aliases": [],
      "competitors": [
        "Trello",
        "Monday.com",
        "ClickUp"
      ]
    }
  ],
  "queries": [
    "best project management tool for small teams",
    "what project management software should a startup use"
  ],
  "engines": [
    "chatgpt",
    "perplexity",
    "gemini"
  ],
  "trackTrends": true
}
```

# 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 = {
    "brands": [
        {
            "name": "Asana",
            "aliases": [],
            "competitors": [
                "Trello",
                "Monday.com",
                "ClickUp"
            ]
        }
    ],
    "queries": [
        "best project management tool for small teams",
        "what project management software should a startup use"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dbott23/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 = {
    "brands": [{
            "name": "Asana",
            "aliases": [],
            "competitors": [
                "Trello",
                "Monday.com",
                "ClickUp",
            ],
        }],
    "queries": [
        "best project management tool for small teams",
        "what project management software should a startup use",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dbott23/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 '{
  "brands": [
    {
      "name": "Asana",
      "aliases": [],
      "competitors": [
        "Trello",
        "Monday.com",
        "ClickUp"
      ]
    }
  ],
  "queries": [
    "best project management tool for small teams",
    "what project management software should a startup use"
  ]
}' |
apify call dbott23/ai-visibility-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Brand Visibility Tracker",
        "description": "Track how AI assistants (ChatGPT, Perplexity, Gemini, Claude) mention your brand vs. competitors. Get mention rates, position scores, share of voice, and run-over-run trend deltas. Pay per check — no subscription.",
        "version": "0.0",
        "x-build-id": "9Q7CMwbe5K75rUvrZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dbott23~ai-visibility-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dbott23-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/dbott23~ai-visibility-tracker/runs": {
            "post": {
                "operationId": "runs-sync-dbott23-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/dbott23~ai-visibility-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-dbott23-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": [
                    "brands",
                    "queries"
                ],
                "properties": {
                    "brands": {
                        "title": "Brands",
                        "type": "array",
                        "description": "One or more brands to track. Each: {\"name\": \"Asana\", \"aliases\": [], \"competitors\": [\"Trello\", \"Monday.com\"]}. Batch as many brands as you like in one run."
                    },
                    "queries": {
                        "title": "Buyer queries",
                        "type": "array",
                        "description": "Questions your customers ask AI assistants (e.g. \"best project management tool for small teams\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "engines": {
                        "title": "AI engines",
                        "type": "array",
                        "description": "Which engines to check.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "chatgpt",
                                "perplexity",
                                "gemini",
                                "claude"
                            ]
                        },
                        "default": [
                            "chatgpt",
                            "perplexity",
                            "gemini"
                        ]
                    },
                    "trackTrends": {
                        "title": "Track trends (week-over-week deltas)",
                        "type": "boolean",
                        "description": "Store this run's summary and report deltas vs your previous run — schedule weekly for automatic trend reports.",
                        "default": true
                    },
                    "trendKey": {
                        "title": "Trend series key",
                        "type": "string",
                        "description": "Optional label to keep separate trend series (e.g. per client)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
