# LLM Brand Visibility Tracker – ChatGPT, Perplexity, Gemini (`gazidev/llm-brand-visibility-tracker`) Actor

Track if AI search engines recommend your brand. Ask Perplexity, OpenAI GPT and Gemini (official APIs with web search) your customers' questions; get mention, rank, share of voice vs competitors, cited URLs and sentiment. $0.01 per check.

- **URL**: https://apify.com/gazidev/llm-brand-visibility-tracker.md
- **Developed by:** [Cemal Atakli](https://apify.com/gazidev) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 visibility check (prompt x engine)s

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/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

## LLM Brand Visibility Tracker – ChatGPT, Perplexity, Gemini (AI Search Rank Tracker)

**Does AI recommend your brand?** This Actor asks AI answer engines the questions your customers ask, such as
*"What is the best CRM for small businesses?"*, and tells you whether your brand appears in the answer, at which
**rank**, your **share of voice** against competitors, whether your **website is cited as a source**, and the
**sentiment** of the answer. Use it for GEO (Generative Engine Optimization), AEO and AI SEO monitoring for **$0.01 per check**.

Engines (all with **live web search**, called through their **official APIs**):

| Engine | Model (OpenRouter ID) | Web search |
|---|---|---|
| Perplexity | `perplexity/sonar` | built in |
| OpenAI (ChatGPT model family) | `openai/gpt-5-mini` | OpenRouter web search |
| Google Gemini | `google/gemini-2.5-flash` | OpenRouter web search |
| Any other model (Claude, Grok, Llama, ...) | your OpenRouter ID in *Extra models* | added automatically |

> **Honest note:** results are **API answers with web search**. They can differ from what the consumer apps
> (chatgpt.com, perplexity.ai, gemini.google.com) show a logged-in user, because those apps add personalization,
> memory, location and their own system prompts. This Actor does **not** scrape ChatGPT or Google, so it does not
> break their terms. AI answers also change from run to run, so track trends over many prompts and schedule
> runs instead of reading too much into one answer.

### What you get per prompt x engine

- `mentioned`: whether your brand or one of its aliases is named
- `rank`: position in the recommendation list (`rankSource: "list"`), or order of first mention when the answer has no list
- `shareOfVoice`: your mentions divided by mentions of you plus your competitors
- `competitorsMentioned`, `competitorRanks`, `competitorMentionCounts`
- `domainCited` and `brandCitationUrls`: whether your domain is one of the cited sources
- `citationUrls`: every source URL the engine cited
- `sentiment` (positive / neutral / negative / mixed) with a short reason, plus an `excerpt` around your brand
- `answer` (full text), `model`, `tokens`, `llmCostUsd`
- `changed`, `previousMentioned`, `previousRank` for scheduled monitoring

There is also **one summary row per engine**: mention rate, average rank, top-3 rate, share of voice, domain
citation rate, sentiment breakdown, competitor share of voice and the domains cited most often. The same summary
is saved to the `OUTPUT` record of the key-value store.

### Use cases

- **AI search visibility / GEO reporting** for your brand or for agency clients
- **Competitor benchmarking**: who do ChatGPT, Perplexity and Gemini recommend instead of you?
- **Content and PR targeting**: `topCitedDomains` shows which sites AI engines trust in your niche, so you know where to get mentioned
- **Scheduled monitoring** with *Only save changed results*: get a row only when you enter or drop out of an answer
- **Product launches**: check whether AI already knows your new product

### How to use

1. Enter your **brand**, optional **aliases**, your **domain** and **competitors**.
2. Add the **prompts** your customers ask, written without your brand name. You can also leave prompts empty and
   fill **Category** + **Audience** to auto-generate up to 10 prompts such as "best X for Y".
3. Pick the **engines** and click Start. Each prompt x engine is one check.

#### Input example

```json
{
  "brand": "Notion",
  "aliases": ["Notion AI"],
  "domain": "notion.com",
  "competitors": ["Obsidian", "Evernote", "Coda", "ClickUp", "Confluence"],
  "prompts": [
    "What are the best note-taking apps for startup teams?",
    "Which wiki or knowledge base tool should a small remote team use?"
  ],
  "engines": ["perplexity", "chatgpt", "gemini"]
}
```

#### Output example (one check)

```json
{
  "type": "check",
  "engine": "perplexity",
  "model": "perplexity/sonar",
  "prompt": "What are the best note-taking apps for startup teams?",
  "mentioned": true,
  "rank": 1,
  "rankSource": "list",
  "shareOfVoice": 0.42,
  "competitorsMentioned": ["Obsidian", "Evernote", "ClickUp"],
  "competitorRanks": {"Obsidian": 3, "Evernote": 4, "ClickUp": 2},
  "domainCited": true,
  "brandCitationUrls": ["https://www.notion.com/product"],
  "citationUrls": ["https://www.notion.com/product", "https://zapier.com/blog/best-note-taking-apps/"],
  "sentiment": "positive",
  "sentimentReason": "Recommended as the most flexible all-in-one workspace",
  "excerpt": "1. Notion - an all-in-one workspace for notes, docs and wikis ...",
  "changed": true,
  "error": null
}
```

### Pricing

Pay per event, with no subscription:

| Event | Price |
|---|---|
| `visibility-check`: one prompt answered by one engine and analyzed | **$0.01** |
| `summary-report`: per-engine summary, once per run | **$0.02** |

**Failed checks are free.** The run stops cleanly at your *maximum total charge per run*, and checks that do not
fit the budget are not started.

**LLM tokens and web search** are billed separately to your Apify account by Apify's
[OpenRouter Actor](https://apify.com/apify/openrouter), so you need no OpenAI, Perplexity or Google key. The typical cost
per check on a paid Apify plan is about $0.006 with Perplexity Sonar and about $0.01-0.015 with GPT or Gemini plus web
search, mostly the search fee of the provider. Sentiment adds about $0.0001.

**Example:** 20 prompts x 3 engines = 60 checks = $0.60 + $0.02 summary + about $0.60 tokens, so roughly **$1.20 per weekly report**.

#### Compared with alternatives (Apify Store, October 2026)

| Tool | Method | Price per check |
|---|---|---|
| **This Actor** | official APIs + web search | **$0.01** + tokens (about $0.02 total) |
| ChatGPT / Perplexity search scrapers | scrapes the consumer UI | $0.20 per result |
| Other API-based AI rank trackers | APIs | $0.05 to $0.30 per check |
| SaaS brand-monitoring suites | subscription | from about $199/month |

### FAQ

**Is this the same answer I see in ChatGPT?** It is not guaranteed to be. It is the answer of the OpenAI model through the API with
web search enabled. The consumer app uses other system prompts, memory and personalization. The API approach is
reproducible, legal and cheap, which makes it good for trends and comparisons.

**Why are answers different on every run?** LLMs are not deterministic and web results change. Use 10 or more prompts and
look at rates such as mention rate and share of voice over time.

**How is the rank computed?** The Actor finds the main list in the answer (numbered headings, numbered items, bullets
or bold product names) and reports the position of the item that names your brand. If the answer has no list,
`rank` is the order of first mention among your brand and competitors (`rankSource: "mentionOrder"`).

**Should prompts contain my brand name?** No. Neutral prompts measure organic visibility. Prompts with your brand name, such as
"Is Notion good for startups?", are useful for sentiment only.

**Can I monitor daily or weekly?** Yes. Create a schedule and enable *Only save changed results*. The previous state
is kept in a named key-value store (*State store name*). Use one name per brand.

**Which other models can I add?** Any OpenRouter model ID, for example `anthropic/claude-sonnet-4.5` or `x-ai/grok-4.7`.
Web search is added automatically.

**Why did a run fail with HTTP 401/402?** The run token could not call `apify/openrouter`, or your Apify account has no
credit for tokens. The run ends with a clear error row and nothing is charged.

### Use with AI agents (Apify MCP)

This Actor works as a tool in the [Apify MCP server](https://mcp.apify.com): an agent can call
`llm-brand-visibility-tracker` with `brand`, `competitors` and `prompts` and read the summary rows to answer
"How visible is my brand in AI search compared with competitors?". You can also call it through the Apify API,
or run it on a schedule and send the dataset to Google Sheets, Slack or a webhook.

# Actor input Schema

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

The brand, product or company to track in AI answers, e.g. "Notion". Matching is case-insensitive and on whole words.

## `aliases` (type: `array`):

Other names that count as a mention of your brand, e.g. product names, old names or spellings ("Notion AI", "Notion Labs").

## `domain` (type: `string`):

Your domain, e.g. "notion.com". Used to detect whether the AI engine cites your website as a source (subdomains count too).

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

Competitor brand names. Used for share of voice, competitor ranks and competitor mention rates (max 30).

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

Questions your customers ask ChatGPT, Perplexity or Gemini, e.g. "What is the best note-taking app for startups?". Write them neutrally (without your brand name) to measure organic visibility. Leave empty to auto-generate prompts from Category + Audience.

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

Used only when Prompts is empty: your product category in plural, e.g. "CRM software" or "running shoes". Generates prompts like "What are the best CRM software for small businesses?".

## `audience` (type: `string`):

Used only with Category: who is asking, e.g. "small businesses", "marathon beginners". Default: small businesses.

## `maxAutoPrompts` (type: `integer`):

How many prompts to generate from Category + Audience (1-10).

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

Answer engines to ask. All are called through their official APIs with live web search via Apify's OpenRouter Actor. Each prompt x engine is one check.

## `customModels` (type: `array`):

Optional extra OpenRouter model IDs to check, e.g. "anthropic/claude-sonnet-4.5" or "x-ai/grok-4.7". Web search is added automatically (except perplexity/\* and IDs ending in :online). See openrouter.ai/models.

## `userLocation` (type: `string`):

Optional country or city to simulate a local user, e.g. "Germany" or "Austin, Texas". Added to the instructions as context.

## `answerLanguage` (type: `string`):

Optional language for the answers, e.g. "German". Empty = language of the prompt.

## `analyzeSentiment` (type: `boolean`):

When your brand is mentioned, rate how the answer portrays it (positive / neutral / negative / mixed) with a small extra call to gemini-2.5-flash-lite (about $0.0001 in tokens).

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

Save the complete AI answer in each row (the excerpt around your brand is always saved).

## `onlyChanged` (type: `boolean`):

For scheduled runs: remember the last result per prompt x engine and only save rows whose mention, rank, domain citation or sentiment changed. Every check is still performed and charged; summary rows are always saved.

## `stateStoreName` (type: `string`):

Name of the key-value store that remembers previous results for "Only save changed results". Use a different name per brand/project.

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

Safety limit on the number of prompts per run. Checks = prompts x engines.

## `concurrency` (type: `integer`):

How many checks run at the same time.

## Actor input object example

```json
{
  "brand": "Notion",
  "aliases": [
    "Notion AI"
  ],
  "domain": "notion.com",
  "competitors": [
    "Obsidian",
    "Evernote",
    "Coda",
    "ClickUp",
    "Confluence"
  ],
  "prompts": [
    "What are the best note-taking apps for startup teams?",
    "Which wiki or knowledge base tool should a small remote team use?"
  ],
  "maxAutoPrompts": 5,
  "engines": [
    "perplexity",
    "chatgpt"
  ],
  "analyzeSentiment": true,
  "includeFullAnswer": true,
  "onlyChanged": false,
  "stateStoreName": "llm-brand-visibility-state",
  "maxPrompts": 50,
  "concurrency": 4
}
```

# Actor output Schema

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

No description

## `csv` (type: `string`):

No description

## `summary` (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 = {
    "brand": "Notion",
    "aliases": [
        "Notion AI"
    ],
    "domain": "notion.com",
    "competitors": [
        "Obsidian",
        "Evernote",
        "Coda",
        "ClickUp",
        "Confluence"
    ],
    "prompts": [
        "What are the best note-taking apps for startup teams?",
        "Which wiki or knowledge base tool should a small remote team use?"
    ],
    "engines": [
        "perplexity",
        "chatgpt"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gazidev/llm-brand-visibility-tracker").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "brand": "Notion",
    "aliases": ["Notion AI"],
    "domain": "notion.com",
    "competitors": [
        "Obsidian",
        "Evernote",
        "Coda",
        "ClickUp",
        "Confluence",
    ],
    "prompts": [
        "What are the best note-taking apps for startup teams?",
        "Which wiki or knowledge base tool should a small remote team use?",
    ],
    "engines": [
        "perplexity",
        "chatgpt",
    ],
}

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

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

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

```

## CLI example

```bash
echo '{
  "brand": "Notion",
  "aliases": [
    "Notion AI"
  ],
  "domain": "notion.com",
  "competitors": [
    "Obsidian",
    "Evernote",
    "Coda",
    "ClickUp",
    "Confluence"
  ],
  "prompts": [
    "What are the best note-taking apps for startup teams?",
    "Which wiki or knowledge base tool should a small remote team use?"
  ],
  "engines": [
    "perplexity",
    "chatgpt"
  ]
}' |
apify call gazidev/llm-brand-visibility-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gazidev/llm-brand-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/4QLn7VNdcRVTIdcI2/builds/ha8lNTyM6MfwLMPKp/openapi.json