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

Measure how often your brand shows up when buyers ask AI assistants about your category. Get a 0–100 AI Visibility Score, share-of-voice vs. competitors, an opportunity-gap list, and a client-ready report — across ChatGPT and Claude.

- **URL**: https://apify.com/brodyfuller13/ai-brand-visibility.md
- **Developed by:** [Brody Fuller](https://apify.com/brodyfuller13) (community)
- **Categories:** SEO tools, AI, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Report

Track how often your brand is **mentioned and cited across ChatGPT, Claude, Gemini, and Perplexity** when buyers ask AI assistants about your category. Get a 0–100 visibility score, share-of-voice vs. competitors, per-engine breakdown, an opportunity-gap list, and a **client-ready HTML report** — not just raw rows.

> Keywords for store SEO (edit the store title/description to include these): AI visibility, GEO score, generative engine optimization, AEO, brand monitoring ChatGPT, AI search visibility, share of voice, Perplexity citations.

### What it does

1. Generates realistic, brand-agnostic **buyer prompts** for your category (or uses your own).
2. Runs each prompt across the AI engines you enable.
3. Detects, per answer: whether your **brand is mentioned**, its **position**, whether your **domain is cited**, and which **competitors** appear.
4. Aggregates into a **visibility score**, **share of voice**, **citation rate**, per-engine and per-competitor breakdowns, and a **gap list** (buyer questions where competitors show up and you don't).
5. Outputs: a structured dataset (one row per prompt×engine), a `REPORT` HTML deliverable, and an `OUTPUT` summary object.

### Inputs

- `brand` (required), `brandDomain`, `brandAliases`
- `competitors` (up to ~8)
- `industry` — used to auto-generate prompts, or supply `customPrompts`
- `promptCount` (default 25)
- `engines` — any of `openai`, `anthropic`, `perplexity`, `gemini`
- `analyzeSentiment` — optional extra pass
- API keys per provider (or set as environment variables / actor secrets)

### Outputs

- **Dataset** — per prompt×engine: mentioned, position, cited, competitors seen, sentiment.
- **Key-value `REPORT`** — a self-contained HTML report (prints to PDF).
- **Key-value `OUTPUT`** — headline metrics as JSON.

### Cost model (READ BEFORE PRICING)

Your cost of goods is **LLM API calls**: every prompt hits each enabled engine once
(plus one cheap call to generate prompts, plus one per mention if sentiment is on).
Estimate real token cost at your target `promptCount` × engines, then price the
per-event rate so tokens stay well under ~⅓ of what you charge. Benchmark on the
store is ~$40–70 / 1,000 prompts analyzed for this deliverable class.

### Honest measurement caveat

API responses are **not identical** to the consumer apps (e.g. the OpenAI API is not
the same as ChatGPT.com with live search). Perplexity's API is closest to real AI
search because it returns citations. Scores are **directional and best read as a trend
over time** — say this plainly in the listing; every serious tool in this space has the
same caveat.

### Run locally

```bash
npm install
export OPENAI_API_KEY=...        # + ANTHROPIC_API_KEY, GOOGLE_API_KEY, PERPLEXITY_API_KEY
apify run                        # or: npm start  (with an INPUT.json / apify CLI)
```

### Monetization

Set `chargePerPrompt: true` only on the published, pay-per-event actor. The event
name is `prompt-analyzed` (see `src/config.js`); configure the price in the Apify
monetization settings to match.

### Verify before shipping

Model IDs in `src/config.js` change often — confirm each against current provider docs.

# Actor input Schema

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

The brand you want to measure visibility for, e.g. "Notion".

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

Used for citation detection, e.g. "notion.so". Leave blank to skip citation matching.

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

Other names/spellings the brand goes by, so mentions aren't missed.

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

Up to ~8 competitor brand names to compare share-of-voice against.

## `industry` (type: `string`):

Used to auto-generate realistic buyer prompts, e.g. "team note-taking and docs software". Ignored if you supply custom prompts.

## `customPrompts` (type: `array`):

Supply your own buyer questions instead of auto-generating them. If provided, these are used as-is.

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

How many buyer prompts to generate and run (when not supplying custom prompts).

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

Which engines to run each prompt against.

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

Run one extra classification pass to label each brand mention positive/neutral/negative. Adds LLM cost.

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

Falls back to the OPENAI\_API\_KEY environment variable if left blank.

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

Falls back to the ANTHROPIC\_API\_KEY environment variable if left blank.

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

Falls back to the GOOGLE\_API\_KEY environment variable if left blank.

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

Falls back to the PERPLEXITY\_API\_KEY environment variable if left blank.

## `chargePerPrompt` (type: `boolean`):

For the monetized (pay-per-event) version. Leave OFF while developing/testing.

## Actor input object example

```json
{
  "brand": "Notion",
  "brandDomain": "notion.so",
  "competitors": [],
  "promptCount": 25,
  "engines": [
    "openai",
    "anthropic",
    "perplexity",
    "gemini"
  ],
  "analyzeSentiment": false,
  "chargePerPrompt": false
}
```

# 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 = {
    "competitors": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("brodyfuller13/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 = { "competitors": [] }

# Run the Actor and wait for it to finish
run = client.actor("brodyfuller13/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 '{
  "competitors": []
}' |
apify call brodyfuller13/ai-brand-visibility --silent --output-dataset

```

## MCP server setup

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