# AI Brand Visibility Tracker: ChatGPT/Perplexity/Gemini/Google (`xyventures/ai-visibility-tracker`) Actor

Track brand mentions, citations and competitors in ChatGPT, Perplexity, Gemini and Google AI Overviews. GEO reports and weekly changes. $0.035 per successful check; engine usage billed separately.

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

## Pricing

$35.00 / 1,000 successful visibility 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 Tracker: ChatGPT/Perplexity/Gemini/Google

Measure whether AI answers mention and cite your brand, which competitors appear first, and what changed since your previous complete run. Built for SEO/GEO agencies, in-house marketers, and one-off brand audits.

**$0.035 per successful prompt × engine × tracked brand.** Engine usage is billed separately to your own Apify account at your plan's rates.

### Quick audit

Copy this input for one brand and one Google AI Overviews check:

```json
{
  "brand": "HubSpot",
  "brandDomain": "hubspot.com",
  "prompts": ["what are the best crm platforms"],
  "engines": ["google_ai_overviews"],
  "maxChecks": 1,
  "maxEngineSpendUsd": 0.10,
  "trackChanges": false
}
```

For a successful answer, a historical Free-plan example costs **about $0.039**: $0.035 tracker fee + $0.003 Overview answer + $0.00005 engine start + approximately $0.00083 engine compute/storage. See the pricing tables below; rates and platform usage can change. If Google returns no Overview, the result is partial rather than a zero visibility score.

### Sample result

This excerpt is derived offline by the existing parser and analyzer from a recorded, trimmed [Google AI Overviews fixture](tests/fixtures/google_ai_overviews.json); position is relative to the tracked names in this single-brand example, not search rank.

```json
{
  "brand": "HubSpot",
  "engine": "google_ai_overviews",
  "prompt": "what are the best crm platforms",
  "mentioned": true,
  "mentionCount": 1,
  "position": 1,
  "listRank": 2,
  "cited": false,
  "citationRank": null
}
```

### Use it from an AI agent

