# AI Brand Visibility Monitor: ChatGPT, Claude & Gemini Mentions (`localwire/ai-brand-visibility`) Actor

AI search visibility tracker for GEO and AEO: asks ChatGPT, Claude and Gemini your customers' questions through the official APIs with web search and records brand mentions, rank, tone, competitors and cited sources, with the change since the last run. $0.08 to $0.10 per answer.

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

## Pricing

from $100.00 / 1,000 claude 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

## AI Brand Visibility Monitor: ChatGPT, Claude & Gemini Mentions

AI Brand Visibility Monitor is an AI search visibility tracker: it asks ChatGPT's models, Claude and Gemini your customers' questions through the official OpenAI, Anthropic and Gemini APIs with web search on, and records whether your brand is mentioned, ranked and cited. **$0.08 to $0.10 per answer**, no start fee, no subscription.

Use it for generative engine optimisation (GEO) and answer engine optimisation (AEO) work: measure where you stand in AI answers today, see which competitors and which web pages the assistants rely on, and track the change week by week.

For every answer the Actor records:

- whether your **brand is mentioned**, how many times, and **where it comes** in the order of brands named (rank 1 = named first);
- how the passage about you **reads** (positive, neutral, negative or mixed);
- which **competitors** are named and ranked, and whether their sites are cited;
- which **pages and domains are cited**, whether **your own site** is among them, and what the engine **searched for**;
- the **change since the previous run** (new, gained, lost, changed, unchanged) when you run it on a schedule.

