# AI Brand Visibility Report (`exepal/ai-brand-visibility`) Actor

Measure how often AI assistants recommend your brand vs competitors for real buyer questions. Share of voice, first-mention rate, sentiment, cited sources and missed prompts. Pay per report.

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

## Pricing

from $1,000.00 / 1,000 completed reports

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 Report

**Find out whether ChatGPT, Claude, Gemini and Perplexity recommend your brand — or your competitors — when people ask them what to buy.**

Search is moving into AI assistants. When someone asks "what's the best CRM for a small business?", the answer is a short list of brands, and either you're on it or you're not. This tool measures that, across engines, with real buyer questions, and tells you where you're missing.

### What you get

For one brand and its competitors, the Actor runs 5–50 buyer-intent questions ("best X for Y", "which X should I use", "top 5 X") against each AI engine and returns:

| Field | What it tells you |
|---|---|
| `score` | 0–100 composite AI visibility score |
| `engines[]` | Per engine: visibility %, first-mention rate, average rank, sentiment |
| `shareOfVoice[]` | Your brand vs each competitor, % of all brand mentions |
| `topCitedDomains[]` | Sites the engines lean on for this category (your fastest PR/SEO lever) |
| `missedPrompts[]` | Questions where a competitor was named and you weren't |
| `recommendations[]` | Plain-language next steps |
| `results[]` | Every prompt, answer, mention and citation (in `REPORT.json`) |

Example summary:

```json
{
  "brand": "Zoho",
  "score": 41,
  "engines": [
    { "engine": "openai", "visibility": 55, "firstMentionRate": 10, "avgRank": 1.8, "avgSentiment": 0.3 },
    { "engine": "perplexity", "visibility": 35, "firstMentionRate": 5, "avgRank": 2.1, "avgSentiment": 0.1 }
  ],
  "shareOfVoice": [
    { "brand": "HubSpot", "mentions": 38, "share": 46 },
    { "brand": "Salesforce", "mentions": 27, "share": 33 },
    { "brand": "Zoho", "mentions": 17, "share": 21 }
  ],
  "topCitedDomains": [{ "domain": "g2.com", "count": 14 }, { "domain": "forbes.com", "count": 9 }],
  "recommendations": ["HubSpot leads share of voice at 46%. Target the 11 prompts where it appears and you don't.", "..."]
}
```

### Who uses this

- **Agencies** adding "AI visibility" to SEO retainers (run monthly per client).
- **Brand and growth teams** tracking generative engine optimization (GEO).
- **AI agents** vetting a company's reputation before a recommendation.
- **SEO tools** that want a share-of-voice feed without building the pipeline.

### Pricing

Pay per event. No subscription.

- **$1.00 per completed report**
- **$0.03 per prompt check** (one engine × one prompt)

A standard run — 20 prompts on 4 engines — costs **$1.00 + 80 × $0.03 = $3.40**. A quick check of 5 prompts on one engine is $1.15.

Answers are cached for 24 hours, so re-running the same brand and category the same day costs you nothing extra upstream.

**Bring your own keys:** add your OpenAI/Anthropic/Google/Perplexity API keys in the input to use your own quota. The per-event prices stay the same; your upstream costs are then on your account.

### Input

| Field | Required | Notes |
|---|---|---|
| `brand` | yes | e.g. `Notion` |
| `category` | yes | what it is, in buyer language: `note-taking app` |
| `domain` | | `notion.so` — tightens matching |
| `competitors` | | `["Obsidian", "Evernote"]` |
| `market` | | `India`, `United States` — added to each prompt |
| `engines` | | subset of `openai`, `anthropic`, `google`, `perplexity` |
| `promptCount` | | 5–50, default 20 |
| `prompts` | | your own questions instead of generated ones |

### Use from code or an AI agent

**Apify API (Node):**

```js
import { ApifyClient } from "apify-client";
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("exepal/ai-brand-visibility").call({
  brand: "Notion", category: "note-taking app", competitors: ["Obsidian", "Evernote"], promptCount: 20
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].score, items[0].shareOfVoice);
```

**MCP (Claude, ChatGPT, Cursor):** add `exepal/ai-brand-visibility` to the Apify MCP server at `https://mcp.apify.com` and ask: *"Run an AI visibility report for Notion, a note-taking app, against Obsidian and Evernote."* The agent fills the input and pays per result.

**Direct HTTP with USDC (x402):** the same tool is available at `https://api.exepal.com/v1/ai-visibility` for agents that pay per request in stablecoins. See [exepal.com](https://exepal.com).

### How it works

1. Generates buyer-intent prompts for your category (or uses yours). Your brand is never in the prompt — this measures *unprompted* recall.
2. Queries each engine with a neutral system prompt asking for specific brand names.
3. Parses every answer for your brand and competitors: order of mention, frequency, sentence-level sentiment, cited URLs.
4. Aggregates into per-engine scores, share of voice, cited-domain ranking and missed prompts.

Gemini runs with Google Search grounding and Perplexity returns citations, so `topCitedDomains` shows which websites are shaping AI answers in your category.

### Limits and notes

- Results reflect the model versions and dates at run time; AI answers drift, so track monthly.
- Sentiment is lexicon-based and indicative, not a substitute for reading the snippets.
- Brand names that are common words (e.g. "Apple") may over-match; add `domain` and specific competitors to tighten.

### About Exepal

[Exepal](https://exepal.com) builds paid, agent-ready tools: upstream APIs in, computed answers out. Questions or custom runs: contact@laxmankafle.com

# Actor input Schema

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

The brand or product to measure, e.g. Notion

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

What the brand is, in buyer language. Used to generate the questions people ask AI assistants, e.g. "note-taking app" or "CRM for small business"

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

Brand website, improves mention matching, e.g. notion.so

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

Brands to compare share of voice against

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

Country or region to add to the prompts, e.g. United States, India, UK

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

Which assistants to query. Leave empty for all configured.

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

How many buyer-intent questions to run per engine (5–50). More prompts = more accurate, higher cost.

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

Supply your own questions instead of generated ones

## `openaiApiKey` (type: `string`):

Optional. Use your own OpenAI key so upstream usage is billed to your account. Leave empty to use Exepal's managed key.

## `anthropicApiKey` (type: `string`):

Optional. Use your own Anthropic key so upstream usage is billed to your account. Leave empty to use Exepal's managed key.

## `googleApiKey` (type: `string`):

Optional. Use your own Google AI key so upstream usage is billed to your account. Leave empty to use Exepal's managed key.

## `perplexityApiKey` (type: `string`):

Optional. Use your own Perplexity key so upstream usage is billed to your account. Leave empty to use Exepal's managed key.

## Actor input object example

```json
{
  "brand": "Notion",
  "category": "note-taking app",
  "competitors": [
    "Obsidian",
    "Evernote",
    "Coda"
  ],
  "promptCount": 20
}
```

# Actor output Schema

## `results` (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",
    "category": "note-taking app",
    "competitors": [
        "Obsidian",
        "Evernote",
        "Coda"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("exepal/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",
    "category": "note-taking app",
    "competitors": [
        "Obsidian",
        "Evernote",
        "Coda",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("exepal/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",
  "category": "note-taking app",
  "competitors": [
    "Obsidian",
    "Evernote",
    "Coda"
  ]
}' |
apify call exepal/ai-brand-visibility --silent --output-dataset

```

## MCP server setup

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