# AI Visibility Tracker: 7 AI Assistants (`babel42/ai-visibility-tracker`) Actor

See how AI assistants answer when buyers ask about your category. Calls the official APIs of ChatGPT, Perplexity, Gemini, Claude and Grok, plus Google AI Overviews and AI Mode. Reports whether your brand is named, how early, whether your site is cited, and which rivals appear alongside you.

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

## Pricing

from $40.00 / 1,000 brand query 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?

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

Find out how AI assistants answer when your buyers ask about your category, and whether your brand is in the answer.

When someone asks ChatGPT "what are the best project management tools for a small agency", one of two things happens. Your brand is named, or it is not. This Actor asks that kind of question on seven AI assistants and tells you whether you were named, how early in the answer, whether your own site was used as a source, and which competitors came up alongside you. Switch on sentiment and it rates how favourably too.

No API keys. Nothing to sign up for. Set a brand name and press start.

Use it as an MCP tool inside any AI agent. No setup, no install:

```
https://mcp.apify.com?tools=babel42/ai-visibility-tracker
```

Works with Claude, ChatGPT agents, Cursor, LangChain, Make, Zapier, n8n and the REST API.

### Which AI assistants it checks

Seven, in a single run. Pick any combination.

| AI assistant | Live web search | Returns citations |
|---|---|---|
| ChatGPT | Yes | Yes |
| Perplexity | Yes | Yes |
| Google Gemini | Yes, Google Search grounding | Yes |
| Claude | Yes | Yes |
| Google AI Overviews | Yes | Yes |
| Google AI Mode | Yes | Yes |
| Grok | Answers from training knowledge | No |

Every result records whether the assistant searched the web for that answer or answered from what it already knew. Both are worth measuring, and the difference matters when you read the numbers.

ChatGPT, Perplexity, Gemini, Claude and Grok are each called through their own official API, so what you see is what the assistant actually returned. Google publishes no API for AI Overviews or AI Mode, so those two run through DataForSEO, a licensed SERP data provider.

### Key features

- Seven AI assistants in one run, not three or four.
- No API keys to bring and no separate AI bills.
- Answers come from the assistants' own official APIs, with the two Google surfaces served by a licensed SERP data provider.
- Builds your questions from real Google search volume, seeded by the keywords your domain already ranks for.
- Tells "your brand was not mentioned" apart from "this assistant could not be reached".
- Records whether each answer came from a live web search or from memory.
- Tracks competitor mentions in the same answer, so you get share of voice per question.
- Follows citations to the exact URL and domain.
- Optional sentiment rating on every mention, off by default.
- Free dry run shows the exact questions and cost before you spend anything.
- Set a maximum spend and the run stops there.
- Works as an MCP tool in any AI agent through one URL, with nothing to install.
- Country and city targeting for local intent.

### Where the questions come from

Most trackers make you write the questions, or pick from a fixed template menu. This one starts from measured demand.

Give it your domain and it looks up the keywords that domain already ranks for in Google's top 30 results, along with the real monthly search volume behind each one. The highest volume terms become the seeds for the questions put to the AI assistants. Every result carries the `seed_keyword` it grew from, so you can trace any number back to a real search term and the demand behind it.

That means you are measuring visibility on the questions that carry actual search volume in your category, not on questions someone guessed at.

You can still write your own questions. Put them in `customQueries` and they are used exactly as given.

### What you get for every check

One row per brand, question and AI assistant.

| Metric | What it tells you |
|---|---|
| `brand_mentioned` | Whether your brand appears in the answer at all |
| `brand_mention_count` | How many times it appears |
| `mention_position_score` | How early it appears, 1 is first and most prominent |
| `mention_context` | The sentence around the mention, so you can read it in context |
| `sentiment` | Positive, neutral or negative on that mention |
| `is_cited_as_source` | Whether your own domain was used as a source |
| `cited_url` | The exact page of yours that was cited |
| `cited_urls` | Every source the assistant cited for that answer |
| `cited_domains` | Which domains the assistant trusts in your category |
| `total_sources_cited` | How many sources the answer rested on |
| `competitor_mentions` | Which rivals were named in the same answer |
| `competitor_mention_count` | How many times, in total |
| `brand_share_of_voice` | Your mentions as a share of you plus your competitors |
| `searched` | Whether the assistant searched the web for this answer |
| `ai_response_summary` | The answer itself, so you can see what was actually said |
| `query_category` | Which kind of buying question this was |
| `model_used` | Exactly which model answered |
| `ok` | Whether the check completed |