**What it covers, plainly:** ChatGPT's models (OpenAI API), Claude (Anthropic API) and Gemini (Gemini API), each with its web search tool switched on. It does **not** cover Perplexity, Google AI Overviews, AI Mode, Copilot or any other assistant. Answers come from the providers' APIs, not from the consumer apps, so they can differ from what you see when you type the same question into chatgpt.com, claude.ai or the Gemini app (see [Limitations](#limitations)).

### What you get

One dataset record per **check**. A check is one prompt asked of one engine: 10 prompts on three engines is 30 checks and 30 records.

```json
{
  "id": "openai-5d0c1f6f1a2b9e47",
  "type": "check",
  "engine": "openai",
  "engineLabel": "ChatGPT (OpenAI API)",
  "model": "gpt-6.1-terra",
  "prompt": "Best HR software for small UK companies?",
  "country": "GB",
  "brand": "Humaans",
  "status": "ok",
  "error": null,
  "brandMentioned": true,
  "mentionCount": 2,
  "mentionRank": 2,
  "firstMentionAt": 0.19,
  "sentiment": "positive",
  "sentimentScore": 0.6,
  "snippets": [
    "Humaans is a modern, fast platform built for small and mid-sized companies, and users praise its clean interface. It lacks built-in payroll, so you connect a payroll provider."
  ],
  "brandCited": true,
  "brandCitations": ["https://humaans.io/"],
  "competitors": [
    { "name": "BambooHR", "mentioned": true, "mentionCount": 3, "mentionRank": 1, "firstMentionAt": 0.07, "cited": true, "citedUrls": ["https://www.bamboohr.com/pricing/"] },
    { "name": "Personio", "mentioned": true, "mentionCount": 1, "mentionRank": 3, "firstMentionAt": 0.41, "cited": false, "citedUrls": [] }
  ],
  "competitorsMentioned": ["BambooHR", "Personio"],
  "citations": [
    { "url": "https://www.techradar.com/best/best-hr-software", "domain": "techradar.com", "title": "Best HR software of 2026" },
    { "url": "https://humaans.io/", "domain": "humaans.io", "title": "Humaans: HRIS for modern companies" }
  ],
  "citedDomains": ["techradar.com", "humaans.io"],
  "sources": [
    { "url": "https://www.techradar.com/best/best-hr-software", "domain": "techradar.com", "title": null },
    { "url": "https://humaans.io/", "domain": "humaans.io", "title": null },
    { "url": "https://www.g2.com/categories/core-hr", "domain": "g2.com", "title": null }
  ],
  "sourceDomains": ["techradar.com", "humaans.io", "g2.com"],
  "searchQueries": ["best HR software for small UK companies 2026"],
  "searchCount": 1,
  "answer": "For a small UK company the usual shortlist is BambooHR, Humaans and Personio. ...",
  "answerLength": 2140,
  "previous": { "checkedAt": "2026-11-02T08:00:09.000Z", "brandMentioned": false, "mentionRank": null, "sentiment": null, "brandCited": false },
  "change": "gained",
  "checkedAt": "2026-11-09T08:00:12.000Z"
}
```

#### Output fields

| Field | Meaning |
|---|---|
| `engine`, `engineLabel`, `model` | Which assistant answered and the model id the API reported. |
| `prompt`, `country`, `brand` | What was asked. |
| `status` | `ok`, `truncated` (answer cut at the token limit), `refused` (the model declined), `no_answer`, or `error` (the provider failed; `error` holds the message and the record is free). |
| `brandMentioned`, `mentionCount`, `mentionRank`, `firstMentionAt` | Mention facts. `mentionRank` counts only the brands you track (yours plus competitors); `firstMentionAt` is the position of the first mention as a fraction of the answer (0 = the first words). |
| `sentiment`, `sentimentScore` | Tone of the passages about your brand: `positive`, `neutral`, `negative` or `mixed`, with a score from -1 to 1. A word-list heuristic with negation handling, not a judgement; read the `snippets`. |
| `snippets` | Up to three passages mentioning the brand. |
| `brandCited`, `brandCitations` | Whether a page on one of your domains (or a subdomain) is cited, and which. |
| `competitors[]`, `competitorsMentioned` | Per competitor: mentioned, count, rank, position, cited, cited URLs. |
| `citations[]`, `citedDomains` | Pages cited in the answer (`url`, `domain`, `title`). |
| `sources[]`, `sourceDomains` | Every page the engine read while answering (a superset of the citations where the API exposes it). |
| `searchQueries`, `searchCount` | What the engine searched for and how many searches it ran. |
| `answer`, `answerLength` | The full answer text (email addresses and phone numbers removed). `answer` is `null` when `includeAnswer` is off. |
| `previous`, `change` | The last result for the same engine, model, prompt and brand, and the change: `new`, `gained`, `lost`, `changed` (rank, tone or citation moved) or `unchanged`. |
| `checkedAt` | When the answer was produced (UTC). |

The dataset has two table views, **Checks** and **Citations**. The run's key-value store also holds an `OUTPUT` summary: checks planned and completed, errors, answers that mention the brand in total and per engine, the stop reason and the account's daily allowance.

### Quick start

The form opens with a one-check example: one prompt, one engine (ChatGPT). Press **Start** and you get one record for $0.09. The same input as JSON:

```json
{
  "brand": "Apify",
  "brandDomains": ["apify.com"],
  "competitors": ["Bright Data | brightdata.com", "Zyte | zyte.com"],
  "prompts": ["What are the best web scraping platforms for developers?"],
  "engines": ["openai"],
  "maxChecks": 10
}
```

Then make it yours:

1. Put your brand in `brand`, your sites in `brandDomains`, and any other spellings in `brandAliases`.
2. Replace the prompt with the questions your customers ask, one per line. Write them as a person would: "best payroll software for a 20-person company", not "payroll software".
3. Add `anthropic` and `gemini` to `engines` when you want all three assistants.
4. Raise `maxChecks` to at least prompts × engines.
5. Schedule the run (weekly is a sensible start) and read the `change` field.

Note that `engines` asks **all three** when the field is left out of an API call, so list the engines you want.

### Input reference

| Field | Type | Default | Meaning |
|---|---|---|---|
| `brand` (required) | string | | The brand, product or company name to look for. Matching is case-insensitive on whole words. |
| `brandAliases` | string\[] | | Other spellings that also count as a mention ("Humaans HR", "humaans.io"). |
| `brandDomains` | string\[] | | Your own domains. A cited page on one of them, or on a subdomain, sets `brandCited`. |
| `competitors` | string\[] | | Other brands to track in the same answers, one per line. `"Name \| domain.com"` also tracks their citations; `"Name; alias; domain.com"` adds aliases. |
| `prompts` (required) | string\[] | | The questions, up to 200 per run and 600 characters each. Duplicates are asked once. |
| `country` | string | none | Two-letter country code (GB, US, DE) to localise web search. Applies to ChatGPT and Claude; Gemini has no location setting. |
| `engines` | string\[] | all three | Any of `openai`, `anthropic`, `gemini`. |
| `openaiModel` | string | `gpt-6.1-terra` | `gpt-6.1-terra` or `gpt-6-luna` (standard price), `gpt-6.1-sol` (premium price). |
| `anthropicModel` | string | `claude-sonnet-5-5` | `claude-sonnet-5-5` or `claude-haiku-5-5` (standard), `claude-opus-5-5` (premium). |
| `geminiModel` | string | `gemini-3.8-flash` | `gemini-3.8-flash`, `gemini-3.6-flash` or `gemini-3.5-flash-lite` (standard), `gemini-3.1-pro-preview` (premium). |
| `maxSearches` | integer | 5 | Web searches Claude may run for one answer (1 to 10). ChatGPT and Gemini decide for themselves. |
| `maxChecks` | integer | 60 | Stop after this many checks (1 to 500). Checks beyond it are not run and not charged. |
| `includeAnswer` | boolean | true | Return the full answer text in each record. |
| `compareWithPrevious` | boolean | true | Remember each check's last result and fill `previous` and `change`. |

### Use cases

- **GEO and AEO baselines.** Before you change anything, record which of your category's questions mention you on each assistant, at what rank and with what tone.
- **AI share of voice.** Ask 20 to 50 category questions and count the answers that name you against the answers that name each competitor. The `OUTPUT` summary gives mentions per engine; `competitors[]` gives the same facts for each rival.
- **Citation and source analysis.** `citedDomains` and `sourceDomains` show which review sites, directories, forums and publishers the assistants read for your category. Those are the pages worth being on.
- **Competitor monitoring.** Track when a competitor starts to be named first, or when their own site begins to be cited.
- **Launch and campaign tracking.** Schedule a weekly run and filter on `change` = `gained` or `lost` to see what moved after a launch, a PR push or a content update.
- **Agency reporting.** Run one task per client and export the Checks view to CSV, Excel or Google Sheets.
- **Brand safety.** Read the `snippets` and `sentiment` for prompts such as "is X any good?" or "X problems" to see how the assistants describe you.

### Pricing

Pay per check, by engine and model tier. There is no start fee and no monthly fee.

| Engine | Standard models | Price per check | Premium model | Price per check |
|---|---|---|---|---|
| ChatGPT (OpenAI API) | GPT-6.1 Terra (default), GPT-6 Luna | **$0.09** | GPT-6.1 Sol | **$0.15** |
| Claude (Anthropic API) | Claude Sonnet 5.5 (default), Claude Haiku 5.5 | **$0.10** | Claude Opus 5.5 | **$0.18** |
| Gemini (Gemini API) | Gemini 3.8 Flash (default), 3.6 Flash, 3.5 Flash-Lite | **$0.08** | Gemini 3.1 Pro Preview | **$0.15** |

The price includes the provider's API usage and its web search fees: you do not need your own OpenAI, Anthropic or Google keys.

Worked examples with the default models:

| Run | Checks | Cost |
|---|---|---|
| The quick-start example: 1 prompt on ChatGPT | 1 | **$0.09** |
| 1 prompt on all three engines | 3 | $0.09 + $0.10 + $0.08 = **$0.27** |
| 10 prompts on all three engines | 30 | 10 × $0.27 = **$2.70** |
| 20 prompts on all three engines, every week | 60 a week | $5.40 a run, about **$23.40 a month** |
| 10 prompts on Gemini only, every day | 10 a day | $0.80 a day, about **$24 a month** |

What is and is not charged:

- A check is charged when the provider returns an answer, including the rare answer that is `truncated`, `refused` or empty (`no_answer`), because the provider bills for it.
- A check that fails at the provider (rate limit, outage, authentication) is written as a `status: "error"` record and is **free**.
- Checks that `maxChecks`, the daily allowance or the run's maximum cost prevent are never sent, so they cost nothing.

To cap a run, set `maxChecks`, or set the run's maximum cost in the Console (the `maxTotalChargeUsd` API parameter): the Actor checks before each provider call that another check still fits and stops when it does not.

**Daily allowance.** Because every check costs real API usage on our side, each Apify account has a daily allowance: **15 checks a day on free plans, 1,000 a day on paid plans**. When it is used up, the run stops with a clear status message and the remaining checks can run the next day (UTC).

### Use it from the API

Run the Actor and get the records back in one HTTP call:

```bash
curl -X POST "https://api.apify.com/v2/acts/localwire~ai-brand-visibility/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>&maxTotalChargeUsd=1" \
  -H "content-type: application/json" \
  -d '{
    "brand": "Humaans",
    "brandDomains": ["humaans.io"],
    "competitors": ["BambooHR | bamboohr.com", "Personio | personio.com"],
    "prompts": ["Best HR software for small UK companies?"],
    "engines": ["openai", "gemini"],
    "country": "GB"
  }'
```

Each answer involves live web searches and can take tens of seconds, so for more than a handful of checks start the run asynchronously (`POST /v2/acts/localwire~ai-brand-visibility/runs`) and read the dataset when it finishes.

With the official clients:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("localwire/ai-brand-visibility").call({
  brand: "Humaans",
  prompts: ["Best HR software for small UK companies?"],
  engines: ["openai"],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("localwire/ai-brand-visibility").call(run_input={
    "brand": "Humaans",
    "prompts": ["Best HR software for small UK companies?"],
    "engines": ["openai"],
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### Use it from an AI agent (MCP)

Apify hosts an MCP server at `https://mcp.apify.com`. Add it to any MCP client (Claude, ChatGPT, Cursor, VS Code and others) and sign in with your Apify account, or send your API token as an `Authorization: Bearer` header. To expose just this Actor as a tool, use:

```
https://mcp.apify.com?tools=localwire/ai-brand-visibility
```

The agent can then run a check itself. A prompt such as "Use localwire/ai-brand-visibility to ask ChatGPT whether Humaans is recommended for small UK companies, and list the domains it cited" is enough.

Two things an agent should know, because it sees the input schema's defaults and not the Console's example values:

- `engines` defaults to **all three** engines. Pass `"engines": ["openai"]` (or another single engine) for a one-check call.
- `maxChecks` defaults to 60. Pass a small number when experimenting.

### Integrations

Runs can be scheduled in the Apify Console, called from the API, or connected to other tools through Apify's integrations: Make, n8n, Zapier, LangChain, webhooks and others. Datasets export as JSON, CSV, Excel, XML or RSS, or straight to Google Sheets through an integration. A common setup is a weekly schedule plus a webhook or Make/Zapier scenario that posts the records whose `change` is `gained` or `lost` to Slack or e-mail.

### How it works

- **ChatGPT:** OpenAI Responses API with the `web_search` tool (sources included), low reasoning effort. Citations come from the answer's `url_citation` annotations, sources from the search calls.
- **Claude:** Anthropic Messages API with the `web_search` server tool (up to `maxSearches` searches), low effort. Citations come from the text blocks' `web_search_result_location` entries, sources from the search result blocks.
- **Gemini:** Gemini API `generateContent` with Grounding with Google Search. Cited pages come from `groundingSupports`, read pages from `groundingChunks`; Google's redirect links are resolved to the real page URLs. Gemini decides for itself whether to search and often answers from memory, so every request carries a short system instruction to ground the answer in current web sources and cite them.

Each prompt is sent on its own, with no conversation history, no memory and no persona. Mentions are whole-word, case-insensitive matches of the brand name and aliases. Ranks compare the first mention of each tracked brand. The tone score counts positive and negative cue words in the sentences that name the brand (and the pronoun sentences that follow), flipping a cue after "not", "no", "never" and the like.

No chat interface is scraped, and no accounts, browsers or proxies are involved.

### FAQ

#### How do I check if ChatGPT mentions my brand?

Put your brand in `brand`, the question in `prompts`, set `engines` to `["openai"]` and run. `brandMentioned` answers the question; `mentionRank`, `snippets` and `citations` show where and how. One check costs $0.09.

#### What is GEO (generative engine optimisation) and how does this help?

GEO, also called AEO (answer engine optimisation) or LLM SEO, is the work of getting your brand named and your pages cited in AI-generated answers. You cannot improve what you do not measure: this Actor gives you the measurement (mentions, rank, tone, citations, competitors) on a fixed prompt set so you can compare before and after.

#### How do I measure AI share of voice?

Ask a set of category questions (20 or more gives steadier numbers) and divide the answers that mention you by all answers. The `OUTPUT` summary has `mentioned` and `ok` in total and per engine. Do the same with each entry of `competitors[]` to get each rival's share. The Actor reports the counts; it does not output a single share-of-voice score.

#### Does it track Perplexity or Google AI Overviews?

No. It covers ChatGPT's models, Claude and Gemini through their official APIs. Perplexity, Google AI Overviews, AI Mode and Copilot are not covered.

#### Are the answers the same as in the ChatGPT, Claude and Gemini apps?

Not exactly. The consumer apps add their own system prompts, memory, personalisation, location and sometimes different models and search behaviour. API answers with web search are a close, reproducible view of what the same models say, not a screenshot of the app. Treat the results as a consistent benchmark over time.

#### Why do results change between runs?

AI answers are not deterministic and the web search results behind them change. One answer is an anecdote. Ask several prompts, run on a schedule, and read trends.

#### Do I need my own OpenAI, Anthropic or Google API keys?

No. The provider calls are made on the Actor's keys and their cost is included in the price per check.

#### Can I track competitors?

Yes. List them in `competitors`, optionally with a domain (`"Zyte | zyte.com"`). Each gets its own mention count, rank and cited flag in every record.

#### How do I export the results to CSV or Google Sheets?

Open the run's dataset and choose CSV or Excel, or call `https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&view=overview`. For Google Sheets use Apify's Google Sheets integration or a Make/Zapier scenario.

#### How often should I run it?

Weekly suits most brands. Daily is useful around a launch. Each scheduled run compares with the previous one for the same engine, model, prompt and brand.

#### Is there a free trial?

There is no separate trial, but a first test is cheap: the one-check quick start costs $0.09, and accounts on Apify's free plan can run up to 15 checks a day, paid from the plan's platform credit.

### Limitations

- **API, not the apps.** See the FAQ above: API answers can differ from the consumer apps.
- **Three engines only.** No Perplexity, Google AI Overviews, AI Mode, Copilot, Grok or Meta AI.
- **Answers vary.** The same prompt can be answered differently minutes apart.
- **Tone is a heuristic.** Use `sentiment` to sort, then read the snippets.
- **Mentions are name matches.** A brand whose name is a common word ("Notion", "Monday") can match unrelated uses; add specific aliases and check the snippets.
- **`country` applies to ChatGPT and Claude only.** Gemini's grounded search has no location setting.
- **English cue words.** Mention detection works in any language; the tone label is built on English words and is unreliable for answers in other languages.
- **Model list.** Model ids are the providers' current ones. If a provider retires a model, pick another in the input; the record reports the model the API actually used.
- **Daily allowance** of 15 (free plans) or 1,000 (paid plans) checks per account, and at most 500 checks per run.
- **Failures.** A temporary provider error is retried once; after three failures in a row, or an authentication failure, that engine is skipped for the rest of the run and the status message says so.
- **Privacy.** Answers are about brands and products. Email addresses and phone numbers that appear in answer text are removed before it is stored. No user or account data is collected.

### More from this developer

- [UK & EU public tenders](https://apify.com/localwire/uk-public-tenders)
- [Google Trends Trending Now](https://apify.com/localwire/google-trends-trending-now)
- [Hacker News](https://apify.com/localwire/hacker-news)
- [Career Site Jobs API](https://apify.com/localwire/ats-jobs)
- [Workday Jobs](https://apify.com/localwire/workday-jobs)
- [Reed Jobs](https://apify.com/localwire/reed-jobs)
- [Wellfound Jobs](https://apify.com/localwire/wellfound-jobs)
- [App Store Reviews, Details & Top Charts](https://apify.com/localwire/app-store-reviews)
- [Flashscore results and fixtures](https://apify.com/localwire/flashscore-sports)
- [ESPN scores and standings](https://apify.com/localwire/espn-sports)
- [Eventbrite Events](https://apify.com/localwire/eventbrite-events)
- [Meetup Events & Groups](https://apify.com/localwire/meetup-events)
- [Gumtree Listings](https://apify.com/localwire/gumtree-listings)
- [Telegram Channels](https://apify.com/localwire/telegram-channels)

# Actor input Schema

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

The brand, product or company name to look for in the answers, e.g. Humaans. Required.

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

Spellings and variants that also count as a mention (e.g. "Humaans HR", "humaans.io"). Matching is case-insensitive on whole words.

## `brandDomains` (type: `array`):

Your own domains, e.g. humaans.io. A cited page on one of them (or a subdomain) sets brandCited.

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

Other brands to track in the same answers, one per line, optionally with a domain: "Bright Data | brightdata.com". Each gets its own mention count, rank and cited flag.

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

The questions your customers would ask an AI assistant, one per line, written the way a person would ask them ("best CRM for a small UK agency"). Up to 200 per run, at most 600 characters each. Every prompt is asked of every selected engine, and each answer is one paid check, so 5 prompts on 3 engines is 15 checks.

## `country` (type: `string`):

Two-letter country code (GB, US, DE…) to localise web search results where the engine supports it (ChatGPT and Claude). Leave empty for no localisation.

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

Which AI answer engines to ask: openai (ChatGPT's models through the OpenAI API), anthropic (Claude) and gemini (Gemini). Every prompt is asked of every engine listed, and each answer is one paid check: $0.09 for ChatGPT, $0.10 for Claude, $0.08 for Gemini with the default models. If the field is left out, all three are asked; list one engine for the cheapest run.

## `openaiModel` (type: `string`):

The model asked through the OpenAI Responses API with web search. Sol is charged as a premium check (see Pricing).

## `anthropicModel` (type: `string`):

The Claude model asked through the Anthropic Messages API with web search. Opus is charged as a premium check (see Pricing).

## `geminiModel` (type: `string`):

The Gemini model asked with Grounding with Google Search. Pro is charged as a premium check (see Pricing).

## `maxSearches` (type: `integer`):

How many web searches Claude may run for one answer (ChatGPT and Gemini decide for themselves).

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

Stop after this many checks (one check = one prompt asked of one engine). Prompts × engines above this number are not run and not charged. 60 if left out, at most 500. You can also cap spending with the run's maximum cost.

## `includeAnswer` (type: `boolean`):

Return each engine's full answer text in the record (email addresses and phone numbers removed). Turn off for smaller records.

## `compareWithPrevious` (type: `boolean`):

Remember each check's last result and report whether the brand gained or lost its mention since then (the previous and change fields). Schedule the Actor to track changes over time.

## Actor input object example

```json
{
  "brand": "Apify",
  "brandDomains": [
    "apify.com"
  ],
  "competitors": [
    "Bright Data | brightdata.com",
    "Zyte | zyte.com"
  ],
  "prompts": [
    "What are the best web scraping platforms for developers?"
  ],
  "engines": [
    "openai"
  ],
  "openaiModel": "gpt-6.1-terra",
  "anthropicModel": "claude-sonnet-5-5",
  "geminiModel": "gemini-3.8-flash",
  "maxSearches": 5,
  "maxChecks": 10,
  "includeAnswer": true,
  "compareWithPrevious": true
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per prompt and engine: mentioned or not, rank, tone, cited, change since the last run.

## `citations` (type: `string`):

Which sites each engine cited and searched for.

## `allResults` (type: `string`):

Every record in the run's default dataset, all fields, including the full answers.

# 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": "Apify",
    "brandDomains": [
        "apify.com"
    ],
    "competitors": [
        "Bright Data | brightdata.com",
        "Zyte | zyte.com"
    ],
    "prompts": [
        "What are the best web scraping platforms for developers?"
    ],
    "engines": [
        "openai"
    ],
    "maxChecks": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("localwire/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": "Apify",
    "brandDomains": ["apify.com"],
    "competitors": [
        "Bright Data | brightdata.com",
        "Zyte | zyte.com",
    ],
    "prompts": ["What are the best web scraping platforms for developers?"],
    "engines": ["openai"],
    "maxChecks": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("localwire/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": "Apify",
  "brandDomains": [
    "apify.com"
  ],
  "competitors": [
    "Bright Data | brightdata.com",
    "Zyte | zyte.com"
  ],
  "prompts": [
    "What are the best web scraping platforms for developers?"
  ],
  "engines": [
    "openai"
  ],
  "maxChecks": 10
}' |
apify call localwire/ai-brand-visibility --silent --output-dataset

```

## MCP server setup

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