# AI Brand Visibility Tracker - GPT, Gemini & Claude Mentions (`actor-forge/ai-brand-visibility`) Actor

Check how AI models answer your buyers' questions: is your brand mentioned, at what rank and list position, with what sentiment, which competitors appear, which sites are cited, and your share of voice per model. GPT, Gemini, Claude, Llama or Sonar via OpenRouter. $0.01 per check + tokens.

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

## Pricing

from $10.00 / 1,000 prompt checks

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

## AI Brand Visibility Tracker - GPT, Gemini & Claude Mentions

Check how AI models answer your buyers' questions: is your brand mentioned, at what rank and list position, with what sentiment, which competitors appear, which sites are cited, and your share of voice per model. GPT, Gemini, Claude, Llama or Sonar via OpenRouter. $0.01 per check + tokens.

**See how AI assistants talk about your brand (generative engine optimisation, GEO / AEO).** Give it your brand, your competitors and the questions your buyers ask (*"best note-taking app for teams"*, *"cheapest CRM for startups"*, *"Notion vs Confluence"*), pick the AI models, and for every prompt × model you get: **is your brand mentioned, how often, its rank (order of first mention among you and your competitors), its position in the recommendation list, the sentiment around it, which competitors were named, which websites were cited** (web mode), whether **your own site** was cited, plus a per-model **share of voice** and mention rate. Models come through Apify's official OpenRouter actor: **OpenAI GPT (the model family behind ChatGPT), Google Gemini, Anthropic Claude, Meta Llama, Mistral, DeepSeek and Perplexity Sonar**. Use it to **track AI search visibility over time (schedule it weekly), benchmark against competitors, find which sources AI models trust, and measure the effect of content and PR on LLM answers**. Answers are analysed deterministically (no second AI call), so the analysis itself costs nothing. **$0.01 per check** plus the AI tokens at cost (a memory-mode check with the default models costs about $0.0003 in tokens on a paid plan).

#### Two lines on your bill (please read)