### What you get for the whole run

A summary is written to the key value store under `RUN_SUMMARY` on every run. Set `includeSummaryItem` if you also want it appended to the results dataset.

| Metric | What it tells you |
|---|---|
| `visibility_score` | One number for how visible the brand is across everything checked |
| `mention_rate` | Share of questions where the brand was named |
| `citation_rate` | Share of answers that cited your domain |
| `avg_position_score` | How early you appear on average |
| `share_of_voice` | You against your competitors across the whole run |
| `sentiment_breakdown` | Positive, neutral and negative counts |
| `by_assistant` | The same figures broken down per AI assistant |
| `top_competitors` | Who comes up most often alongside you |
| `top_cited_domains` | Which sites AI assistants cite most in your category |

Every rate is calculated over the checks that completed, so one assistant having a bad day never quietly drags a number down.

### How to use it

#### Step 1: the smallest useful input

```json
{
  "brand": "Ahrefs",
  "brandDomain": "ahrefs.com",
  "category": "SEO tools"
}
```

That is enough. The Actor writes the questions, picks sensible AI assistants and runs.

#### Step 2: see the plan before you spend

Set `demoMode` to `true`. The run builds the exact question set and assistant list, reports them, and charges nothing. No AI provider is called. Use it to check a configuration before a large run.

#### Step 3: a real run

```json
{
  "brand": "Ahrefs",
  "brandDomain": "ahrefs.com",
  "category": "SEO tools",
  "competitors": ["Semrush", "Moz", "Ubersuggest"],
  "assistants": ["chatgpt", "perplexity", "gemini", "ai_overviews"],
  "maxQueries": 10,
  "market": "GB",
  "includeSentiment": true,
  "maxBudgetUsd": 2.00
}
```

#### Step 4: schedule it

Run it weekly with the Apify scheduler and set `monitorId` to the same value each time. Every row carries that value, so a week of runs lines up into a trend without any extra work.

### How much does it cost

Pay per event. One check is one brand, on one question, on one AI assistant. Ten questions across four assistants is forty checks.

| Event | Price |
|---|---|
| Brand query check | $0.04 |
| Claude query checked | $0.21 |
| Question set written for you | $0.08 per run, only when you ask for it |
| Sentiment classified | $0.005 per check, optional |
| Competitors discovered | $0.005 per check, optional |

Claude is billed as its own event because it costs considerably more to run per check. It is not in the default selection, so you only pay for it when you choose it.

A typical weekly run of 10 questions across 4 assistants is about $1.60. Sentiment and competitor discovery are charged per check, so switching both on adds about $0.40 to that run. Set a maximum spend and the run will not start if the total would exceed it.

### Output example

```json
{
  "platform": "perplexity",
  "query": "best SEO tools for a small agency",
  "query_category": "best_tools",
  "brand": "Ahrefs",
  "brand_mentioned": true,
  "brand_mention_count": 3,
  "mention_position_score": 2,
  "mention_context": "Ahrefs remains the strongest choice for backlink analysis...",
  "sentiment": "positive",
  "is_cited_as_source": true,
  "cited_url": "https://ahrefs.com/blog/seo-tools/",
  "total_sources_cited": 8,
  "competitor_mentions": ["Semrush", "Moz"],
  "brand_share_of_voice": 0.6,
  "searched": true,
  "model_used": "sonar",
  "ok": true
}
```

### Use it inside an AI agent

Point your agent at this URL and it can run brand checks inside a conversation:

```
https://mcp.apify.com?tools=babel42/ai-visibility-tracker
```

Then ask it directly:

