# AI Brand Visibility Tracker: ChatGPT, Perplexity & Gemini (`tan_carrel_h1q/ai-search-brand-visibility-monitor`) Actor

Check if ChatGPT, Perplexity & Gemini mention your brand. Visibility %, share of voice, sources, run-over-run trends and an HTML report. Pay per check, no subscription.

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

## Pricing

from $50.00 / 1,000 ai answer 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 Answer Scorecard: an AI brand visibility tracker for ChatGPT, Perplexity and Gemini (GEO / AEO).** Check whether AI search recommends your brand or your competitors, then **track the change run after run**. Pay per check, **from $0.015 with your own API key, $0.05 with ours**, no subscription. Visibility %, share of voice, position, cited sources and a client-ready HTML report.

> **Try it free:** tick **Demo mode** (no AI calls, labelled example data) or paste your **own OpenAI / Perplexity / Gemini API key**: own-key checks work on every Apify plan, including free. The Actor's built-in keys need a paid Apify plan. A free-plan run without a key still finishes successfully with a clearly labelled demo result that tells you how to get real numbers.

#### What does AI Answer Scorecard track?

Give it your brand, your competitors and the questions your buyers ask. It asks OpenAI, Perplexity and Google Gemini each question through their official APIs and reports for every answer:

- Is your brand mentioned, in which position (1st, 2nd, 3rd…) and at which list rank?
- Which competitors are mentioned, and in which order?
- Which websites were cited as sources, and was *your* domain one of them? (OpenAI answers are always run with web search, so they carry cited sources.)
- How positive or negative is the sentence about your brand?
- Your **visibility %**, **share of voice** and **top cited domains** per engine.

#### How do I track my AI visibility week over week?

**Tracking is the point of the Actor.** A single check tells you where you stand; the trend tells you whether your content and PR work. Every real run:

1. saves a compact summary in a **named key-value store in your own Apify account** (`ai-answer-scorecard-<brand>-<id>`, last 52 runs, nothing leaves your account);
2. compares itself with the previous run and shows **▲ / ▼ changes** for visibility %, share of voice, average position and cited-as-a-source %, **per engine, per prompt and per competitor** (who moved up or down a place);
3. draws **sparkline charts and a history table for the last 12 runs** in the HTML report;
4. writes the same numbers to `SUMMARY.tracking` and adds `previousVisibilityPct` and `changeVsPrevious` (`gained` / `lost` / `unchanged`) to every dataset row, so you can push them straight to Google Sheets, Slack or a dashboard.

Changes that are smaller than the sampling noise are tagged **"within noise"** (the 95% ranges of the two runs overlap), so you do not chase random wobble. Set **Runs per prompt** to 3 or more to get a 95% confidence range around every visibility figure.

**Schedule it weekly (no extra cost from us beyond the checks):**

1. Run the Actor once with your real input and save it as a **Task** (Console → *Save as a new task*).
2. Open **Schedules → Create new**, set a cron such as `0 8 * * 1` (every Monday 08:00), and add the task as the action.
3. Done. Each Monday's run is compared with the previous one. Keep the input the same (same brand, same prompts) so the comparison is like-for-like. Use **Tracking ID** to keep separate histories for the same brand, for example per country (`acme-uk`, `acme-us`). If you change the prompt list the report says so and compares only the prompts present in both runs.

Scheduling costs nothing on top of the per-check price. Apify's own platform usage for a run of this size is a fraction of a cent. Optionally add a **webhook / integration** (Google Sheets, Slack, Make, Zapier) on the schedule's runs to get the new numbers delivered automatically.

#### What does the AI Answer Scorecard report look like?

