# AI Visibility Tracker: ChatGPT, Perplexity, Gemini, Claude (`rjmacarthy/ai-search-visibility-tracker`) Actor

Track if ChatGPT, Perplexity, Gemini and Claude mention and cite your brand vs competitors: rank, citations, share of voice, HTML report. Official APIs.

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

## Pricing

from $50.00 / 1,000 prompt 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 Search Visibility Tracker: ChatGPT, Perplexity, Gemini & Claude brand mentions (GEO / AEO / LLM SEO)

**AI Search Visibility Tracker** shows whether **ChatGPT, Perplexity, Gemini and Claude** mention, rank and **cite your brand**
when buyers ask them for recommendations, and how you compare with your competitors. It is a generative engine
optimization (**GEO**) and answer engine optimization (**AEO**) rank tracker for marketers, SEO agencies and founders who
need to measure **AI visibility**, **share of voice in AI answers** and **LLM citations**, one run at a time or every week.

All four AI engines run in one go through their **official APIs with live web search**. No chat UI is scraped, so runs do
not break when a website changes. You get one row per prompt × engine, a share-of-voice summary, an HTML report, and
week-over-week changes.

### What does AI Search Visibility Tracker measure?

For every prompt (for example *"What is the best CRM for a small business?"*) and every engine, it records:

| Metric | What it tells you |
|---|---|
| **Brand mentioned** | Does the AI answer name your brand or one of its aliases? |
| **Rank** | Your position in the answer's list (#1, #2…) or, without a list, your order of first mention among tracked brands |
| **First mention index** | Where in the answer your brand first appears |
| **Competitors mentioned** | Which competitors appear, each with their own rank |
| **Citations** | Every source URL, domain and title the engine cited or consulted |
| **Own-domain cited** | Whether the AI cited *your* website, and which competitor domains it cited |
| **Sentiment** | Positive / neutral / negative / mixed tone around your brand (keyword heuristic) |
| **Cost and latency** | Estimated provider API cost and response time per check |

Then it adds a **summary** for each engine and overall:

- **Mention rate**: % of answers mentioning you.
- **Average rank**: lower is better.
- **Citation rate**: % of answers citing your domain.
- **Share of voice**: your mentions ÷ all tracked brands' mentions.
- **Citation share of voice**: citations to your domains ÷ citations to any tracked brand's domains.

The summary is also saved as a clean **HTML report**, with deltas versus your previous run.

### Why use this AI visibility tracker?

- **Four AI engines in one run:** ChatGPT (OpenAI), Perplexity, Gemini (Google) and Claude (Anthropic). No need to chain several single-engine scrapers.
- **Official APIs only:** OpenAI Responses API with web search, Perplexity Agent API with Sonar, Gemini API with Grounding with Google Search, and the Anthropic Messages API with web search. That means stable, documented outputs and no UI scraping.
- **Citations and own-domain tracking:** see which pages AI engines trust, whether your site is cited, and which competitor domains win the citation.
- **Share-of-voice summary and HTML report included for free.** There is no extra "report" fee.
- **Week-over-week deltas:** each run stores its summary, and the next run shows mention-rate, rank, citation and share-of-voice changes.
- **Reliable by design:** timeouts, retries with backoff on rate limits and server errors, and per-check error isolation. One engine failing never stops the run, and **failed checks are never charged**.
- **Bring your own API keys** for a much lower per-check price, or use the built-in keys and pay only per successful check.
- **Spend control:** the run stops cleanly when it reaches your "Maximum cost per run", so it never over-charges.
- **Lower cost per run:** $0.05 per check including analysis, summary and report. Comparable tools charge $0.05–$0.08 per check, often plus a per-report fee.

### How to track your brand in ChatGPT, Perplexity, Gemini and Claude

1. Click **Try for free**. The form opens in **Demo mode**, which returns realistic sample data at no cost so you can see the output.
2. Enter **your brand** (name and aliases), **your domains**, and your **competitors** (name, aliases, domains).
3. Add 5–20 **buyer-intent prompts**, the questions your customers ask AI assistants.
4. Pick the **AI engines** and a **country**.
5. **Untick Demo mode** and click **Start**.
6. Open the **HTML report** from the Output tab, or export the dataset to CSV, Excel, JSON or Google Sheets.

### Input example