> "Check how Ahrefs appears in ChatGPT and Perplexity when people ask about SEO tools for small agencies."

Set `mode` to `quick` for agent use. It returns shorter answer excerpts, which keeps the response small enough to sit comfortably in a conversation.

### API

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/babel42~ai-visibility-tracker/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "brand": "Ahrefs",
    "brandDomain": "ahrefs.com",
    "category": "SEO tools",
    "assistants": ["chatgpt", "perplexity", "ai_overviews"]
  }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("babel42/ai-visibility-tracker").call(run_input={
    "brand": "Ahrefs",
    "brandDomain": "ahrefs.com",
    "category": "SEO tools",
    "competitors": ["Semrush", "Moz"],
    "assistants": ["chatgpt", "perplexity", "gemini"],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["platform"], item["brand_mentioned"], item["mention_position_score"])

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("RUN_SUMMARY")
print(summary["value"]["visibility_score"])
```

Works with the Apify scheduler, the MCP server, Make, Zapier, n8n, Google Sheets, Slack, Airtable and any webhook.

### Frequently asked questions

#### Do I need my own API keys?

No. Access to all seven AI assistants is included in the per check price. There is nothing to sign up for and no second bill.

#### How often should I run it?

Weekly suits most brands. Run it after publishing a major piece of content, launching a feature or running a campaign, and compare against the week before.

#### Can I track a competitor instead of my own brand?

Yes. Put their name in `brand` and their domain in `brandDomain`. You get exactly the same report on them.

#### What does the position score mean?

It runs from 1 to 10. A 1 or 2 means the assistant leads with your brand. A 6 to 9 means you are mentioned late, after other options. It is the difference between being the recommendation and being an afterthought.

#### Can I write my own questions?

Yes. Put them in `customQueries` and they are used exactly as written. Leave it empty and the Actor builds them from the keywords your domain already ranks for in Google, weighted by real monthly search volume.

#### Can I limit what a run costs?

Yes. Set `maxBudgetUsd` and the run stops when it reaches your ceiling.

#### Is this affiliated with OpenAI, Anthropic, Google or xAI?

No. This Actor uses their public APIs under their normal terms. It is not endorsed by or affiliated with any of them. Product names are used only to identify which assistant was measured.

### Support

Maintained by Babel42. Open an issue on the Actor's Issues tab and we will pick it up.

# Actor input Schema

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

The brand, product or company to measure. Use the name a customer would write, not the legal entity name.

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

Your website, as a bare host such as ahrefs.com. Required for citation tracking, which reports whether AI answers used your own site as a source. Also used to look up the real search demand that seeds generated questions.

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

Other spellings that count as your brand: abbreviations, the legal name, common misspellings, or a former name. Omitting a real alias silently undercounts your mentions.

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

What you sell, phrased as a buyer would say it. This is what the generated questions are about, so be specific: 'SEO tools for agencies' produces a far better question set than 'software'.

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

Rivals to count in the same answers, which is what makes share of voice meaningful. Accepts a plain name, or Name|domain.com to match their site in citations too.

## `discoverCompetitors` (type: `boolean`):

Find brands the AI recommends alongside or instead of yours, beyond the competitors you listed. Charged per check. Every discovered name is verified against the answer text before it counts, and discovered rivals are included in competitor mentions, top competitors and share of voice.

## `customQueries` (type: `array`):

Exact questions to ask, one per entry. Supplying these switches off generation. Avoid naming your own brand in a question: it guarantees a mention and inflates your score. Any question that does name the brand is flagged and excluded from the headline metrics.

## `queryTemplates` (type: `array`):

Ready made question shapes built from your category. The first six never name your brand and are safe for measuring visibility. The last three do name it, which is useful for reputation and comparison but is excluded from the headline score.

## `generateQueries` (type: `boolean`):

Write the questions for you from the keywords your domain already ranks for in Google, weighted by real monthly search volume. On by default. Turn it off only if you are supplying your own questions or picking templates. Generated questions never name your brand.

## `maxQueries` (type: `integer`):

Total questions to ask. Every question is asked on every AI assistant you select, so billed checks are questions multiplied by assistants. Up to 50 questions per run.

## `assistants` (type: `array`):

Pick which AI assistants to ask. Every question you set is asked on every assistant you pick here. Claude is billed as a separate premium check. Each result records whether the assistant searched the live web for that answer, so you can tell a searched answer from a remembered one.

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

Two letter country code to target, such as gb or us. Gemini and Grok have no location parameter, so for those two the country is carried in the question text instead, which is a weaker signal. The run notes say so explicitly.

## `city` (type: `string`):

Optional city for local intent, for example London. Applies to the AI assistants that accept a location.

## `includeSentiment` (type: `boolean`):

Judge whether each answer portrays your brand positively, neutrally or negatively. Billed separately per mention. A classification that cannot be made is reported as unknown rather than guessed as neutral.

## `responseFormat` (type: `string`):

How much of each AI answer to keep on the row. Concise is roughly a quarter of the size and is the right choice when an AI agent is reading the output.

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

Quick is built for AI agents: few questions, concise answers, finishes inside a tool call timeout. Standard is built for scheduled monitoring.

## `demoMode` (type: `boolean`):

Build and report the exact question set and AI assistants without calling any provider and without charging anything. Use it to check a configuration before you spend.

## `maxBudgetUsd` (type: `number`):

Refuse to start if the projected charge exceeds this. Checked before any paid call is made, so an oversized run costs you nothing. The projection prices Claude checks at the premium rate.

## `monitorId` (type: `string`):

A stable label for a recurring monitor, written onto every row. Keep it and the question set unchanged between scheduled runs or your trend line is not comparable.

## `includeSummaryItem` (type: `boolean`):

Append the aggregated summary as an extra item in the results dataset. Off by default so the results stay a single record type: mixing the summary in makes every column read 99 percent complete instead of 100, because the summary carries none of the per check fields. The summary is always written to the key value store under RUN\_SUMMARY either way.

## Actor input object example

```json
{
  "brand": "Babel42",
  "brandDomain": "babel42.io",
  "brandAliases": [
    "Babel42 Ltd",
    "babel42.io"
  ],
  "category": "AI brand visibility tools",
  "competitors": [
    "Profound|tryprofound.com",
    "Peec AI"
  ],
  "discoverCompetitors": false,
  "customQueries": [
    "What are the best tools for tracking brand mentions in AI answers?"
  ],
  "queryTemplates": [
    "best_tools",
    "recommendations"
  ],
  "generateQueries": true,
  "maxQueries": 5,
  "assistants": [
    "chatgpt",
    "perplexity",
    "gemini",
    "ai_overviews"
  ],
  "market": "gb",
  "city": "London",
  "includeSentiment": false,
  "responseFormat": "detailed",
  "mode": "quick",
  "demoMode": false,
  "monitorId": "weekly-uk-ai-visibility",
  "includeSummaryItem": false
}
```

# Actor output Schema

## `checks` (type: `string`):

One row per brand, question and AI assistant combination.

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

Aggregated visibility score, per assistant breakdown, competitors and cited domains.

# 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": "Babel42",
    "brandDomain": "babel42.io",
    "category": "AI brand visibility tools",
    "maxQueries": 5,
    "assistants": [
        "chatgpt",
        "perplexity",
        "gemini",
        "ai_overviews"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("babel42/ai-visibility-tracker").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": "Babel42",
    "brandDomain": "babel42.io",
    "category": "AI brand visibility tools",
    "maxQueries": 5,
    "assistants": [
        "chatgpt",
        "perplexity",
        "gemini",
        "ai_overviews",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("babel42/ai-visibility-tracker").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": "Babel42",
  "brandDomain": "babel42.io",
  "category": "AI brand visibility tools",
  "maxQueries": 5,
  "assistants": [
    "chatgpt",
    "perplexity",
    "gemini",
    "ai_overviews"
  ]
}' |
apify call babel42/ai-visibility-tracker --silent --output-dataset

```

## MCP server setup

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

```

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/AV9V7KQBmMUcG2V2E/builds/st7rxXJFbtaIVeopc/openapi.json