1. **This actor's fee:** `prompt-check`, **$0.01 per answered and analysed check** (one prompt × one model × one sample). Failed checks, the share-of-voice summary rows and status rows are free.
2. **AI tokens (and web-search fees in web mode), billed directly to your own Apify account** by Apify's official [OpenRouter actor](https://apify.com/apify/openrouter) at **OpenRouter's rates** (the run calls it with your run's own token; there is no extra API key and nothing is marked up by us). Memory mode is cheap (≈ $0.0001–0.0005 per check); web mode adds OpenRouter's web search, about **$0.02 per check**. **On the Apify free plan, Apify charges AI tokens at 10× the OpenRouter rate**, so web mode is best used on a paid plan.

Every check row shows its own **`llmCostUsd`** (estimated token charge on your account, 10× free-plan rate applied when it applies). **`maxLlmCostUsd` (default $0.10) is a hard cap on the token side**: each check's worst case (including the web-search fee) is reserved before the call and the run stops cleanly before passing it, and every call has a `max_tokens` limit. If a model is unavailable or your account has no credit left, you get a free row explaining what happened, and the run still succeeds.

### What data does it return?

Every run outputs clean, schema-validated rows like these:

| prompt | model | brandMentioned | brandRank | brandListPosition | brandSentiment | competitorsMentioned | llmCostUsd |
| --- | --- | --- | --- | --- | --- | --- | --- |
| best note-taking app for teams | google/gemini-2.5-flash-lite | true | 1 | 1 | positive | Evernote, Obsidian | 0.0028 |
| best note-taking app for teams | openai/gpt-4o-mini | true | 2 | 2 | positive | Evernote, Obsidian | 0.0041 |

### How much does it cost?

Transparent pay-per-event pricing — you only pay for what you get, and the
actor **always respects your run budget**: set a maximum total charge and it
stops cleanly at the cap instead of overrunning.

| Event | Price | Charged | Worked example |
| --- | --- | --- | --- |
| `prompt-check` | $0.01 | per prompt × model × sample answered and analysed (failed checks and summary rows are free) | 20 prompts × 3 models = 60 checks = $0.60 (+ AI tokens on your account, ≈ $0.02 in memory mode on a paid plan) |
| `apify-actor-start` | $0.00005 | per run per GB of memory (platform start fee) | One run at 0.25 GB = $0.0000125 |

### Input options

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `brand` | string | yes | — | The brand or product name to look for in AI answers (whole-word, case-insensitive). |
| `brandAliases` | array | no | — | Other spellings or product names that count as your brand, e.g. Notion AI, notion.so. |
| `brandDomain` | string | no | — | Optional, e.g. notion.so: sets brandCited when the answer cites your own site (most useful in web mode). |
| `competitors` | array | no | — | Competitor brands to compare against: each answer reports whether, where and how they are mentioned, and the summary gives share of voice. |
| `prompts` | array | yes | — | Questions your buyers ask AI assistants, e.g. "best note-taking app for teams", "Notion vs Confluence for documentation", "what CRM should a 10-person startup use". Each is sent as-is, without mentioning your brand. |
| `models` | array | no | `["openai/gpt-4o-mini","google/gemini-2.5-flash-lite"]` | OpenRouter model ids (openrouter.ai/models): openai/gpt-4o-mini (ChatGPT's model family), google/gemini-2.5-flash-lite (Gemini), anthropic/claude-3.5-haiku, meta-llama/llama-3.3-70b-instruct, perplexity/sonar (searches the web)… Reasoning models such as openai/gpt-5-nano are run with low reasoning effort. |
| `mode` | string | no | `"memory"` | Memory (default, cheapest): what the model says from its training. Web: the model searches the web first (OpenRouter :online web search, ≈ $0.02 per check on paid plans, 10× on the free plan; Perplexity Sonar searches natively) and its cited sources are reported. |
| `samplesPerPrompt` | integer | no | `1` | AI answers vary between runs; ask each prompt this many times per model for a steadier mention rate (each sample is one charged check). |
| `maxOutputTokens` | integer | no | `700` | max_tokens for each answer (reasoning models get at least 2,000). Recommendation answers usually need 400–800. |
| `maxLlmCostUsd` | number | no | `0.1` | Hard cap on the AI token (and web-search) charges this run may cause on your Apify account, estimated with the 10× free-plan rate when it applies. Each check's worst case is reserved before the call; the run stops cleanly before passing the cap. Separate from this actor's per-check fee, which the run's maximum total charge limits. |
| `includeAnswer` | boolean | no | `true` | Keep the model's full answer text in each row. |

### Limits & honest notes

- API answers are not identical to the consumer apps: ChatGPT, Gemini and Perplexity's apps add their own system prompts, memory, personalisation and live search. This actor asks the underlying models through their APIs (via OpenRouter), the same way for every brand, which makes it a consistent benchmark rather than a screenshot of one user's chat. It does not scrape or log in to chatgpt.com, gemini.google.com or perplexity.ai.
- AI tokens and web-search fees are a second, separate charge on your own Apify account, made by apify/openrouter at OpenRouter's rates (10× on the Apify free plan). They are not part of this actor's pay-per-event price and are not limited by the run's maximum total charge: use maxLlmCostUsd (default $0.10) to cap them.
- Answers vary from run to run (temperature 0.7, like a normal chat). Use samplesPerPrompt and repeat runs over time for trends; single answers are anecdotes.
- Mentions are matched as whole words (case-insensitive) on the brand, its aliases and competitor names; generic brand names (for example "Bear" or "Linear") may match ordinary words. Sentiment is a simple word-list heuristic over the sentences that name the brand.
- In memory mode models only cite URLs they write into the answer (often none); web mode reports the sources the search returned.
- If a model id is unknown or the AI service rejects the request, that check gets a free status row; with a single model the run stops early and still finishes as SUCCEEDED.

### Related ActorForge actors

- [AI Web Extractor](https://apify.com/actor-forge/ai-web-extractor) — structured data from any page with a prompt
- [News Search](https://apify.com/actor-forge/news-search) — track press coverage of your brand
- [Brand Mentions Monitor](https://apify.com/actor-forge/dev-community-mentions) — mentions on HN, Bluesky, Mastodon, GitHub and DEV

### Changelog

- **2026-10-23** — Initial release: brand + competitors + buyer prompts × OpenRouter models (memory or web mode) → mention, rank, list position, sentiment, competitors, citations and per-model share of voice; maxLlmCostUsd cap; apify/openrouter billed to the running account.

***

*Built and maintained by **ActorForge**. Reliability first: every actor in the
portfolio is monitored by an automated nightly self-test, and breakages are
typically fixed the same day.*

# Actor input Schema

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

The brand or product name to look for in AI answers (whole-word, case-insensitive).

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

Other spellings or product names that count as your brand, e.g. Notion AI, notion.so.

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

Optional, e.g. notion.so: sets brandCited when the answer cites your own site (most useful in web mode).

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

Competitor brands to compare against: each answer reports whether, where and how they are mentioned, and the summary gives share of voice.

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

Questions your buyers ask AI assistants, e.g. "best note-taking app for teams", "Notion vs Confluence for documentation", "what CRM should a 10-person startup use". Each is sent as-is, without mentioning your brand.

## `models` (type: `array`):

OpenRouter model ids (openrouter.ai/models): openai/gpt-4o-mini (ChatGPT's model family), google/gemini-2.5-flash-lite (Gemini), anthropic/claude-3.5-haiku, meta-llama/llama-3.3-70b-instruct, perplexity/sonar (searches the web)… Reasoning models such as openai/gpt-5-nano are run with low reasoning effort.

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

Memory (default, cheapest): what the model says from its training. Web: the model searches the web first (OpenRouter :online web search, ≈ $0.02 per check on paid plans, 10× on the free plan; Perplexity Sonar searches natively) and its cited sources are reported.

## `samplesPerPrompt` (type: `integer`):

AI answers vary between runs; ask each prompt this many times per model for a steadier mention rate (each sample is one charged check).

## `maxOutputTokens` (type: `integer`):

max_tokens for each answer (reasoning models get at least 2,000). Recommendation answers usually need 400–800.

## `maxLlmCostUsd` (type: `number`):

Hard cap on the AI token (and web-search) charges this run may cause on your Apify account, estimated with the 10× free-plan rate when it applies. Each check's worst case is reserved before the call; the run stops cleanly before passing the cap. Separate from this actor's per-check fee, which the run's maximum total charge limits.

## `includeAnswer` (type: `boolean`):

Keep the model's full answer text in each row.

## Actor input object example

```json
{
  "brand": "Notion",
  "competitors": [
    "Evernote",
    "Obsidian"
  ],
  "prompts": [
    "best note-taking app for teams"
  ],
  "models": [
    "google/gemini-2.5-flash-lite"
  ],
  "mode": "memory",
  "samplesPerPrompt": 1,
  "maxOutputTokens": 500,
  "maxLlmCostUsd": 0.005,
  "includeAnswer": true
}
```

# Actor output Schema

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

One row per prompt × model × sample with mention, rank, sentiment, competitors and citations, plus a share-of-voice summary per model.

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

Checks delivered and failed, LLM calls, AI token cost, why the run stopped and billing.

# 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",
    "competitors": [
        "Evernote",
        "Obsidian"
    ],
    "prompts": [
        "best note-taking app for teams"
    ],
    "models": [
        "google/gemini-2.5-flash-lite"
    ],
    "maxOutputTokens": 500,
    "maxLlmCostUsd": 0.005
};

// Run the Actor and wait for it to finish
const run = await client.actor("actor-forge/ai-brand-visibility").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",
    "competitors": [
        "Evernote",
        "Obsidian",
    ],
    "prompts": ["best note-taking app for teams"],
    "models": ["google/gemini-2.5-flash-lite"],
    "maxOutputTokens": 500,
    "maxLlmCostUsd": 0.005,
}

# Run the Actor and wait for it to finish
run = client.actor("actor-forge/ai-brand-visibility").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",
  "competitors": [
    "Evernote",
    "Obsidian"
  ],
  "prompts": [
    "best note-taking app for teams"
  ],
  "models": [
    "google/gemini-2.5-flash-lite"
  ],
  "maxOutputTokens": 500,
  "maxLlmCostUsd": 0.005
}' |
apify call actor-forge/ai-brand-visibility --silent --output-dataset

```

## MCP server setup

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

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/QDP689CQ9iIimvU0f/builds/PraOvxdHrkrhhS443/openapi.json