# AI Share of Voice - Brand Visibility in LLM Answers (`centorprat/ai-share-of-voice`) Actor

Measure how often AI models recommend your brand: asks GPT, Gemini, Claude, Perplexity and more your buyers' questions, then reports mention rate, list position, share of voice vs competitors, AI-discovered rivals, cited sources and fixes. No API keys.

- **URL**: https://apify.com/centorprat/ai-share-of-voice.md
- **Developed by:** [Centor Prat](https://apify.com/centorprat) (community)
- **Categories:** AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.30 / 1,000 ai answer analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Share of Voice — How Often AI Models Recommend Your Brand

When buyers ask an AI "what's the best CRM?", are you in the answer? This Actor asks several AI models the questions your buyers actually ask: OpenAI GPT, Google Gemini, Anthropic Claude, Perplexity Sonar (live web + citations), and optionally DeepSeek, Llama and Grok. It then measures your brand in every answer:

- **mention rate**, **list position**, **share of voice** vs competitors
- **competitors the AI recommends that you didn't even list**
- the **live-web vs model-memory gap** (are you in today's search results, in what the model has learned, or both?)
- **which sources AI cites** for your category (where to get mentioned)
- **framing** of your mentions, **lost prompts**, and **prioritised actions**

**No API keys.** Models are called through Apify's own OpenRouter proxy, so model usage is billed to your Apify account at cost. Agent-callable.

Built for marketing, SEO/GEO and brand teams, and the agencies who serve them, tracking "AI search visibility" (GEO / AEO).

### Why this one

| | Typical AI-visibility trackers | This Actor |
|---|---|---|
| Cost | $0.05–$0.30 per query / platform check | **$0.005 per answer + model cost** (cents per run) |
| Setup | some need your own OpenAI / Perplexity keys | **no keys**: billed through your Apify account |
| Competitors | only the ones you type | **also discovers the brands AI recommends instead** |
| Live web vs memory | one number | **split**: live-web engines vs model-memory engines, with the gap explained |
| Sources | rarely | **cited domains** across answers, and whether your site is cited |
| Output | mention yes/no | score, position, SoV, leaderboard, intents, framing, lost prompts, **actions** |

### How it works

1. **Prompts:** give a `category` and the Actor generates realistic buyer prompts (discovery, recommendation, small-business / enterprise, alternatives, comparison vs your top competitor, budget, perception). Or give your own `prompts`.
2. **Engines:** each prompt goes to each selected model. *Memory* engines answer from training data; *web* engines (Perplexity Sonar, GPT with web search) search the live web and cite sources.
3. **Analysis:** deterministic parsing; no LLM grades another LLM. It detects your brand and aliases, list rank, first mention, competitors, list entities (to discover rivals), framing words around your mention, and cited URLs.
4. **Report:** visibility score (0–100) and verdict (`ai-dominant` / `ai-visible` / `ai-emerging` / `ai-invisible`), plus everything above and every analysed answer.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `brand` | string | ✅ | Company/product to track. |
| `category` | string | ✅\* | What buyers search for, e.g. "note-taking apps". |
| `competitors` | array | | Competitors to benchmark (others are discovered automatically). |
| `brandAliases` | array | | Other names models may use. |
| `brandDomain` | string | | Your site, e.g. `notion.com` (citation check + AI-crawler site audit). |
| `auditSite` | boolean | | Test your site for AI crawlers and link root causes (default on with a domain). |
| `prompts` | array | ✅\* | Your own buyer questions instead of the generated set. |
| `engines` | array | | API: `openai-gpt`, `google-gemini`, `anthropic-claude`, `perplexity-sonar`, `openai-gpt-web`, `deepseek`, `meta-llama`, `xai-grok`. Real apps: `app-chatgpt`, `app-perplexity`, `app-gemini`, `app-copilot`, `app-google-ai-mode`, `app-google-ai-overview`. |
| `countryCode` | string | | Country for the app engines (e.g. `us`). |
| `maxPrompts` | integer | | Prompts per engine (default 8). |
| `samplesPerPrompt` | integer | | Repeat each prompt to average out randomness (default 1). |
| `market` | string | | Localise prompts to a country/region. |
| `includeFullAnswers` | boolean | | Return full answer texts too. |
| `historyStore` | key-value store | | Your store for trend tracking (see below). |
| `webhookUrl` | string | | POST the report here. |

\* `category` or `prompts`.

**Example input**

```json
{ "brand": "Notion", "category": "note-taking apps", "competitors": ["Evernote", "Obsidian"], "brandDomain": "notion.com" }
```

### Output

One report per run. **Example** (real run, 2 prompts × 4 engines, trimmed):

```json
{
  "brand": "Notion",
  "visibilityScore": 69,
  "signal": "ai-visible",
  "mentionRatePct": 88,
  "shareOfVoicePct": 15.9,
  "avgListPosition": 3.5,
  "liveWebMentionRatePct": 100,
  "modelMemoryMentionRatePct": 83,
  "byEngine": {
    "openai-gpt": {"mentionRatePct": 100, "avgListRank": 5},
    "google-gemini": {"mentionRatePct": 50, "avgListRank": 2},
    "anthropic-claude": {"mentionRatePct": 100, "avgListRank": 1},
    "perplexity-sonar": {"mentionRatePct": 100, "avgListRank": 4, "lens": "web"}
  },
  "leaderboard": [
    {"rank": 1, "name": "Notion", "isYou": true, "mentionRatePct": 88},
    {"rank": 2, "name": "Google Keep", "mentionRatePct": 75, "discovered": true},
    {"rank": 3, "name": "Apple Notes", "mentionRatePct": 75, "discovered": true},
    {"rank": 4, "name": "Evernote", "mentionRatePct": 62}
  ],
  "citedDomains": [{"domain": "theverge.com", "answers": 2}, {"domain": "wired.com", "answers": 2}, {"domain": "zapier.com", "answers": 2}],
  "yourDomainCitedInAnswers": 0,
  "actions": [
    {"priority": "medium", "action": "Your domain isn't cited. AI cites these sources for your category - earn a mention/listing there: pocket-lint.com, clickup.com, theverge.com, wired.com, tomsguide.com."},
    {"priority": "low", "action": "AI also recommends brands you didn't list: Google Keep, Apple Notes, Microsoft OneNote, Bear, Roam Research - add them to your competitor set."}
  ],
  "llmCostUsd": 0.01491
}
```

Model cost for that whole run was **$0.015** (paid-plan rate).

### AI visibility audit: visibility + root causes in one call

Give your `brandDomain` and the report also tests **your site the way AI bots see it**:

- robots.txt per AI bot (search vs training)
- a live fetch as each bot vs a browser, to catch CDN/firewall blocks
- JavaScript-only content
- llms.txt
- Organization / sameAs schema

It then **links the findings to your visibility numbers** in `siteDiagnosis`, with root-cause actions at the top of `actions`. For example: *"ROOT CAUSE: AI answer bots can't fetch your site (OAI-SearchBot, PerplexityBot blocked…) - this caps your live-web mention rate"*. Or, when the site is fully readable: *"the gap is OFF-site - earn mentions on the domains AI cites"*. Included in the report price (`auditSite: false` turns it off).

### Real consumer apps + API-vs-app calibration

Besides the cheap API engines, you can add the **real consumer products** as `app` engines: **ChatGPT search, Perplexity, Gemini, Microsoft Copilot, Google AI Mode and Google AI Overviews**. These run through Apify's own scrapers, billed to your account per prompt (~$0.20; Google AI Overviews ~$0.003). They capture what a real user sees, including each app's own live browsing and citations.

Mix API and app engines and the report adds **`apiVsAppCalibration`**: on the same prompts, how often the cheap API engines agree with the real apps about whether you're mentioned. High agreement means you can **track weekly via API for cents and spot-check the apps monthly**. Low agreement means you should keep the apps in your tracking. `googleAiOverviewShownPct` tells you how often Google even shows an AI Overview for your prompts.

Real check from our tests (HubSpot, "CRM software"):

- **Google AI Overviews:** shown for 100% of prompts, HubSpot in 100%, citing forbes.com, g2.com and business.com.
- **ChatGPT search (real app):** ranked HubSpot #1 and cited hubspot.com.
- **API vs app agreement:** 100%.

### Track trends over time (GEO monitoring)

Pick a key-value store in **`historyStore`** (create one in the picker) and schedule the Actor, say weekly. Each run saves a snapshot per brand + category and adds a `trend` block plus `trendAlerts`:

- change in visibility score, mention rate, share of voice, live-web and memory rates
- per-engine moves (e.g. "openai-gpt now mentions you 40 points less often")
- **rising competitors** and **new competitors** appearing in AI answers
- **newly cited / dropped source domains**
- a visibility series for charts

The store is yours, and the Actor only gets access to the store you select.

### Use cases

- **GEO / AEO tracking:** schedule weekly and watch mention rate and share of voice move.
- **Competitive intelligence:** who AI recommends in your category, and for which intents.
- **Content & PR planning:** the cited domains are your outreach list; lost prompts are your content gaps.
- **Agency reporting:** one structured report per client brand.
- **AI agents:** "is brand X recommended by AI for Y?" in one call, with a `summary` line.

### One API call, JSON back

Run it synchronously: one POST starts the run and returns the results in the same response. No run to poll, which is what an AI agent wants mid-task:

```bash
curl -X POST "https://api.apify.com/v2/acts/centorprat~ai-share-of-voice/run-sync-get-dataset-items" -H "Authorization: Bearer <APIFY_TOKEN>" \
     -H "Content-Type: application/json" -d '{"brand": "Notion", "category": "note-taking apps", "competitors": ["Evernote"], "engines": ["openai-gpt", "perplexity-sonar"], "maxPrompts": 4}'
```

The body takes the same fields as the normal input. Same pay-per-event price; failed checks aren't charged.

### Ready-made tasks

- [Brand Visibility in ChatGPT-class AI Answers](https://apify.com/centorprat/ai-share-of-voice/examples/chatgpt-brand-visibility-check)
- [Which Sources Does AI Cite for Your Category?](https://apify.com/centorprat/ai-share-of-voice/examples/ai-citation-sources-for-category)

### For AI agents / MCP

```
https://mcp.apify.com/?tools=actors,docs,centorprat/ai-share-of-voice
```

Loads as `centorprat--ai-share-of-voice`. Claude Code:

```
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors centorprat/ai-share-of-voice
```

### FAQ

**Is this the same as the ChatGPT app?** The default engines query the models through their APIs (the model families behind ChatGPT, Gemini, Claude and Perplexity). Add the `app-*` engines to capture the real consumer apps as well. API answers can differ from the consumer apps, which add their own browsing and personalisation. Use the trend across repeated runs, which is what matters for GEO.

**Why do answers vary between runs?** LLMs are non-deterministic. Use `samplesPerPrompt` (2–3) for steadier numbers, and track over time.

**What do "web" and "memory" mean?** Memory engines answer from what the model learned in training, which reflects your long-term footprint. Web engines search the live web first, which reflects today's content and citations. A big gap between the two tells you which kind of work to do.

**Do I need API keys?** No. The Actor uses Apify's OpenRouter proxy with your Apify account. Note that Apify bills model usage on its Free plan at 10× the paid-plan rate.

**What does it cost?** $0.005 per analysed answer + $0.05 per report, plus model usage. A default run of 8 prompts × 4 engines (32 answers) costs $0.21 + model usage: about $0.07 on a paid Apify plan, more on the Free plan.

**Does it use an LLM to judge the answers?** No. Mention, position, competitor and citation analysis is deterministic text parsing, so the same answers always give the same scores.

### Data & attribution

Answers generated by third-party AI models via OpenRouter, accessed through Apify's OpenRouter proxy. These are visibility signals for marketing and research, not guarantees of how any AI product will answer a given user.

### Related actors

- [AI Overview Citation Tracker](https://apify.com/centorprat/ai-overview-citation-tracker): cited vs ranking on Google's AI Overviews, click-loss risk per keyword.
- [AI Crawler Access Test](https://apify.com/centorprat/ai-crawler-access-test): can GPTBot, ClaudeBot and PerplexityBot actually read your site?
- [On-Page SEO Audit](https://apify.com/centorprat/on-page-seo-audit)

# Actor input Schema

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

The company or product name to track (e.g. "Notion").

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

What buyers search for, in plain words (e.g. "note-taking apps", "CRM software for startups"). Used to generate realistic buyer prompts (discovery, recommendation, alternatives, comparison, budget, perception).

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

Competitor names to benchmark against (e.g. "Evernote", "Obsidian"). The report also lists competitors the AI recommends that you didn't name.

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

Other names the models may use for you (product names, old names, abbreviations).

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

e.g. "notion.com" - reports whether AI answers cite your site and (with 'Audit my site') tests whether AI bots can read it.

## `auditSite` (type: `boolean`):

With a domain set, also test your site the way AI bots see it (robots.txt per AI bot, live bot fetch vs browser, JS-only content, llms.txt, Organization schema) and link the findings to your visibility numbers as root causes. Included in the report price.

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

Use your own buyer questions instead of the generated set (one per line).

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

Which AI engines to ask. API engines (cheap, billed at model cost): 'memory' answer from training data, 'web' search the live web. 'app' engines capture the REAL consumer products (ChatGPT search, Perplexity, Gemini, Copilot, Google AI Mode / AI Overviews) via Apify's own scrapers, billed to your account per prompt (~$0.20; Google AI Overviews ~$0.003). Mixing API + app engines adds an API-vs-app calibration. The form starts with one engine so a first try costs a fraction of a cent.

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

How many buyer prompts to ask each engine.

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

Ask each prompt more than once per engine to average out answer randomness (costs more).

## `market` (type: `string`):

Country or region to localise the prompts (e.g. "Germany").

## `countryCode` (type: `string`):

Two-letter country code passed to the consumer-app scrapers (e.g. "us", "gb", "de").

## `includeFullAnswers` (type: `boolean`):

Also return the full text of every model answer (bigger output).

## `historyStore` (type: `string`):

Pick (or create) a key-value store to keep a snapshot per brand+category. Each run then reports what changed since the last run: visibility, mention rate, share of voice, per-engine moves, rising/new competitors, new/dropped cited domains - plus alerts. Schedule the Actor weekly for GEO tracking.

## `webhookUrl` (type: `string`):

If set, the finished report is POSTed here as JSON when the run completes.

## Actor input object example

```json
{
  "brand": "Notion",
  "category": "note-taking apps",
  "competitors": [
    "Evernote",
    "Obsidian"
  ],
  "auditSite": true,
  "engines": [
    "openai-gpt"
  ],
  "maxPrompts": 2,
  "samplesPerPrompt": 1,
  "includeFullAnswers": false
}
```

# Actor output Schema

## `report` (type: `string`):

One report: visibility score + verdict, mention rate, share of voice, average list position, top-3 and first-mention rates, per-engine and per-intent breakdowns, live-web vs model-memory gap, competitor leaderboard (named + AI-discovered), cited domains, framing, lost prompts, prioritised actions and every analysed answer.

# 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",
    "category": "note-taking apps",
    "competitors": [
        "Evernote",
        "Obsidian"
    ],
    "engines": [
        "openai-gpt"
    ],
    "maxPrompts": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/ai-share-of-voice").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",
    "category": "note-taking apps",
    "competitors": [
        "Evernote",
        "Obsidian",
    ],
    "engines": ["openai-gpt"],
    "maxPrompts": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("centorprat/ai-share-of-voice").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",
  "category": "note-taking apps",
  "competitors": [
    "Evernote",
    "Obsidian"
  ],
  "engines": [
    "openai-gpt"
  ],
  "maxPrompts": 2
}' |
apify call centorprat/ai-share-of-voice --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/ai-share-of-voice"
        }
    }
}
```

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/UT4mWYCaBilixOkqq/builds/eyJJUvmbVO6Gzb5ly/openapi.json