# AI Search Visibility Tracker - ChatGPT, Perplexity & Gemini (`kadi_bence/ai-visibility-tracker`) Actor

Check if ChatGPT, Perplexity, Gemini and Claude mention and cite your brand. Input: prompts, brand name and domains, competitors; no API key needed for ChatGPT. Returns per answer: brand mentioned, position, cited URLs, competitors, answer text. Default: 1 answer per prompt.

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

## Pricing

from $35.00 / 1,000 ai answer checked (no key needed)s

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

Find out **whether AI assistants recommend your brand**. Give it the questions your buyers ask ("What is the best CRM for small agencies?"), your brand, your domain and your competitors. The Actor asks **OpenAI (the models behind ChatGPT), Perplexity, Google Gemini and Anthropic Claude** through their **official APIs, with your own API keys** (or, for OpenAI, with no key at all), and tells you for every answer:

- is your brand **mentioned**, and in **which position** among all brands named,
- is your **website cited** as a source (and at which rank),
- which **competitors** were mentioned or cited instead,
- **share of voice**, simple **sentiment**, cited domains and the search queries the AI ran.

Plus a **visibility SUMMARY**: visibility %, average position, citation rate and share of voice per brand and per AI, the most-cited domains, and the prompts where only competitors show up. **$10 per 1,000 checks with your own key, or $35 per 1,000 OpenAI checks without a key (AI costs included).**

### ✨ Why this tracker

- ✅ **Official APIs only, no ChatGPT scraping.** Automating the ChatGPT or Perplexity website breaks their terms of use and can stop working any day. This Actor only calls the documented APIs (OpenAI Responses API with web search, Perplexity Agent API, Gemini API, Claude Messages API with web search).
- 🔑 **Bring your own key, see your real costs.** You pay the AI provider directly at their list price (for example about $2 per 1,000 answers on Perplexity, $10-15 on OpenAI with web search). No hidden markup on AI usage, and your provider bill shows every call.
- 🚀 **Or start without any key.** Leave the OpenAI key empty and the Actor uses its own key: one price per check, AI costs included.
- 🧮 **Rankings, not just "yes/no".** Position of your first mention among all tracked brands, mention count, share of voice and citation rank, per answer and aggregated.
- 🔁 **Answers vary, so measure properly.** Ask each prompt 1-3 times and get a visibility % instead of a lucky single answer.
- 📈 **Monitoring mode.** Schedule it weekly: every row says whether your brand was gained or lost, moved up or down, or gained or lost a citation since the last run. "Only changes" mode writes only what changed.
- 💸 **You don't pay for failures.** Invalid keys, exhausted quota, rate limits, timeouts and refusals are listed with the reason and **are not charged**. A wrong key stops calls to that provider right away.

**Use cases:** Brand monitoring · Analyze SEO & marketing (track search rankings) · Research markets & competitors (track competitors) · Developer tools (AI and LLM integrations).

### 🎯 Use cases

- **Brands and marketing teams:** do ChatGPT, Perplexity, Claude and Gemini recommend you for your category's buying questions? Which competitors do they name first?
- **SEO / GEO / AEO teams (generative engine optimization):** track AI visibility like rankings, find the sources AI cites for your topics (outreach and PR targets), and measure whether content changes move the needle.
- **Agencies:** white-label AI visibility audits per client and market (use one **Monitoring ID** per client, country and language).
- **ChatGPT ads buyers:** ChatGPT ads launched in 2026 (US first, Europe from 31 August 2026). Check how ChatGPT's models talk about you organically before and while you buy ads, and compare with competitors who advertise.
- **Product and PR teams:** see how AI describes your product (answer text, sentiment) after launches or press coverage.

### 🚀 How to use it

