# AI Brand Visibility Tracker: ChatGPT & LLMs, No API Key (`signalwharf/ai-brand-visibility-tracker-managed`) Actor

AI brand visibility & LLM visibility tracker for AI SEO, GEO and AEO. See if ChatGPT, Claude, Gemini and Perplexity mention and recommend your brand: mentions, rank, competitors, share of voice, snippets. No API key, no subscription: $0.08 per AI check.

- **URL**: https://apify.com/signalwharf/ai-brand-visibility-tracker-managed.md
- **Developed by:** [Signal Wharf](https://apify.com/signalwharf) (community)
- **Categories:** AI, SEO tools, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $80.00 / 1,000 ai 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

## See if ChatGPT recommends your brand

When a customer asks ChatGPT, Claude, Gemini or Perplexity "what's the best tool for X?", is your brand in the answer? Is it first, or fifth? Which competitors show up instead?

It's an **AI visibility tracker** for AI SEO, GEO (generative engine optimization) and AEO (answer engine optimization): it measures your **LLM visibility**, **AI brand mentions** and **share of voice in AI search** against your competitors.

This Actor asks AI assistants the questions your customers ask and tells you, for every answer:

- **Mentioned or not**: is your brand in the answer at all
- **Position**: where you appear in the list of recommendations, and the order brands are mentioned
- **Competitors**: which of your competitors were mentioned, and other brands the AI recommended that you might not be tracking
- **Snippet**: the exact sentence the AI used about you
- **Sentiment and citations**: whether the wording is positive, and which websites the AI cited (when web search is on)

At the end of each run you get a **visibility report**: a visibility score, share of voice against your competitors, a leaderboard, and the prompts where you're missing. Run it again next week or next month with the same tracking ID to see what changed.

**No API key, no AI account and no setup needed.** You pay per AI check, and there's no $95+/month subscription.

### Who it's for

- **Marketers and founders** who want to know whether AI assistants recommend them
- **Small agencies and freelancers** who want to add an "AI visibility" check to SEO or content reports without paying for another platform
- **Anyone testing GEO/AEO changes** (generative engine optimization) who wants a before and after

### How it works

1. Enter your brand (plus optional aliases and your website), e.g. `Trello | trello.com`
2. Add a few competitors, e.g. `Asana | asana.com`
3. Add the questions your customers would ask AI, e.g. "What is the best project management tool for a small marketing team?"
4. Pick the AI models. The example uses OpenAI and Anthropic Claude. Add Google Gemini and Perplexity for a broader view, or clear the list to use all four.
5. Click **Start**.

Results are ready in about a minute. Download them as CSV, Excel or JSON, or connect them to Google Sheets, Slack or Zapier with Apify integrations.

### Sample output

This is a real run: brand **Trello**, competitor **Asana**, 3 prompts, 2 models, 6 AI checks.

| Prompt | Model | Trello mentioned | List position | Mention order | Asana mentioned | Other names in the answer | Snippet |
|---|---|---|---|---|---|---|---|
| 1 | openai/gpt-6-luna | Yes | 1 | 2 | Yes | ClickUp, Monday.com, Notion | Trello — best if you want a very simple, visual Kanban board. - ClickUp — best if you want lots of features... |
| 1 | perplexity/sonar | Yes | 1 | 2 | Yes | Monday.com, ClickUp, Basecamp | Trello if you want the simplest visual Kanban workflow with minimal setup. - Monday.com if you want more... |
| 2 | openai/gpt-6-luna | Yes | - | 1 | No | - | I’d recommend Trello for most freelancers: it’s easy to set up, and a simple board—To do → In progress →... |
| 2 | perplexity/sonar | Yes | 1 | 1 | Yes | KanbanFlow, ClickUp, Notion | For most freelancers, the best free Kanban options are Trello for simplicity and ecosystem, and KanbanFlow if... |
| 3 | openai/gpt-6-luna | Yes | 3 | 2 | Yes | Linear | Very lightweight needs: Trello can be enough. If you’re unsure, I’d pick Asana for a cross-functional team or... |
| 3 | perplexity/sonar | Yes | - | 1 | Yes | Jira, ONES Project, Notion | For a 10‑person startup, use a simple, low‑friction tool with a good free plan—for most teams that means... |

*Mention order* is where Trello comes among all tracked brands mentioned in the answer. *List position* is its place in the answer's recommendation list (a dash means it was mentioned in the text, not in a ranked list).

In the combined report, Trello was mentioned in 100% of answers with a visibility score of 78.8, against 83% of answers for Asana (score 71.6). Trello's share of voice between the two was 55%.

### Pricing

**$0.08 per AI check.** One check is one question answered by one AI model and analyzed. AI model costs are included. Visibility reports are included at no extra charge. Failed AI calls are free.

| Example | Checks | Cost |
|---|---|---|
| 5 questions x 4 models | 20 | $1.60 |
| 10 questions x 4 models | 40 | $3.20 |
| 10 questions x 4 models x 3 samples (for stable tracking) | 120 | $9.60 |

There's no monthly subscription. You pay only when you run it. Each run is capped at 50 checks by default (up to 200), and you can set your own maximum cost per run in Apify, so you always know the most a run can cost.

**Prefer to use your own AI key?** Add your own OpenRouter (or OpenAI, Anthropic, Gemini, Perplexity, xAI) key under "Optional: use your own API key". The run then uses your key and any model you choose, and costs $0.005 per answer plus $0.02 per report. Your AI provider bills you directly for the AI usage.

### Models available without a key

| Model | Notes |
|---|---|
| `openai/gpt-6-luna` | OpenAI (the models behind ChatGPT) |
| `anthropic/claude-haiku-5.5` | Anthropic Claude |
| `google/gemini-3.5-flash-lite` | Google Gemini |
| `perplexity/sonar` | Perplexity: always searches the web and cites sources |
| `x-ai/grok-4.3` | xAI Grok |
| `google/gemini-2.5-flash-lite`, `deepseek/deepseek-v4.1-flash`, `meta-llama/llama-4-maverick` | Extra options |

If you leave the model list empty, the first four are used. Answers come from each model's API, which is close to, but not identical to, what a logged-in user sees in the consumer apps (those can add personalization, memory or location).

### Tips for reliable results

- **Ask like a customer.** "Best CRM for a 5-person real estate team" is better than "CRM".
- **Use 5 to 15 prompts** that cover the ways people search for what you sell.
- **Use 3 samples per prompt** for tracking over time. AI answers vary from run to run, and samples smooth that out.
- **Keep the same tracking ID** so each report compares against your last run.
- **Turn on web search** to see which websites AI cites. That shows where to get mentioned.

### Output fields (per AI check)

`brandMentioned`, `brandListPosition`, `brandRank` (mention order), `brandSentiment`, `brandSnippet`, `brandCited`, `brandsMentionedInOrder`, `competitors` (each with mentioned, position, sentiment and snippet), `otherNamesInLists`, `citedDomains`, `answerText`, `prompt`, `model`.

Report items (`itemType: report`) add `brandVisibilityScore`, `brandMentionRate`, `brandShareOfVoice`, `leaderboard`, `promptsWhereBrandMissing`, `topCitedDomains` and change versus your previous run.

### Use cases

- **ChatGPT brand tracking**: does ChatGPT mention your brand for the questions that matter to you?
- **AI search monitoring**: re-run weekly or monthly and track your visibility score and share of voice over time
- **Competitor benchmarking**: see which competitors AI recommends instead of you, and for which questions
- **GEO / AEO reporting for clients**: a simple, repeatable AI visibility check agencies can add to SEO reports

### FAQ

**Do I need an OpenAI or other AI account?** No. Just run it.

**Is this the same as what people see in ChatGPT?** It uses the same model families through their APIs. Consumer apps can personalize answers, so treat the results as a consistent, repeatable benchmark rather than a screenshot of one person's chat.

**How is the visibility score calculated?** It's a 0 to 100 score: 60% how often you're mentioned, 25% how early you're mentioned, and 15% how often AI cites your website. Share of voice is your share of all mentions among the brands you track.

**What if AI usage is temporarily unavailable?** The run stops cleanly, tells you why, and charges only for the checks that were completed.

# Actor input Schema

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

Brand name, optional aliases and website domain separated by <code>|</code>, e.g. <code>HubSpot | HubSpot CRM | hubspot.com</code>. The domain is used to detect when AI answers cite your site.

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

Same format as the brand, one per line, e.g. <code>Salesforce | salesforce.com</code>.

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

The questions your customers would ask an AI assistant, one per line, e.g. 'What is the best CRM for a small business?'.

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

The example uses two models. Add <code>google/gemini-3.5-flash-lite</code> and <code>perplexity/sonar</code> for a broader mix, or clear the list to use those four by default. Available without a key: <code>openai/gpt-6-luna</code>, <code>anthropic/claude-haiku-5.5</code>, <code>google/gemini-3.5-flash-lite</code>, <code>perplexity/sonar</code>, <code>x-ai/grok-4.3</code>, <code>google/gemini-2.5-flash-lite</code>, <code>deepseek/deepseek-v4.1-flash</code>, <code>meta-llama/llama-4-maverick</code>. With your own key you can use any model as <code>provider:model-id</code>.

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

AI answers vary. Ask each prompt several times per model for a more reliable mention rate (each sample is one AI check). Max 5 without your own key.

## `webSearch` (type: `boolean`):

Let models search the web before answering (Perplexity always searches). Shows which sites AI cites. Same price per check.

## `maxChecks` (type: `integer`):

Hard cap on AI checks (prompts x samples x models) per run, so you always know the maximum cost: 50 checks = at most $4.00. Up to 200.

## `openrouterApiKey` (type: `string`):

Optional. Your own OpenRouter key (openrouter.ai/keys). Encrypted by Apify, never logged or stored in results.

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

Needed for <code>openai:</code> models (platform.openai.com/api-keys). Encrypted by Apify, never logged or stored in results. You pay OpenAI directly.

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

Needed for <code>anthropic:</code> models (console.anthropic.com).

## `geminiApiKey` (type: `string`):

Needed for <code>gemini:</code> models (Google AI Studio key from aistudio.google.com).

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

Needed for <code>perplexity:</code> models (perplexity.ai API settings).

## `xaiApiKey` (type: `string`):

Needed for <code>xai:</code> (Grok) models (console.x.ai).

## `customBaseUrl` (type: `string`):

For provider <code>custom</code>, e.g. <code>https://api.groq.com/openai/v1</code> or your own gateway. Requests go to <code>{baseUrl}/chat/completions</code>.

## `customApiKey` (type: `string`):

Bearer key for the custom endpoint (optional if it needs none).

## `trackingId` (type: `string`):

Name for this tracking project. Reports compare against the previous run with the same tracking ID (default: the brand name).

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

Named key-value store that keeps report history between runs.

## `locationHint` (type: `string`):

Optional, e.g. 'Germany' or 'Austin, Texas'. Added to the system prompt so answers reflect a market.

## `systemPrompt` (type: `string`):

Optional. Leave empty to see the model's default behaviour (closest to what real users get).

## `temperature` (type: `string`):

Optional, e.g. 0.7. Empty = provider default (recommended; some models only accept the default).

## `maxAnswerTokens` (type: `integer`):

Upper limit for answer length. Without your own key this is capped at 1000.

## `includeAnswerText` (type: `boolean`):

Store the full AI answer in each result.

## `maxAnswers` (type: `integer`):

Only with your own key: safety cap on AI calls per run.

## `maxConcurrency` (type: `integer`):

How many AI requests run at the same time.

## `maxRetries` (type: `integer`):

Retries for rate limits (429), server errors and network errors.

## Actor input object example

```json
{
  "brand": "Trello | trello.com",
  "competitors": [
    "Asana | asana.com"
  ],
  "prompts": [
    "What is the best project management tool for a small team?"
  ],
  "models": [
    "openai/gpt-6-luna",
    "anthropic/claude-haiku-5.5"
  ],
  "samplesPerPrompt": 1,
  "webSearch": false,
  "maxChecks": 50,
  "stateStoreName": "ai-brand-visibility-managed-state",
  "maxAnswerTokens": 1000,
  "includeAnswerText": true,
  "maxAnswers": 300,
  "maxConcurrency": 3,
  "maxRetries": 3
}
```

# Actor output Schema

## `reports` (type: `string`):

Share-of-voice reports per model.

## `answers` (type: `string`):

Every AI answer with detected brands, ranks, sentiment and citations.

## `runSummary` (type: `string`):

Per-model status and errors.

# 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": "Trello | trello.com",
    "competitors": [
        "Asana | asana.com"
    ],
    "prompts": [
        "What is the best project management tool for a small team?"
    ],
    "models": [
        "openai/gpt-6-luna",
        "anthropic/claude-haiku-5.5"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalwharf/ai-brand-visibility-tracker-managed").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": "Trello | trello.com",
    "competitors": ["Asana | asana.com"],
    "prompts": ["What is the best project management tool for a small team?"],
    "models": [
        "openai/gpt-6-luna",
        "anthropic/claude-haiku-5.5",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("signalwharf/ai-brand-visibility-tracker-managed").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": "Trello | trello.com",
  "competitors": [
    "Asana | asana.com"
  ],
  "prompts": [
    "What is the best project management tool for a small team?"
  ],
  "models": [
    "openai/gpt-6-luna",
    "anthropic/claude-haiku-5.5"
  ]
}' |
apify call signalwharf/ai-brand-visibility-tracker-managed --silent --output-dataset

```

## MCP server setup

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

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/bXdIlqpdC6KOLnvre/builds/UhdjMSn0BP8wJ5Axj/openapi.json