Use the [Apify API](https://docs.apify.com/academy/api/run-actor-and-retrieve-data-via-api) with your own credentials and the input above: POST the JSON to `/v2/actors/xyventures~ai-visibility-tracker/runs`, wait for the run to finish, then use its `defaultDatasetId` and `defaultKeyValueStoreId` to fetch `/v2/datasets/{defaultDatasetId}/items` and `/v2/key-value-stores/{defaultKeyValueStoreId}/records/OUTPUT`. Authenticate using the [Authorization header](https://docs.apify.com/api/v2#authentication).

Summarize only returned successful dataset checks, using fields such as `brand`, `engine`, `prompt`, `mentioned` and `cited`. Check `OUTPUT.status`: `complete` covers all requested answers; `partial` means missing or skipped answers, which are not evidence of absence. Also handle `invalid-input` and `charge-limit` before interpreting coverage.

### What it does

- Runs Apify's ChatGPT, Perplexity, Gemini, Google AI Overviews, and optional Google AI Mode Actors **on your Apify account**. No separate AI API key.
- Checks case-insensitive whole-word brand names, aliases and bare domains. Measures mention count, first-mention order against competitors, and list-item rank.
- Matches citations using an offline Public Suffix List (ICANN and private domains). `blog.acme.com` matches `acme.com`; `acme.com.evil.io` does not.
- Produces dataset checks, an `OUTPUT` JSON summary, and one self-contained `REPORT.html` with an optional agency header.
- Compares previous complete runs with identical inputs. Schedule weekly for week-over-week tracking.

It does **not** use an LLM for analysis, infer sentiment, scrape chat UIs itself, or target Copilot/Bing or other Microsoft-owned services.

### Three input presets

#### 1. Single-brand weekly tracking

```json
{
  "brand": "HubSpot",
  "brandDomain": "hubspot.com",
  "brandAliases": ["HubSpot CRM"],
  "competitors": ["Zoho CRM | zoho.com", "Pipedrive | pipedrive.com"],
  "prompts": ["what are the best crm platforms", "HubSpot alternatives"],
  "engines": ["chatgpt", "perplexity", "gemini", "google_ai_overviews"],
  "country": "US",
  "language": "en",
  "trackingId": "hubspot-weekly-us",
  "trackChanges": true,
  "maxChecks": 100,
  "maxEngineSpendUsd": 5
}
```

#### 2. Agency batch

```json
{
  "agencyName": "Example GEO Agency",
  "maxChecks": 100,
  "maxEngineSpendUsd": 5,
  "projects": [
    {
      "brand": "HubSpot",
      "brandDomain": "hubspot.com",
      "competitors": ["Zoho CRM | zoho.com"],
      "prompts": ["what are the best crm platforms"],
      "trackingId": "client-crm"
    },
    {
      "brand": "Pipedrive",
      "brandDomain": "pipedrive.com",
      "competitors": ["HubSpot | hubspot.com"],
      "prompts": ["what are the best crm platforms"],
      "trackingId": "client-sales"
    }
  ]
}
```

Projects replace top-level simple-mode fields and have their own defaults. Top-level `agencyName` and `maxChecks` remain global. Use distinct `trackingId` values; defaults derive from brand. Each project can optionally set a smaller `maxChecks` cap.

Identical prompts are deduplicated across projects, then batched per engine and requested locale in chunks of **at most 20 prompts**. Up to four independent engine/locale chunks run in parallel. Timeout scales as 120 seconds + 20 seconds per prompt (maximum 900 seconds). Different requested locales use separate batches. Shared answers are analyzed and billed separately for each tracked brand at $0.035 per successful check.

#### 3. Quick audit with generated questions

```json
{
  "brand": "HubSpot",
  "brandDomain": "hubspot.com",
  "category": "CRM",
  "competitors": ["Pipedrive | pipedrive.com"],
  "generatePrompts": true,
  "maxGeneratedPrompts": 5,
  "engines": ["chatgpt", "google_ai_overviews"],
  "trackChanges": false,
  "maxChecks": 10
}
```

Templates include `best CRM`, `top CRM tools 2026`, `HubSpot alternatives`, `HubSpot vs Pipedrive`, and `is HubSpot worth it`. The year follows the run year. Available templates, not a model, determine the generated count.

### Inputs and limits

See the Input tab for every field. A project must provide a brand and at least one prompt, or generation plus a category. Invalid combinations stop before any engine call and produce `invalid-input` OUTPUT/report with zero charges. Maximum 100 combined prompts per project; maximum 100 projects. `maxChecks` defaults to **100** and caps attempted brand × prompt × engine units, not competitor analyses. Work truncates in project → prompt → engine order before engine calls.

**`maxEngineSpendUsd` defaults to $5 (minimum $0.10)** and controls the combined engine budget, separately from your tracker max charge per run. Each engine run gets a spending cap from its share of your remaining budget; a one-answer buffer stays inside your budget to allow for upstream final-event overshoot. Reported spending is never counted below the estimated answer/start fees, even with zero returned items or a temporarily zero usage meter. When usage is unavailable, the full reservation remains accounted rather than treating it as free. No new engine runs start when funds cannot cover an answer. Conservative reservations can leave some budget unused.

**Gemini requires a minimum $0.50 engine-run cap. This is a cap, not a fixed fee.** Your total budget is never increased to meet it. Gemini is skipped with a clear warning if its remaining share cannot cover that minimum plus the one-answer buffer: $0.70 on Free or $0.505 on Bronze for a single Gemini run. With multiple engines, Gemini's individual budget share must be large enough.

When an engine returns some answers, only missing prompts may be retried once in a new capped run. **Failed or timed-out engine runs with no valid answers are not retried.** A failed or unacknowledged engine start is also not retried in that run, to avoid double spend. Its reservation remains accounted and the result is partial. An engine failure does not crash other engines; insufficient budget also yields partial output.

Progress is saved in the run's **`STATE`** record. Resuming keeps completed checks and reconnects to engine runs whose IDs were saved. Keep the original default storages when resuming; changed input with an existing STATE requires a fresh run. Recovery from interrupted engine requests can require manual inspection of child runs, so do not assume that every interruption can recover automatically. If platform event counts are unavailable while a charge is pending, the run stops before any new engine work, data push or charge; it can be resurrected later when counts are available.

**Locale limits, confirmed 9 Nov 2026:** ChatGPT, Perplexity, Gemini and AI Mode accept `countryCode`. Overview exposes only `queries`; its requested country is metadata, not enforced. None exposes a language field: write questions in your preferred language. Unsupported locale controls are not passed as invented fields. Requested language is metadata only.

### Outputs

The default dataset contains **successful checks only**. Example based on a recorded answer (9 Nov 2026; tracking ID changed and competitor details omitted):

```json
{
  "project": "hubspot-weekly-us",
  "brand": "HubSpot",
  "engine": "google_ai_overviews",
  "prompt": "what are the best crm platforms",
  "mentioned": true,
  "mentionCount": 1,
  "position": 1,
  "listRank": 2,
  "cited": false,
  "citationRank": null,
  "citedUrls": [],
  "topCitedDomains": ["forbes.com", "salesforce.com", "business.com", "youtube.com"],
  "answerExcerpt": "rting around $25/user/month up to $550. You can explore options on the Salesforce Best CRM Guide.\n- HubSpot: Best for service businesses and inbound marketing. It includes free tools for up to 2 users, strong lead-to-client pipelines, and paid plans scaling with automation.\n- Zoho CRM: Best value fo",
  "answerLength": 1842,
  "engineRunId": "9GgfpACw5gSTipVTW",
  "checkedAt": "2026-11-09T03:11:45.249700+00:00",
  "change": "first-run"
}
```

`OUTPUT` includes status (`complete`, `partial`, `invalid-input`, `charge-limit`), requested/planned/successful counts, failures, warnings, report URL, and per-project/per-engine aggregates:

- Visibility % = mentioned checks / successful checks × 100.
- Citation % = brand-cited checks / successful checks × 100.
- Average position excludes unmentioned checks.
- Share of voice = brand mentions / all brand-and-competitor mentions (fraction 0–1; report shows %).
- Competitor table uses the same all-tracked-name denominator.
- Deltas compare the last complete identical-input run; percentage deltas are percentage points.

Missing answers are **not** scored as absence. Zero successful checks show unavailable percentages, not fabricated zero visibility. A run with every requested answer analyzed is `complete`, even at exactly the tracker limit; `charge-limit` means work was skipped due to that limit. Missing answers or engine-budget skips produce `partial`. Invalid combinations produce `invalid-input`, with validation details and no engine calls. `OUTPUT` includes accounted engine spend.

`REPORT.html` is a single offline HTML page: inline CSS, no JavaScript or external resources, escaped user text, project sections, competitor tables and check excerpts. Find it through the run output links/status message or download it from the default key-value store.

History uses a named store `xyventures-geo-history-v1` on your account. Only complete projects replace snapshots, so failures/caps don't overwrite your baseline or cause false lost mentions. Changed prompts, names, aliases, domains, engines or locale start a new baseline. `trackChanges: false` disables history and change labels. Restricted storage permissions can make history unavailable; the output warns and processing continues. Avoid overlapping schedules for the same tracking ID: last complete writer wins.

### Transparent pricing

**Tracker event `visibility-check`: $0.035 per successful prompt × engine × tracked brand.** No tracker start fee, no extra fee for competitors, no tracker fee for failures or skipped work.

You pay the engine Actors' usage directly on your own Apify account, at your plan's rates, in addition to the tracker fee. Normal platform compute/storage usage for upstream engines can also apply; the tracker uses standard PPE (no additional tracker platform-usage pass-through). Engine prices checked 9 Nov 2026:

| Engine | Paid plan (Bronze) / answer | Free plan / answer |
|---|---:|---:|
| ChatGPT | $0.005 | $0.20 |
| Perplexity | $0.013 | $0.20 |
| Gemini | $0.005 | $0.20 |
| Google AI Overviews | $0.002 | $0.003 |
| Google AI Mode | $0.005 | $0.20 |

Each engine also charges a $0.00005 start event per GB, minimum one event. Other paid plans have different discounts. Store “from” prices are not universal. Check each engine's current Pricing tab before running. Retried batches can add upstream start/answer fees.

#### Measured Free-plan engine costs (9 Nov 2026)

Observed two-question engine runs used 512 MB and a 240-second timeout:

| Engine | Answers returned | Settled engine total |
|---|---:|---:|
| ChatGPT | 2/2 | $0.40005 |
| Perplexity | 2/2 | $0.40005 |
| Gemini | 2/2 | $0.40005 |
| Google AI Overviews | 2/2 | $0.00605 |
| Google AI Mode | 1/2 (partial timeout) | $0.20005 |

These totals include one $0.00005 start. The missing AI Mode answer is not averaged
into a cheaper advertised answer price. A single-Overview run used $0.00305 for the
engine plus approximately $0.00083 platform compute/storage. These historical
engine measurements exclude the tracker fee.

Run/monthly usage can briefly show only the start fee even after answers finish.
Budgeting therefore retains the larger of actual reported usage and conservative
answer/start estimates rather than assuming unreported usage is free.

**Monthly illustration:** one brand, 10 questions × 4 default engines × 4 weekly runs = 160 successful checks. Tracker fees cost **$5.60**. Engine answers cost **$1.00 Bronze** or **$24.12 Free**, plus approximately $0.0008 engine starts with 512 MB batches and no retries: total **$6.6008 Bronze** or **$29.7208 Free** (subscription and other platform usage excluded). For the Free-plan illustration set `maxEngineSpendUsd: 8` per run; the default $5 budget prevents collecting the full $6.03 of engine answers per run. Deduplicated agency prompts can reduce upstream answer costs, but each successful tracked-brand check still costs $0.035.

The tracker max charge per run and `maxEngineSpendUsd` are separate. The tracker checks its remaining event allowance before new work. Existing engine runs retain their assigned caps and may finish after the budget prevents new work. Upstream engines can overshoot a spending cap by a final event; the one-answer buffer mitigates this, but cannot guarantee against all overshoot or price changes.

### Scheduling and integrations

Save an Actor task with your input in Apify Console. Open **Schedules**, create a weekly schedule (for example Monday 09:00), and attach that saved task. Keep its tracking ID and questions stable. Apify handles scheduling. Export dataset rows as JSON/CSV/Excel; use `OUTPUT` in Make/n8n or fetch output links with the Apify API.

### FAQ and limitations

**Are these identical to ChatGPT/Gemini UI answers?** No guarantee. Upstream retrieval, account personalization, location, prompts and time can change answers.

**What does position mean?** Order of first mention among tracked names, not search-result rank. List rank counts list items in document order, even if displayed numbering starts elsewhere. Alias overlap between brands can make comparisons ambiguous; choose distinct names/aliases.

**Do citations mean endorsement?** No. We match domain references, not sentiment, factual accuracy, or commercial recommendation.

**Can I add custom engines or API keys?** Not in v1. Only the five allowlisted Apify Actors; no own AI API, Copilot or Bing.

**Can an engine fail?** Yes; Google may not generate an Overview. Results remain partial and missing checks are disclosed instead of being scored as brand absence.

**Are transient engine-start failures retried?** No. A child-engine start that fails or is not acknowledged is not retried in that run, even for transient failures, to avoid double spend. The output is partial. Inspect child runs, then start a new run containing only the missing prompts/engines.

**Does this store prompts?** They appear in the dataset/report and resumable STATE chunk results/rows. Runtime logs contain counts/status, not questions or child logs. History stores hashed check identifiers and summary/metric snapshots, not answer text. Your Apify storages retain customer data under your account; manage access/retention there.

# Actor input Schema

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

Required in simple mode. A whole-word name to track; e.g. HubSpot.

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

Public domain used for citation matching. Subdomains count; empty disables brand citation matching.

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

Alternative names counted with the brand. Whole-word, case-insensitive.

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

Each entry is Name or Name | domain.com. No additional fee for competitor analysis.

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

Single-line questions, maximum 100 per project including generated prompts. At least one is required unless generation is enabled.

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

Required when generatePrompts is enabled; e.g. CRM.

## `generatePrompts` (type: `boolean`):

Append deterministic templates, without an AI API call.

## `maxGeneratedPrompts` (type: `integer`):

Take up to this many available templates. The combined prompt list must stay at or below 100.

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

Select supported engines. Google AI Mode is optional. Gemini requires a $0.50 child cap plus one-answer safety headroom from your existing engine budget; it is skipped when its budget share is too small. No Copilot or Bing.

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

Two-letter country code. Four engines accept it; Google AI Overviews does not expose country control.

## `language` (type: `string`):

Language code. None of the five upstream Actors currently exposes language control; write prompts in your preferred language.

## `trackChanges` (type: `boolean`):

Store last complete summary/check metrics in an Actor-created named key-value store on your account. Identical inputs are required for deltas.

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

Stable project identifier; defaults to a hash of brand. Use distinct IDs for multiple projects with the same brand.

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

Global maximum attempted prompt × engine × brand checks, including agency mode. Truncates in project/prompt/engine order before calling engines.

## `maxEngineSpendUsd` (type: `number`):

Global engine-usage budget, default $5; tracker fees are separate ($0.035 per successful check). Free: $0.20/answer for ChatGPT/Perplexity/Gemini/AI Mode and $0.003 Overview; Bronze: $0.005/$0.013/$0.005/$0.005 and $0.002 Overview; higher paid plans discount further. All add $0.00005 start fees. This cap bounds child spending by splitting remaining budget across ≤20-prompt child calls, retaining one-event overshoot headroom. Available usage_total_usd is accounted at least at the answer/start estimate even with zero returned items; missing usage retains full reserved limits. No new child calls when funds cannot cover an answer. The platform may slightly overshoot a child limit.

## `agencyName` (type: `string`):

Optional report header for basic white-labeling; all text is HTML-escaped.

## `projects` (type: `array`):

1–100 project objects. Each uses simple-mode fields, with its own defaults, and requires brand plus prompts or generation. Top-level simple fields are ignored; top-level maxChecks and agencyName still apply. Optional project maxChecks adds a per-project cap.

## Actor input object example

```json
{
  "brand": "HubSpot",
  "brandDomain": "hubspot.com",
  "brandAliases": [],
  "competitors": [
    "Zoho CRM | zoho.com",
    "Pipedrive | pipedrive.com"
  ],
  "prompts": [
    "what are the best crm platforms"
  ],
  "category": "CRM",
  "generatePrompts": false,
  "maxGeneratedPrompts": 10,
  "engines": [
    "perplexity",
    "google_ai_overviews"
  ],
  "country": "US",
  "language": "en",
  "trackChanges": true,
  "maxChecks": 100,
  "maxEngineSpendUsd": 5
}
```

# Actor output Schema

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

No description

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

No description

## `report` (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": "HubSpot",
    "brandDomain": "hubspot.com",
    "competitors": [
        "Zoho CRM | zoho.com",
        "Pipedrive | pipedrive.com"
    ],
    "prompts": [
        "what are the best crm platforms"
    ],
    "category": "CRM",
    "engines": [
        "perplexity",
        "google_ai_overviews"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyventures/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": "HubSpot",
    "brandDomain": "hubspot.com",
    "competitors": [
        "Zoho CRM | zoho.com",
        "Pipedrive | pipedrive.com",
    ],
    "prompts": ["what are the best crm platforms"],
    "category": "CRM",
    "engines": [
        "perplexity",
        "google_ai_overviews",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("xyventures/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": "HubSpot",
  "brandDomain": "hubspot.com",
  "competitors": [
    "Zoho CRM | zoho.com",
    "Pipedrive | pipedrive.com"
  ],
  "prompts": [
    "what are the best crm platforms"
  ],
  "category": "CRM",
  "engines": [
    "perplexity",
    "google_ai_overviews"
  ]
}' |
apify call xyventures/ai-visibility-tracker --silent --output-dataset

```

## MCP server setup

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