```json
{
  "brand": { "name": "HubSpot", "aliases": ["HubSpot CRM"] },
  "brandDomains": ["hubspot.com"],
  "competitors": [
    { "name": "Salesforce", "aliases": ["Sales Cloud"], "domains": ["salesforce.com"] },
    { "name": "Pipedrive", "domains": ["pipedrive.com"] },
    { "name": "Zoho CRM", "aliases": ["Zoho"], "domains": ["zoho.com"] }
  ],
  "prompts": [
    "What is the best CRM for a small business?",
    "Which CRM is easiest to use for a startup sales team?",
    "What are good alternatives to Salesforce for a 10-person company?"
  ],
  "engines": ["chatgpt", "perplexity", "gemini", "claude"],
  "country": "US",
  "runsPerPrompt": 1,
  "compareWithPreviousRun": true
}
```

Optional settings:

- your own API keys: `openaiApiKey`, `perplexityApiKey`, `geminiApiKey`, `anthropicApiKey`
- per-engine models: `openaiModel`, `perplexityModel`, `geminiModel`, `claudeModel`
- `maxSearchesPerCheck`, `maxConcurrency`, `caseSensitive`, `historyKey`
- `mockMode`: Demo mode. It defaults to `false` for API and scheduled runs.

### Output example

One dataset item per prompt × engine (shortened):

```json
{
  "type": "check",
  "engine": "claude",
  "model": "claude-haiku-5-5",
  "prompt": "Which CRM is easiest to use for a startup sales team?",
  "answerText": "Based on current reviews and comparisons, here are the strongest options:\n\n1. **Salesforce** – …",
  "brandMentioned": true,
  "brandRank": 2,
  "brandRankSource": "list",
  "brandFirstMentionIndex": 171,
  "brandSentiment": "positive",
  "competitorsMentioned": [{ "name": "Salesforce", "rank": 1, "rankSource": "list", "mentionCount": 1 }],
  "ownDomainCited": true,
  "competitorDomainsCited": [{ "name": "Salesforce", "domain": "salesforce.com", "url": "https://www.salesforce.com/product", "cited": true }],
  "citations": [
    { "url": "https://www.hubspot.com/pricing", "domain": "hubspot.com", "title": "HubSpot Pricing & Plans", "cited": true, "entity": "HubSpot" }
  ],
  "costEstimateUsd": 0.012,
  "latencyMs": 8421,
  "chargedEvent": "prompt-check",
  "error": null,
  "timestamp": "2026-10-15T08:20:42.798Z"
}
```

The last item is the run summary (`"type": "summary"`), also saved as `SUMMARY` in the key-value store:

```json
{
  "type": "summary",
  "totals": { "successfulChecks": 11, "failedChecks": 1, "chargedEvents": { "prompt-check": 11 } },
  "overall": {
    "brand": { "name": "HubSpot", "mentionRatePct": 72.7, "avgRank": 2.25, "citationRatePct": 45.5, "shareOfVoicePct": 24.2 },
    "competitors": [{ "name": "Salesforce", "mentionRatePct": 100, "avgRank": 1.45, "shareOfVoicePct": 33.3 }]
  },
  "byEngine": { "chatgpt": { "...": "same metrics per engine" } },
  "comparison": { "previousRunAt": "2026-10-08T08:00:00.000Z", "deltas": { "byEngine": { "claude": { "brandMentionRatePct": 16.7, "brandShareOfVoicePct": 5.5 } } } }
}
```

Dataset views: **Overview** (one row per check), **Citations** (one row per source URL) and **Answers** (full answer text).
The run's **Output** tab links the **HTML report** (`REPORT.html`). A failed check appears as an item with an `error` message and is not charged.

### Pricing

Pay per event. You only pay for successful checks:

| Event | Price | When |
|---|---|---|
| **Prompt check** (`prompt-check`) | **$0.05** | One prompt answered by one AI engine using the built-in API keys |
| **Prompt check, own API key** (`prompt-check-byok`) | **$0.01** | Same, using your own OpenAI / Perplexity / Gemini / Anthropic key. You pay the provider directly |
| Summary, HTML report, run-over-run comparison | Free | Every run |
| Failed checks | Free | Never charged |
| Demo mode | Free | Sample data, no AI calls |

Examples:

- 10 prompts × 4 engines = 40 checks = **$2.00 per run**, or about **$8.70/month** run weekly.
- The same run with your own keys costs $0.40, plus your provider API costs (roughly $0.005–0.03 per check).

Set **Maximum cost per run** in the run options to cap spend. When the cap is reached the Actor stops gracefully, says
so in the status message, and summarises what it checked.

### Weekly AI visibility tracking for SEO agencies