1. **Get an API key** for at least one provider (each takes 2 minutes, all are pay-as-you-go), or skip this step and run OpenAI without a key (see below):
   - **OpenAI:** [platform.openai.com](https://platform.openai.com) > API keys (starts with `sk-`). Add a few dollars of credit under Billing.
   - **Perplexity:** [perplexity.ai](https://www.perplexity.ai) > API Platform > API keys (`pplx-`).
   - **Google Gemini:** [aistudio.google.com](https://aistudio.google.com) > Get API key (`AIza...`).
   - **Anthropic Claude:** [platform.claude.com](https://platform.claude.com) > API keys (`sk-ant-`).
2. Paste your **prompts** (one per line), your **brand name**, **domains** and **competitors** (`Name | domain.com | Alias`).
3. Tick the **AI assistants** and paste the matching **API keys**. Keys are secret inputs: Apify stores them encrypted, and the Actor never logs them or writes them to the output.
4. Click **Start**. Each check takes 5-60 seconds (web search included), with 5 running in parallel by default. Download the rows as CSV/Excel/JSON or open **SUMMARY** for the overview.
5. Optional: turn on **Compare with previous run** and add a **Schedule** (e.g. weekly) to monitor changes.

#### Try it without a key

Click **Start** on the prefilled example as it is: with no OpenAI key, OpenAI is asked with the Actor's own key. This works for **any input**, with these limits: OpenAI only (Perplexity, Gemini and Claude still need your own key and are skipped without one), model `gpt-6-luna`, at most **200 OpenAI checks per run**, **$0.035 per check** with the AI cost included. Rows made this way have `hosted: true`, and RUN_SUMMARY shows `hosted: true`. Add your own OpenAI key at any time to pay $0.01 per check instead.

### 🔧 Input

| Field | What it does | Default |
|---|---|---|
| `prompts` | Questions to ask, one per line (up to 1,000). Unbranded buyer questions show whether AI recommends you | 2 examples |
| `brandName` | Your brand as it appears in answers | `Apify` (example) |
| `brandAliases` | Other names that count as your brand (product names, old names) | - |
| `brandDomains` | Your domains. Citations of the domain **or any subdomain** count (`docs.apify.com` counts for `apify.com`, `notapify.com` does not) | - |
| `competitors` | `Name \| domain.com, other.com \| Alias 1, Alias 2` per line, or objects `{name, domains, aliases}` via API (up to 25) | 4 examples |
| `providers` | `openai`, `perplexity`, `gemini`, `anthropic` | `openai` |
| `openaiApiKey`, `perplexityApiKey`, `geminiApiKey`, `anthropicApiKey` | Your own keys (secret). Providers without a key are skipped, except OpenAI, which then runs with the Actor's key ($0.035 per check) | - |
| `openaiModel` | Any Responses API model, e.g. `gpt-6-luna`, `gpt-6.1-sol`, `gpt-6-astra` (without your own key: `gpt-6-luna` only) | `gpt-6-luna` |
| `perplexityModel` | Agent API preset (`fast`, `low`, `medium`, `high`) or `provider/model` | `fast` |
| `geminiModel` | e.g. `gemini-3.8-flash` | `gemini-3.8-flash` |
| `anthropicModel` | e.g. `claude-opus-5-5`, `claude-sonnet-5-5`, `claude-haiku-4-5` | `claude-opus-5-5` |
| `webSearch` | Let OpenAI and Claude search the web and cite sources (like ChatGPT search). Off = model knowledge only | `true` |
| `country` | 2-letter code sent to the web search as approximate user location (US, GB, DE...) | - |
| `language` | Adds "Answer in ..." (e.g. Deutsch) | - |
| `runsPerPrompt` | 1-3 answers per prompt and provider | `1` |
| `answerMaxChars` | Characters of answer text stored per row (0 = none). Analysis always uses the full answer | `4000` |
| `caseSensitive` | Only the capitalized brand counts (for names like Notion or Box) | `false` |
| `monitoring` / `onlyChanges` / `monitoringId` | Compare with the previous run of the same Monitoring ID; optionally output only changes | off |
| `maxConcurrency` | Parallel API calls (1-20) | `5` |
| `requestTimeoutSecs` | Timeout per API call (retried up to 3 times) | `120` |

```json
{
  "prompts": ["What are the best CRM tools for small agencies?", "HubSpot alternatives for startups"],
  "brandName": "Acme CRM",
  "brandAliases": ["Acme"],
  "brandDomains": ["acmecrm.com"],
  "competitors": ["HubSpot | hubspot.com", "Pipedrive | pipedrive.com", "Zoho CRM | zoho.com | Zoho"],
  "providers": ["openai", "perplexity", "anthropic"],
  "openaiApiKey": "sk-...",
  "perplexityApiKey": "pplx-...",
  "anthropicApiKey": "sk-ant-...",
  "runsPerPrompt": 2,
  "country": "US"
}
```

### 📦 Output

One row per **check** (prompt x AI provider x run). **Example** below (illustrative values from a test with a mocked OpenAI response, competitors and answer shortened):

```json
{
  "prompt": "What are the best web scraping tools?",
  "provider": "openai",
  "providerName": "OpenAI",
  "model": "gpt-6-luna",
  "run": 1,
  "brand": "Apify",
  "brandMentioned": true,
  "brandPosition": 2,
  "mentionCount": 2,
  "brandCited": true,
  "brandCitationRank": 2,
  "sentiment": "positive",
  "shareOfVoice": 0.4,
  "mentionedBrands": ["Bright Data", "Apify", "Octoparse"],
  "competitors": [
    { "name": "Bright Data", "mentioned": true, "mentionCount": 2, "position": 1, "cited": true, "citationRank": 1 },
    { "name": "Zyte", "mentioned": false, "mentionCount": 0, "position": null, "cited": false, "citationRank": null }
  ],
  "citedUrls": ["https://brightdata.com/products", "https://docs.apify.com/platform", "https://www.g2.com/categories/web-scraping"],
  "citedDomains": ["brightdata.com", "docs.apify.com", "g2.com"],
  "citationCount": 3,
  "searchQueries": ["best web scraping tools 2026", "web scraping platform comparison"],
  "webSearchUsed": true,
  "answer": "Here are the most popular web scraping tools in 2026:\n\n1. **Bright Data** - ... 2. **Apify** - a reliable, scalable platform ...",
  "answerLength": 503,
  "usage": { "inputTokens": 3120, "outputTokens": 412, "webSearches": 2 },
  "error": null,
  "checkedAt": "2026-10-05T11:10:50Z"
}
```

- `brandPosition`: 1 = your brand was the first tracked brand named in the answer.
- `shareOfVoice`: your mentions / mentions of all tracked brands in that answer (0-1).
- `sentiment`: `positive` / `neutral` / `negative` from a simple word list around your mentions (a hint, not a judgement), `null` when not mentioned.
- With monitoring on, each row also has `change`: `{"status": "changed", "details": ["position improved 3 -> 1"], "previous": {...}}`.
- Failed checks are listed with `error` and `errorType` (`auth`, `quota`, `rate_limit`, `timeout`, `refusal`...) and are free.

The **SUMMARY** record (key-value store) has per-brand `visibilityPct`, `avgPosition`, `firstPlacePct`, `citationRatePct`, `shareOfVoice`, a breakdown per AI provider, a `leaderboard`, `topCitedDomains` (with the owning brand when it is yours or a competitor's) and `promptsWhereOnlyCompetitorsAppear`. **RUN_SUMMARY** has counts, charged checks and errors per provider.

### 💵 Pricing: $10 per 1,000 checks with your own key, $35 without

A **check** = one prompt answered by one AI provider once (one row). Platform compute is included, plus Apify's tiny $0.00005 per-run start fee. Failed checks (invalid key, no quota, rate limit, timeout, refusal) are free.

| Mode | Price per successful check | AI provider cost |
|---|---|---|
| **Your own key** (any provider) | **$0.01** (event `check`) | Paid by you to the provider |
| **No OpenAI key** (OpenAI, `gpt-6-luna`, max 200 per run) | **$0.035** (event `hosted-check`) | Included |

Both modes can be mixed in one run: for example OpenAI without a key plus Perplexity with your own key.

**AI provider costs are separate and paid by you to the provider** with your own key. Rough list prices per 1,000 answers with the defaults (October 2026, check the providers' pricing pages): Perplexity `fast` preset about $1.5-3; OpenAI `gpt-6-luna` with web search about $10-15 ($10 per 1,000 web search calls + tokens); Gemini `gemini-3.8-flash` (no web search) about $2-4; Claude Opus 5.5 with web search about $50-100 ($10 per 1,000 searches, up to 5 searches per answer, + tokens; Sonnet 5.5 or Haiku 4.5 cost much less). Turning web search off makes OpenAI and Claude much cheaper.

Example: 50 prompts x 3 providers x 2 runs = 300 checks = **$3** on Apify per run. Cap spending with **Max charge per run**: the Actor checks the remaining budget before every API call and stops before making a call your limit can't pay for.

### ❓ FAQ

**Is this allowed? Do you scrape ChatGPT?**
No scraping. The Actor only calls the providers' official, documented APIs with your own key, which is exactly what those APIs are for. It never automates chatgpt.com, perplexity.ai or gemini.google.com. Your use of the answers is governed by your agreement with each provider (for example, OpenAI and Anthropic ask you to show citations when you display web-search answers to end users, and Perplexity asks you to credit it when you publish its output).

**Is the API answer the same as what ChatGPT shows?**
Close, not identical. The ChatGPT app adds its own system prompt, memory, personalization and model routing, which no official API exposes. API answers with web search are the closest compliant proxy, and they are consistent run to run, which is what matters for tracking trends.

**Why are there no citations for Gemini?**
Google's Gemini API terms do not allow storing, analysing or monitoring answers grounded with Google Search, or collecting their links. So Gemini is asked without Google Search grounding: it tells you what the model itself knows and recommends. OpenAI, Perplexity and Claude return citations.

**Why do results change between runs?**
AI answers are not deterministic and web results change. Use **Runs per prompt** = 2-3 and look at the visibility % in SUMMARY rather than a single answer.

**What about privacy and my keys?**
Keys are secret inputs (encrypted by Apify), sent only to the provider's own API endpoint in a request header, never logged, and never written to the dataset, SUMMARY or RUN_SUMMARY. Prompts go to the providers you select; OpenAI and Gemini requests are sent with storage turned off (`store: false`). On Google's free tier, Google may use prompts to improve its products. Use prompts without personal data.

**Which questions should I track?**
Unbranded buying questions ("best X for Y", "X alternatives", "X vs Y", "how to do Z") show whether AI recommends you. Branded questions ("Is Acme CRM good?") show how AI describes you.

**My brand name is a common word.**
Add precise aliases, turn on **Case-sensitive matching**, or use a distinctive form (e.g. "Notion app"). Matching is whole-word; spaces, hyphens and dots are interchangeable, and when two names overlap the longer one wins ("Google Cloud" is not counted as "Google").

**Something is wrong or missing?**
Open an issue on the **Issues** tab with the prompt, provider and model. Fixes usually land within 24-48 hours.

### 📝 Changelog

- **1.1 (2026-10-05):** OpenAI without your own key ($0.035 per check, AI cost included, max 200 per run). Rows and RUN_SUMMARY have `hosted`.
- **1.0 (2026-10-05):** First release. OpenAI Responses API (web search), Perplexity Agent API, Gemini Interactions API, Claude Messages API (web search). Mentions, position, citations, share of voice, sentiment, SUMMARY, monitoring mode, failed checks free.

This Actor is not affiliated with or endorsed by OpenAI, Perplexity, Google or Anthropic. ChatGPT, Perplexity, Gemini and Claude are trademarks of their owners.

### 🤝 Need a custom version?

I build custom scrapers, scheduled data feeds and integrations (CSV, Excel, Google Sheets, API, MCP for AI agents). Tell me the sites and fields you need:

- Email: bence.kadi@gmail.com
- Apify profile: https://apify.com/kadi_bence

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [SEO Site Audit](https://apify.com/kadi_bence/seo-site-audit) — 0-100 SEO score per page, broken links and fix hints
- [PageSpeed Insights Bulk Checker](https://apify.com/kadi_bence/pagespeed-checker) — Core Web Vitals and Lighthouse scores in bulk
- [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) — CMS, ecommerce, analytics and frameworks of any website
- [Document to Markdown](https://apify.com/kadi_bence/document-to-markdown) — PDF, Word, PowerPoint and Excel to clean Markdown, with OCR
- [Website Screenshot & PDF API](https://apify.com/kadi_bence/website-screenshot) — full-page screenshots and PDFs of any URL
- [Bulk WHOIS & RDAP Domain Lookup](https://apify.com/kadi_bence/domain-whois-lookup) — registrar, dates and DNS for many domains
- [Apple App Store Scraper](https://apify.com/kadi_bence/app-store-scraper) — top charts, app details, developers and reviews

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

# Actor input Schema

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

One question per line, phrased the way a customer would ask ChatGPT, Perplexity, Claude or Gemini, e.g. "What are the best CRM tools for small agencies?". Unbranded questions show whether AI recommends you. Up to 1,000 per run; duplicates are skipped.

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

Your brand, product or company as it would appear in an answer, e.g. HubSpot. Matching is whole-word and case-insensitive; spaces, hyphens and dots are interchangeable (Bright Data = BrightData = bright-data).

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

Other names that count as a mention of your brand: product names, old names, abbreviations (e.g. HubSpot CRM, Hub Spot).

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

Your website domains, e.g. apify.com. A citation of the domain or any subdomain (docs.apify.com) counts as "brandCited". notapify.com does not.

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

One competitor per line: Name | domain.com, other-domain.com | Alias 1, Alias 2. Domains and aliases are optional, e.g. "Bright Data | brightdata.com | Luminati". Via the API you can also pass objects {"name", "domains", "aliases"}. Up to 25.

## `providers` (type: `array`):

Each one is called through its official API with YOUR OWN API key (fields below). OpenAI also works without a key (AI cost included in the price). One check = one prompt x one provider x one run. Other providers without a key are skipped.

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

Optional. With your own key from platform.openai.com > API keys (starts with sk-): $0.01 per check and OpenAI bills you directly for tokens and web searches. Leave empty to use the Actor's own key: $0.035 per check with AI costs included, gpt-6-luna only, max 200 OpenAI checks per run. Stored encrypted by Apify, never logged or written to the output.

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

Any Responses API model with web search, e.g. gpt-6-luna (cheapest), gpt-6.1-sol, gpt-6-astra. Other models than gpt-6-luna need your own OpenAI key.

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

Your own key from perplexity.ai > API Platform > API keys (starts with pplx-). Stored encrypted, never logged.

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

An Agent API preset (fast, low, medium, high) or a provider/model id such as openai/gpt-5.6-luna. "fast" is the successor of the retired Sonar model.

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

Your own key from aistudio.google.com > Get API key (starts with AIza). Stored encrypted, never logged. Note: on Google's free tier, Google may use your prompts to improve its products.

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

e.g. gemini-3.8-flash. Gemini answers come from the model's own knowledge: Google's terms do not allow storing or analysing Google Search grounded results, so no citations are collected for Gemini.

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

Your own key from platform.claude.com > API keys (starts with sk-ant-). Stored encrypted, never logged.

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

e.g. claude-opus-5-5 (default, most capable), claude-sonnet-5-5 or claude-haiku-4-5 (cheaper).

## `webSearch` (type: `boolean`):

On: OpenAI and Claude search the web like ChatGPT search does and return cited sources. Off: answers from model knowledge only (cheaper, no citations). Perplexity presets always search; Gemini never does.

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

Optional 2-letter country code (US, GB, DE...) passed to the web search as the user's approximate location.

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

Optional, e.g. Deutsch or Italian. Adds a one-line "Answer in ..." instruction. Leave empty to let the assistant answer in the prompt's language.

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

AI answers vary from call to call. 2-3 runs per prompt give a more reliable visibility %. Each run is a separate check.

## `answerMaxChars` (type: `integer`):

Store at most this many characters of each answer in the dataset (0 = do not store answer text). Analysis always uses the full answer.

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

Turn on for brand names that are common words (e.g. "Notion", "Box") so only the capitalized form counts.

## `monitoring` (type: `boolean`):

Remember results in a named key-value store in your account and add a "change" field to every row (new / changed / unchanged: mention gained or lost, position up or down, citation gained or lost). Use with a Schedule.

## `onlyChanges` (type: `boolean`):

With monitoring: write only new and changed checks to the dataset. Unchanged checks are still counted (the AI call was made) and appear in SUMMARY.

## `monitoringId` (type: `string`):

Name for this tracked project, e.g. acme-us-crm. Use a different ID per client or market. Default: derived from the brand name.

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

How many API calls run at the same time. Lower it if your API key has low rate limits (429 errors are retried automatically).

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

Web-search answers can take 10-60 s. Timeouts are retried up to 3 times.

## Actor input object example

```json
{
  "prompts": [
    "What are the best web scraping tools in 2026?",
    "Which platform should I use to scrape Google Maps reviews at scale?"
  ],
  "brandName": "Apify",
  "brandDomains": [
    "apify.com"
  ],
  "competitors": [
    "Bright Data | brightdata.com | Luminati",
    "Octoparse | octoparse.com",
    "ScrapingBee | scrapingbee.com",
    "Zyte | zyte.com | Scrapinghub"
  ],
  "providers": [
    "openai"
  ],
  "openaiModel": "gpt-6-luna",
  "perplexityModel": "fast",
  "geminiModel": "gemini-3.8-flash",
  "anthropicModel": "claude-opus-5-5",
  "webSearch": true,
  "runsPerPrompt": 1,
  "answerMaxChars": 4000,
  "caseSensitive": false,
  "monitoring": false,
  "onlyChanges": false,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 120
}
```

# Actor output Schema

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

Brand mentioned, position, cited, sentiment and share of voice for every prompt x provider x run.

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

Cited URLs and domains per answer.

## `full` (type: `string`):

Every field incl. answer text, competitors and token usage.

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

Per-brand visibility %, average position, citation rate, share of voice, top cited domains, gaps.

## `runSummary` (type: `string`):

Counts, charged checks, errors per provider.

# 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 = {
    "prompts": [
        "What are the best web scraping tools in 2026?",
        "Which platform should I use to scrape Google Maps reviews at scale?"
    ],
    "brandName": "Apify",
    "brandDomains": [
        "apify.com"
    ],
    "competitors": [
        "Bright Data | brightdata.com | Luminati",
        "Octoparse | octoparse.com",
        "ScrapingBee | scrapingbee.com",
        "Zyte | zyte.com | Scrapinghub"
    ],
    "providers": [
        "openai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/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 = {
    "prompts": [
        "What are the best web scraping tools in 2026?",
        "Which platform should I use to scrape Google Maps reviews at scale?",
    ],
    "brandName": "Apify",
    "brandDomains": ["apify.com"],
    "competitors": [
        "Bright Data | brightdata.com | Luminati",
        "Octoparse | octoparse.com",
        "ScrapingBee | scrapingbee.com",
        "Zyte | zyte.com | Scrapinghub",
    ],
    "providers": ["openai"],
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/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 '{
  "prompts": [
    "What are the best web scraping tools in 2026?",
    "Which platform should I use to scrape Google Maps reviews at scale?"
  ],
  "brandName": "Apify",
  "brandDomains": [
    "apify.com"
  ],
  "competitors": [
    "Bright Data | brightdata.com | Luminati",
    "Octoparse | octoparse.com",
    "ScrapingBee | scrapingbee.com",
    "Zyte | zyte.com | Scrapinghub"
  ],
  "providers": [
    "openai"
  ]
}' |
apify call kadi_bence/ai-visibility-tracker --silent --output-dataset

```

## MCP server setup

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