A one-page, self-contained HTML report (`report.html` in the run's key-value store, open it in a browser or send it to a client):

- **KPI cards** with ▲/▼ chips: visibility, share of voice, average position, cited as a source
- **Trend since the previous run**: sparkline charts, change by engine, competitor movement, prompts that moved, last-12-runs history table
- **By engine, share of voice vs competitors, most cited sources, visibility by prompt, sample answers** with their sources

*See it yourself in 30 seconds:* tick **Demo mode** and run twice, setting **Demo variation** to 1 on the second run. The second report shows the ▲/▼ chips and charts for your own brand and competitors (labelled demo data, nothing billed).

#### How much does it cost?

Pay per event, only for answers actually delivered. No monthly fee.

| Event | Price | When |
|---|---|---|
| AI answer check | **$0.05** | One answer from OpenAI, Perplexity or Gemini on the Actor's built-in keys |
| Grounded Gemini answer check | **$0.10** | One Gemini answer grounded with Google Search (Google bills searches separately) |
| AI answer check (own API key) | **$0.015** | You supplied your own API key and also pay the AI provider directly |

Examples: the default 2 prompts × 3 engines = 6 checks ≈ **$0.30**. Weekly tracking of 15 prompts × 3 engines ≈ 195 checks a month ≈ **$9.75** (about $4–6 with your own keys plus provider fees). Failed answers, engines without a key and answers skipped because you hit your run's **maximum cost per run** are never billed. The Actor never starts a paid AI call it could not bill.

> The live prices are shown on this page's pricing panel.

#### How does it compare with subscription AI-visibility tools?

Prices below are public list prices checked on **29 Oct 2026**; they change often, so verify before you decide. The per-answer figures are our estimates for daily tracking at full plan usage.

| Tool | Public price | What you get | Approx. cost per answer at full daily use |
|---|---|---|---|
| [Otterly.AI](https://otterly.ai/pricing) | $29 / $189 / $489 per month | 15 / 100 / 400 prompts on 4 engines; some engines are paid add-ons | about $0.016 (Lite) |
| [Peec AI](https://llm-visibility-tracker.com/peec-ai-pricing/) (third-party price tracker, 8 Oct 2026) | about $95 / $245 / $495 per month | 50 / 150 / 350 prompts, 3 models, daily | about $0.021 (Starter) |
| HubSpot AEO | $50 per month | 25 prompts daily on ChatGPT, Perplexity, Gemini | about $0.022 |
| **AI Answer Scorecard** | **$0.05 per check, $0.015 with your own key** | Any number of prompts, 3 engines, tracking + report | pay only for the checks you run |

**Honest take:** for *daily, heavy* tracking a subscription is cheaper per answer. This Actor wins for **weekly or occasional tracking, one-off audits, agency pitches and anything where you do not want a monthly commitment**. A 15-prompt × 3-engine weekly check is about $9.75 a month here, with no contract.

#### How do I run it from the API?

Replace `<APIFY_TOKEN>` with your token (Console → Settings → API & Integrations).

```bash
curl -X POST "https://api.apify.com/v2/acts/tan_carrel_h1q~ai-search-brand-visibility-monitor/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"brandName":"Notion","brandDomain":"notion.com","competitors":["Evernote","Obsidian"],"prompts":["What is the best note-taking app for a small team?"],"engines":["openai"],"openaiApiKey":"<YOUR_OPENAI_KEY>"}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('tan_carrel_h1q/ai-search-brand-visibility-monitor').call({
    brandName: 'Notion',
    brandDomain: 'notion.com',
    competitors: ['Evernote', 'Obsidian'],
    prompts: ['What is the best note-taking app for a small team?'],
    trackingId: 'notion-weekly',
});
const summary = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('SUMMARY');
console.log(summary.value.headline, summary.value.tracking?.overall?.visibilityPct);
```

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("tan_carrel_h1q/ai-search-brand-visibility-monitor").call(run_input={
    "brandName": "Notion",
    "brandDomain": "notion.com",
    "competitors": ["Evernote", "Obsidian"],
    "prompts": ["What is the best note-taking app for a small team?"],
    "trackingId": "notion-weekly",
})
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
print(summary["headline"], summary.get("tracking", {}).get("overall", {}).get("visibilityPct"))
```

#### Can I use it with AI agents through the Apify MCP server?

Yes. Add the hosted [Apify MCP server](https://docs.apify.com/mcp) to Claude, Cursor, VS Code or any MCP client and your agent can discover and run this Actor on its own:

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=tan_carrel_h1q/ai-search-brand-visibility-monitor" }
  }
}
```

Example prompt: *"Use AI Answer Scorecard to check whether ChatGPT, Perplexity and Gemini recommend Notion for 'best note-taking app for a small team', compare with Evernote and Obsidian, and tell me what changed since the last run."* Agents with the default Apify tools can also find it with `search-actors` ("does ChatGPT recommend my brand").

#### How do I use it?

1. Enter your **brand name** (plus aliases and your domain, e.g. `notion.com`).
2. Add **competitors**. Use `Name | alias | domain.com` to give a competitor aliases or a domain.
3. Add **prompts**: realistic buyer questions, e.g. *"What is the best CRM for a 10-person agency?"*. Include some that do not name any brand.
4. Pick the **engines**, press **Start**, then schedule the same task weekly. Optionally set a country and answer language.

Input example:

```json
{
  "brandName": "Notion",
  "brandAliases": ["Notion Labs"],
  "brandDomain": "notion.com",
  "competitors": ["Evernote", "Obsidian", "Coda | Coda.io | coda.io", "ClickUp", "Confluence"],
  "prompts": [
    "What is the best note-taking and knowledge management app for a small team?",
    "Which tools should a startup use to organize documents and project wikis?"
  ],
  "engines": ["openai", "perplexity", "gemini"],
  "runsPerPrompt": 1,
  "country": "GB",
  "trackingId": "notion-uk-weekly"
}
```

#### What data do I get?

| Output | Where | What it contains |
|---|---|---|
| **Answer rows** | Default dataset (view "Overview") | One row per engine × prompt × run: `brandMentioned`, `brandPosition`, `brandListRank`, `competitorsMentioned`, `citations`, `citedDomains`, `brandCited`, `shareOfVoice`, `sentiment`, `sentimentSnippet`, full `answer`, `previousVisibilityPct`, `changeVsPrevious`, `timestamp` |
| **Summary** | Key-value store record `SUMMARY` | Visibility %, share of voice, per engine and per prompt; top cited domains; run details; **`tracking`**: deltas vs the previous run, competitor movement, last-12-runs history |
| **HTML report** | Key-value store record `report.html` | The shareable AI Answer Scorecard with trend charts |
| **History** | Named key-value store `ai-answer-scorecard-…` in your account | Compact snapshot of each run (last 52) used for comparisons; delete the store to reset your history |

One dataset row (shortened):

```json
{
  "checkId": "perplexity:1:1",
  "engine": "perplexity",
  "prompt": "What is the best note-taking and knowledge management app for a small team?",
  "brand": "Notion",
  "brandMentioned": true,
  "brandPosition": 2,
  "competitorsMentioned": [{ "name": "Evernote", "mentions": 1, "position": 1 }],
  "shareOfVoice": 40,
  "sentiment": "positive",
  "brandCited": true,
  "citedDomains": ["notion.com", "g2.com"],
  "previousVisibilityPct": 0,
  "changeVsPrevious": "gained"
}
```

`SUMMARY.tracking.overall.visibilityPct` (shortened):

```json
{ "value": 66.7, "previous": 50, "delta": 16.7, "trend": "up", "better": true, "withinNoise": true }
```

*(Example values are illustrative.)*

#### How are the metrics defined?

- **Visibility %**: share of answers that mention your brand at least once. With *Runs per prompt* above 1 the report adds a 95% Wilson range (each check treated as an independent trial: a rough guide to sampling noise).
- **Position**: the order in which brands first appear in the answer (1 = first named among you and your competitors). **List rank**: the item number if the answer is a numbered or bulleted list. For the average position, lower is better.
- **Share of voice**: your mentions ÷ all mentions of you and the listed competitors.
- **Cited %**: share of answers whose source list contains your domain (needs `brandDomain`).
- **Matching**: case-insensitive, whole words, aliases, and domain/URL matching. A name followed directly by `.letters` (e.g. `Acme.community`) is treated as part of a domain, not a mention.
- **Sentiment**: a transparent keyword heuristic on the sentences mentioning your brand, English only. Treat it as a pointer to read the snippet, not as a verdict.

#### What is GEO or AEO, and what is share of voice in AI search?

Generative Engine Optimization (GEO) and Answer Engine Optimization (AEO) mean improving how often, and how favourably, AI assistants name and cite your brand. **AI share of voice** is your brand's share of all brand mentions (yours plus the competitors you list) across the AI answers to your buyer questions: the AI-search equivalent of rank tracking and share of voice in SEO.

#### Free Apify plan: own API key or demo

Apify does not pay developers for runs from free plans, and every check on the built-in keys costs real money, so **the built-in keys need a paid Apify plan** (trials count as paid). On a free plan you can still:

- **Use your own API key**: paste your OpenAI, Perplexity and/or Gemini key into the secret input fields. $0.015 per check, and you also pay your AI provider.
- **Use Demo mode**: free canned example data with the full tracking and report layout.

A free-plan run with no usable key does not fail: it makes no AI call, charges nothing and finishes successfully with a **clearly labelled DEMO result** (dataset, summary and report all marked as demo, plus a message on how to get real results). Demo results are never written to your tracking history.

#### FAQ

**Which models are queried?** Defaults: OpenAI `gpt-4o-mini` always with web search (so answers cite sources), Perplexity `perplexity/sonar`, Gemini `gemini-3.5-flash-lite`. With your own key you can choose any model. These are the **API** versions: answers in the consumer apps (ChatGPT, Perplexity, Gemini and Google AI Overviews) can differ because those apps use their own system prompts, personalisation and ranking layers.

**Is this the same as what my customers see in ChatGPT?** Not exactly. It is a consistent, repeatable *proxy* using the official APIs with web search or grounding enabled. Use it for trends and competitor comparisons, not as a replica of a consumer app.

**Why does the same prompt give different results?** LLMs are non-deterministic. Use *Runs per prompt* of 3–5 and watch the trend over several runs rather than a single number.

**Does Gemini use Google Search?** Only if you tick "Gemini: ground answers with Google Search" (premium event). Without it Gemini answers from its training data and returns no sources.

**Where is my tracking history stored, and can I delete it?** In a named key-value store (`ai-answer-scorecard-…`) inside your own Apify account. Delete the store, or untick *Track results over time*, to reset or stop it.

**What if an API key is missing or invalid?** Engines without a key are skipped with a clear log message; an engine whose key is rejected or out of quota is switched off for the rest of the run while the others continue. If *no* engine has a key you get the labelled demo result.

**Is it legal and allowed?** The Actor calls official APIs, not websites. You are responsible for the prompts you submit and for complying with the AI providers' terms for your own key.

**Where do I report a problem?** Use the **Issues** tab of this Actor.

#### Limitations

- English-only sentiment heuristic; matching is lexical (it does not understand context such as a brand that is also a common word: add precise aliases and use the domain).
- API answers are not identical to consumer chat apps; Google AI Overviews and AI Mode are **not** measured, and Claude, Copilot and Grok are not covered (Claude and others may be added later).
- Gemini without grounding returns no sources; grounded Gemini cites redirect links whose domain is taken from the source title.
- Position is the order of first mention in text: a proxy for prominence, not an official ranking.
- Trends are only as stable as the sampling: with a few prompts and one run each, week-to-week moves are often noise (the report flags this).
- Provider-side limits (rate limits, outages, deprecated models) can cause failed checks; they are retried, then reported in the `ERRORS` record and not billed.
- Up to 100 prompts, 30 competitors and 1,000 checks per run.

#### Not affiliated

AI Answer Scorecard is an independent tool. It is **not affiliated with, endorsed by or sponsored by** OpenAI, Perplexity, Google or any brand you monitor. Product names are used only to describe which API is queried.

#### Technical notes

- Node.js 22 on the Apify platform, `apify` SDK, no browser, 256 MB memory is enough.
- Local development: `npm install && npm test && npm run mock` (mock mode needs no API keys).
- The Actor owner's keys are the secret environment variables `OPENAI_API_KEY`, `PERPLEXITY_API_KEY`, `GEMINI_API_KEY`.

# Changelog

This Actor's version history is a separate document: https://apify.com/tan_carrel_h1q/ai-search-brand-visibility-monitor/changelog.md

# Actor input Schema

## `brandName` (type: `string`):

The brand you want to track, exactly as people write it (e.g. "Notion"). Matching is case-insensitive and respects word boundaries.

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

Other names that count as a mention of your brand: product names, abbreviations, common misspellings, legal names.

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

Your website domain (e.g. notion.com). A mention of the domain counts as a brand mention, and sources on this domain count as "cited".

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

Competing brands to compare against (share of voice). Plain names work; for aliases and a domain use "Name | alias one, alias two | domain.com". A bare domain like "coda.io" also works.

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

Questions a buyer might ask an AI assistant, without naming your brand (e.g. "What is the best CRM for a small agency?"). Each prompt is sent to every selected engine.

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

Which official APIs to query. Engines without an available API key are skipped with a warning.

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

AI answers vary from run to run. Run each prompt several times per engine to get a more stable visibility %. Each run is a separate billed check.

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

Two-letter ISO country code (e.g. US, GB, DE). Used as a location hint for web search and added to the prompt context.

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

Language the AI should answer in (e.g. English, German, Español).

## `geminiGrounding` (type: `boolean`):

Gives Gemini live Google Search results and returns the cited sources. Google bills this per search, so these checks use the higher-priced "grounded Gemini check" event. With your own Gemini key it is billed as a regular own-key check.

## `openaiWebSearch` (type: `boolean`):

Lets the OpenAI model use its web search tool (closer to how ChatGPT answers, and returns cited sources). Turn off for answers from the model's training knowledge only.

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

Model used with the built-in key. Use your own key and the custom models field below for any other model.

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

Model used with the built-in key.

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

Model used with the built-in key.

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

Bring your own key: OpenAI usage is billed to your OpenAI account and checks are billed at the lower "own key" rate. Stored encrypted by Apify; never logged. Required on a free Apify plan; paid plans may omit it.

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

Bring your own key: Perplexity usage is billed to your account and checks use the lower "own key" rate. Stored encrypted by Apify; never logged. Required on a free Apify plan; paid plans may omit it.

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

Bring your own key: Gemini usage is billed to your Google account and checks use the lower "own key" rate. Stored encrypted by Apify; never logged. Required on a free Apify plan; paid plans may omit it.

## `customModels` (type: `object`):

Override the model per engine, e.g. {"openai": "gpt-4.1", "gemini": "gemini-3.8-flash"}. Only applied to engines where you supplied your own API key.

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

Replaces the neutral built-in instruction sent to every engine. Leave empty unless you know you need it; do not mention your brand here or you will bias the results.

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

Safety cap on the number of engine x prompt x run checks. The run also stops gracefully when Apify's "Maximum cost per run" is reached.

## `concurrency` (type: `integer`):

How many AI requests run at the same time.

## `requestsPerMinutePerEngine` (type: `integer`):

Client-side rate limit to stay inside provider limits (new API accounts often have low limits).

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

Per-attempt timeout for each AI API request.

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

Retries with exponential backoff on rate limits, timeouts and server errors. Failed checks are never billed.

## `trackHistory` (type: `boolean`):

Saves a compact summary of every run in a named key-value store in YOUR Apify account and compares each run with the previous one (visibility, share of voice, position, sources, competitors). Schedule the Actor weekly to build a trend. Nothing extra is billed. Not used for demo results.

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

Runs with the same Tracking ID share one history. Leave empty to use your brand name + domain. Use different IDs to track the same brand separately, for example per country or per prompt set: "acme-uk", "acme-us".

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

Runs the whole pipeline on canned example answers so you can see the output format and the tracking section without spending anything. Limited to 30 checks and clearly marked as demo data. Works on every plan, including free.

## `mockVariation` (type: `integer`):

Demo mode only: a different number re-rolls the canned example answers, so you can watch the trend section change between two demo runs. Ignored for real runs.

## Actor input object example

```json
{
  "brandName": "Notion",
  "brandAliases": [
    "Notion Labs"
  ],
  "brandDomain": "notion.com",
  "competitors": [
    "Evernote",
    "Obsidian",
    "Coda | Coda.io | coda.io",
    "ClickUp",
    "Confluence"
  ],
  "prompts": [
    "What is the best note-taking and knowledge management app for a small team?",
    "Which tools should a startup use to organize documents and project wikis?"
  ],
  "engines": [
    "openai",
    "perplexity",
    "gemini"
  ],
  "runsPerPrompt": 1,
  "geminiGrounding": false,
  "openaiWebSearch": true,
  "openaiModel": "gpt-4o-mini",
  "perplexityModel": "perplexity/sonar",
  "geminiModel": "gemini-3.5-flash-lite",
  "customModels": {},
  "maxChecks": 500,
  "concurrency": 4,
  "requestsPerMinutePerEngine": 60,
  "requestTimeoutSecs": 90,
  "maxRetries": 3,
  "trackHistory": true,
  "mockMode": false,
  "mockVariation": 0
}
```

# Actor output Schema

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

One row per engine x prompt x run: brand mentioned, position, competitors, sources, sentiment, raw answer.

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

Self-contained visual report: visibility and share of voice per engine, ▲/▼ changes since the previous run, trend charts, top cited domains, per-prompt matrix.

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

Per-engine visibility %, share of voice vs competitors, top cited domains, per-prompt results, run details and the "tracking" section (changes since the previous run, competitor movement, history).

# 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 = {
    "brandName": "Notion",
    "brandAliases": [
        "Notion Labs"
    ],
    "brandDomain": "notion.com",
    "competitors": [
        "Evernote",
        "Obsidian",
        "Coda | Coda.io | coda.io",
        "ClickUp",
        "Confluence"
    ],
    "prompts": [
        "What is the best note-taking and knowledge management app for a small team?",
        "Which tools should a startup use to organize documents and project wikis?"
    ],
    "engines": [
        "openai",
        "perplexity",
        "gemini"
    ],
    "runsPerPrompt": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("tan_carrel_h1q/ai-search-brand-visibility-monitor").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 = {
    "brandName": "Notion",
    "brandAliases": ["Notion Labs"],
    "brandDomain": "notion.com",
    "competitors": [
        "Evernote",
        "Obsidian",
        "Coda | Coda.io | coda.io",
        "ClickUp",
        "Confluence",
    ],
    "prompts": [
        "What is the best note-taking and knowledge management app for a small team?",
        "Which tools should a startup use to organize documents and project wikis?",
    ],
    "engines": [
        "openai",
        "perplexity",
        "gemini",
    ],
    "runsPerPrompt": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("tan_carrel_h1q/ai-search-brand-visibility-monitor").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 '{
  "brandName": "Notion",
  "brandAliases": [
    "Notion Labs"
  ],
  "brandDomain": "notion.com",
  "competitors": [
    "Evernote",
    "Obsidian",
    "Coda | Coda.io | coda.io",
    "ClickUp",
    "Confluence"
  ],
  "prompts": [
    "What is the best note-taking and knowledge management app for a small team?",
    "Which tools should a startup use to organize documents and project wikis?"
  ],
  "engines": [
    "openai",
    "perplexity",
    "gemini"
  ],
  "runsPerPrompt": 1
}' |
apify call tan_carrel_h1q/ai-search-brand-visibility-monitor --silent --output-dataset

```

## MCP server setup

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

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/1lNU9yxpSRHSOv5ce/builds/pTbtbB9uAJmqKZmHk/openapi.json