AI answers change as engines update and new content is published, so measure the trend, not a single snapshot.

1. Create one **Task** per client (brand, competitors, prompts).
2. Add a **Schedule** (for example every Monday at 07:00) for each task.
3. Keep **Compare with previous run** on. Each run stores its summary in a named key-value store in your account
   (`ai-visibility-history`) and reports the changes in mention rate, average rank, citation rate and share of voice, per engine and overall.
4. Send results to clients with integrations: Google Sheets, Slack or email on run finish, or a webhook into your
   reporting stack. Share the **HTML report** link straight from the run.

Tip: set `runsPerPrompt` to 2–3 for steadier numbers, because AI answers vary between calls.

### Integrations and API

- **Apify API, JavaScript and Python clients:** start runs and fetch the dataset or `SUMMARY` record programmatically.
- **Make, Zapier, n8n, Google Sheets, Slack, Airbyte** and **webhooks** through Apify integrations.
- **AI agents / MCP:** callable from the Apify MCP server. Pay-per-event pricing with no Standby mode keeps it compatible with agentic payments.

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<username>/ai-search-visibility-tracker').call({
    brand: { name: 'HubSpot' }, brandDomains: ['hubspot.com'],
    competitors: ['Salesforce', 'Pipedrive'], prompts: ['What is the best CRM for a small business?'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### FAQ

**Why can results differ from what I see in the ChatGPT, Perplexity, Gemini or Claude apps?**
This Actor uses each provider's official developer API with web search turned on. The consumer apps add things the APIs
do not: personalisation and memory, account history, different default or newer models, their own system prompts, and
sometimes different search backends and ranking. Answers are also probabilistic and change between calls and over time.
Treat the numbers as a consistent, repeatable measurement of AI visibility, and compare trends, not single answers.
Use `runsPerPrompt` for steadier rates.

**Which models are used?**
By default: `gpt-6-luna` (ChatGPT), `perplexity/sonar` (Perplexity Agent API), `gemini-3.5-flash-lite` (Gemini) and
`claude-haiku-5-5` (Claude). These are cheap, current, search-capable models. With your own API keys you can choose any
model the provider offers.

**Does it scrape ChatGPT or Perplexity?**
No. Only official APIs are used.

**How is rank calculated?**
If the answer contains a numbered or bulleted list and your brand heads a list item, rank is that list position.
Otherwise rank is your order of first mention among the tracked brands. The `brandRankSource` field says which one was used.

**How is share of voice calculated?**
Your brand's answers-with-a-mention divided by the sum of answers-with-a-mention across your brand and all tracked competitors.
Citation share of voice uses citations to each brand's domains instead.

**How is sentiment detected?**
With a lightweight keyword heuristic on the sentences that mention your brand (no extra AI call, no extra cost).
It is a quick signal, not a full sentiment analysis.

**Are my API keys safe?**
Keys you enter are stored encrypted by Apify as secret input. They are sent only to the provider's official API and are
never logged or written to the output.

**What happens if an engine fails or is rate limited?**
Each call is retried with backoff on rate limits, server errors and timeouts. If it still fails, that check is recorded
with an `error` field, is not charged, and the rest of the run continues.

**Why do Gemini citation URLs start with vertexaisearch.cloud.google.com?**
That is how Google's grounding API returns source links: they are redirect URLs. The Actor reads the real source domain
from the grounding metadata, so domain and own-domain tracking still work.

**What is Demo mode?**
The input form opens with Demo mode ticked, so you can see the full output, dataset views and report for free with
realistic sample answers. One sample check deliberately fails to show how errors are reported. Untick it for real
tracking. API, schedule and integration runs default to real checks unless `mockMode` is `true`.

**What happens if no API keys are available?**
If you turn Demo mode off without providing keys, and no built-in key is available for the selected engines, the run
stops immediately with a message explaining what to add. Nothing is charged.

### Limits

- **Free Apify plan: up to 12 checks per run use the built-in API keys.** The run then stops gracefully with a clear
  message. Checks that use your own API keys are not limited. Paid Apify plans have no such limit.
- Up to 200 prompts, 25 competitors and 10 runs per prompt per run.
- With the built-in keys, only the default cost-efficient models can be used, with at most 3 web searches per check.
  With your own keys any model is allowed.
- Location: ChatGPT, Perplexity and Claude receive the country as a search location. Gemini's API has no location
  parameter, so it gets a one-line location hint instead.
- Brand matching is whole-word and case-insensitive by default. Use aliases for variants, and case-sensitive matching for
  brand names that are also common words.
- Sentiment is a keyword heuristic. Rank uses list detection and mention order. Both are approximations of how a human
  would read the answer.
- Results reflect the APIs at the time of the run and are not identical to the consumer apps (see FAQ).

# Actor input Schema

## `mockMode` (type: `boolean`):

When ticked, the Actor runs the full pipeline on realistic <strong>generated sample answers</strong> instead of calling the AI engines, and nothing is charged. <strong>Untick to track your brand with real ChatGPT, Perplexity, Gemini and Claude answers.</strong> Runs started via API, schedules or integrations default to real checks (off) unless you set this to true.

## `brand` (type: `object`):

The brand to track. Add aliases for product names, short names or common spellings. Matching is case-insensitive and whole-word ("Hub" never matches "GitHub").

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

Domains you own, used to detect when an AI answer cites your site. Subdomains count (blog.example.com matches example.com).

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

Competitors to benchmark against. Each item: <code>{"name": "Salesforce", "aliases": \["Sales Cloud"], "domains": \["salesforce.com"]}</code>. Plain strings like <code>"Pipedrive"</code> also work. Up to 25.

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

Buyer-intent questions your customers ask AI assistants. Do not include your brand name unless you want to test a branded query. Each prompt is checked once per selected engine (times "Runs per prompt"). Up to 200.

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

Which AI engines to check. Each prompt x engine is one check.

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

Two-letter ISO country code (US, GB, DE, FR...) passed to each engine's web search as the user's approximate location. Gemini has no location parameter, so it gets a one-line system hint instead. Leave empty for no location hint.

## `runsPerPrompt` (type: `integer`):

AI answers vary from call to call. Running each prompt 2-3 times gives steadier mention rates. Every run is a separate check.

## `compareWithPreviousRun` (type: `boolean`):

Saves this run's summary in a named key-value store in your account and shows changes (mention rate, rank, citation rate, share of voice) versus the previous run with the same brand, prompts, engines and country. Ideal for weekly schedules.

## `historyKey` (type: `string`):

Key under which the summary is stored for comparisons. Leave empty to derive it from the brand, prompts, engines and country. Set it to keep comparing after you edit prompts.

## `historyStoreName` (type: `string`):

Named key-value store that keeps run history.

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

Optional. Use your own OpenAI key for ChatGPT checks and pay the much lower bring-your-own-key price. Stored encrypted, never logged or saved to the output.

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

Optional. Your own Perplexity API key.

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

Optional. Your own Google AI Studio (Gemini API) key.

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

Optional. Your own Anthropic (Claude) API key.

## `useBuiltInKeys` (type: `boolean`):

Untick to run only the engines for which you supplied your own key (so you are only ever charged the bring-your-own-key price).

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

OpenAI model with web search support. With built-in keys only these are allowed: gpt-6-luna (default), gpt-5.6-luna, gpt-5-nano, gpt-5-mini, gpt-4.1-mini, gpt-4o-mini. With your own key, any model.

## `perplexityModel` (type: `string`):

Perplexity Agent API model, default perplexity/sonar. With your own key you can use any Agent API model, or a preset written as preset:fast.

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

Gemini model with Google Search grounding. Built-in keys: gemini-3.5-flash-lite (default), gemini-2.5-flash-lite, gemini-2.5-flash.

## `claudeModel` (type: `string`):

Claude model with the web search tool. Built-in keys: claude-haiku-5-5 (default).

## `maxSearchesPerCheck` (type: `integer`):

Upper limit on web searches per answer for ChatGPT and Claude (other engines decide themselves). Capped at 3 on built-in keys.

## `encourageWebSearch` (type: `boolean`):

Adds one brand-neutral instruction ("search the web for current information and cite your sources"), so answers are grounded like the consumer search experience. Your brand and competitors are never mentioned to the engines.

## `caseSensitive` (type: `boolean`):

Turn on for brand names that are also common words (e.g. Notion, Monday).

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

How many checks run in parallel.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each API call. Web-search answers can take 30-90 seconds.

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

Retries per check on rate limits (429), server errors (5xx) and timeouts, with exponential backoff.

## Actor input object example

```json
{
  "mockMode": true,
  "brand": {
    "name": "HubSpot",
    "aliases": [
      "HubSpot CRM"
    ]
  },
  "brandDomains": [
    "hubspot.com"
  ],
  "competitors": [
    {
      "name": "Salesforce",
      "aliases": [
        "Sales Cloud"
      ],
      "domains": [
        "salesforce.com"
      ]
    },
    {
      "name": "Pipedrive",
      "aliases": [],
      "domains": [
        "pipedrive.com"
      ]
    },
    {
      "name": "Zoho CRM",
      "aliases": [
        "Zoho"
      ],
      "domains": [
        "zoho.com"
      ]
    }
  ],
  "prompts": [
    "What is the best CRM for a small business?",
    "Which CRM is easiest to use for a startup sales team?",
    "What are good alternatives to Salesforce for a 10-person company?"
  ],
  "engines": [
    "chatgpt",
    "perplexity",
    "gemini",
    "claude"
  ],
  "country": "US",
  "runsPerPrompt": 1,
  "compareWithPreviousRun": true,
  "historyStoreName": "ai-visibility-history",
  "useBuiltInKeys": true,
  "maxSearchesPerCheck": 2,
  "encourageWebSearch": true,
  "caseSensitive": false,
  "maxConcurrency": 4,
  "requestTimeoutSecs": 120,
  "maxRetries": 3
}
```

# Actor output Schema

## `report` (type: `string`):

Share-of-voice report with per-engine and per-prompt tables and run-over-run changes.

## `results` (type: `string`):

One item per prompt x engine check, plus a final summary item.

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

Per-engine and overall mention rate, average rank, citation rate, share of voice and deltas.

# 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 = {
    "mockMode": true,
    "brand": {
        "name": "HubSpot",
        "aliases": [
            "HubSpot CRM"
        ]
    },
    "brandDomains": [
        "hubspot.com"
    ],
    "competitors": [
        {
            "name": "Salesforce",
            "aliases": [
                "Sales Cloud"
            ],
            "domains": [
                "salesforce.com"
            ]
        },
        {
            "name": "Pipedrive",
            "aliases": [],
            "domains": [
                "pipedrive.com"
            ]
        },
        {
            "name": "Zoho CRM",
            "aliases": [
                "Zoho"
            ],
            "domains": [
                "zoho.com"
            ]
        }
    ],
    "prompts": [
        "What is the best CRM for a small business?",
        "Which CRM is easiest to use for a startup sales team?",
        "What are good alternatives to Salesforce for a 10-person company?"
    ],
    "engines": [
        "chatgpt",
        "perplexity",
        "gemini",
        "claude"
    ],
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("rjmacarthy/ai-search-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 = {
    "mockMode": True,
    "brand": {
        "name": "HubSpot",
        "aliases": ["HubSpot CRM"],
    },
    "brandDomains": ["hubspot.com"],
    "competitors": [
        {
            "name": "Salesforce",
            "aliases": ["Sales Cloud"],
            "domains": ["salesforce.com"],
        },
        {
            "name": "Pipedrive",
            "aliases": [],
            "domains": ["pipedrive.com"],
        },
        {
            "name": "Zoho CRM",
            "aliases": ["Zoho"],
            "domains": ["zoho.com"],
        },
    ],
    "prompts": [
        "What is the best CRM for a small business?",
        "Which CRM is easiest to use for a startup sales team?",
        "What are good alternatives to Salesforce for a 10-person company?",
    ],
    "engines": [
        "chatgpt",
        "perplexity",
        "gemini",
        "claude",
    ],
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("rjmacarthy/ai-search-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 '{
  "mockMode": true,
  "brand": {
    "name": "HubSpot",
    "aliases": [
      "HubSpot CRM"
    ]
  },
  "brandDomains": [
    "hubspot.com"
  ],
  "competitors": [
    {
      "name": "Salesforce",
      "aliases": [
        "Sales Cloud"
      ],
      "domains": [
        "salesforce.com"
      ]
    },
    {
      "name": "Pipedrive",
      "aliases": [],
      "domains": [
        "pipedrive.com"
      ]
    },
    {
      "name": "Zoho CRM",
      "aliases": [
        "Zoho"
      ],
      "domains": [
        "zoho.com"
      ]
    }
  ],
  "prompts": [
    "What is the best CRM for a small business?",
    "Which CRM is easiest to use for a startup sales team?",
    "What are good alternatives to Salesforce for a 10-person company?"
  ],
  "engines": [
    "chatgpt",
    "perplexity",
    "gemini",
    "claude"
  ],
  "country": "US"
}' |
apify call rjmacarthy/ai-search-visibility-tracker --silent --output-dataset

```

## MCP server setup

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