# AI Brand Visibility Tracker: LLM Mentions & Share of Voice (`humble-echidna/ai-visibility`) Actor

Track your AI search visibility (GEO/AEO): do AI models name your brand when buyers ask? Mention rate, rank, competitors and share of voice per model, with change since the last run. Asks the API models behind ChatGPT, Claude, Gemini and Perplexity (not the apps); $15 per 1,000 checks plus tokens.

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

## Pricing

from $10.50 / 1,000 answer checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What does AI Brand Visibility Tracker do?

**AI Brand Visibility Tracker** asks AI models the questions your buyers ask ("what are the best project management
tools for a small team?") and checks each answer for **your brand**: whether it's named, **where it ranks**, which
**competitors** are named instead and which links are cited. A free summary row gives the **mention rate per model**,
**share of voice** against your competitors and the **change since your last run**. It's a way to track your **AI
search visibility** (what marketers call GEO or AEO: generative or answer engine optimization).

It asks the models **through their APIs** (OpenAI, Anthropic, Google, Perplexity and others via OpenRouter). These
are **not** the answers the ChatGPT or Gemini apps show a signed-in user ([why](#are-these-the-answers-chatgpt-gemini-or-perplexity-users-see)).

[Input fields](https://apify.com/humble-echidna/ai-visibility/input-schema) ·
[API](https://apify.com/humble-echidna/ai-visibility/api) ·
[Use it from Claude, ChatGPT or Cursor (MCP)](#can-i-use-ai-brand-visibility-tracker-from-an-ai-agent-mcp)

**Jump to:** [Fields](#what-data-does-ai-brand-visibility-tracker-return) ·
[Price](#how-much-does-it-cost-to-track-brand-visibility-in-ai-answers) ·
[How to use](#how-to-track-your-brands-visibility-in-ai-answers) ·
[Track weekly](#track-it-weekly-changes-since-the-last-run-in-slack-email-or-a-webhook) ·
[Input](#input) · [Output](#output) ·
[AI agents (MCP)](#can-i-use-ai-brand-visibility-tracker-from-an-ai-agent-mcp) · [Limits](#limits) · [FAQ](#faq)

**Try it in one click:** the input comes pre-filled with Trello against Asana and Monday.com, one question and one
model. That's 1 check: $0.015, plus the $0.00005 start fee, plus about $0.001 of model tokens on a paid Apify plan.
**Then put in your own brand, competitors and buyer questions.**

### What data does AI Brand Visibility Tracker return?

One row per check (one question asked once of one model), including checks that failed (with the reason, never
charged), and one summary row per run (free).

| Field | Example | Notes |
|---|---|---|
| `brandMentioned` | `true` | Whether the answer names your brand (any of the names you gave). |
| `brandRank` | `2` | Its position among **every** brand the answer names, in the answer's order. `null` when not named. |
| `competitorsMentioned` | `["Asana", "Monday.com"]` | Your competitors the answer names. |
| `competitorRanks` | `{"Asana": 1, "Monday.com": 3}` | Their positions, on the same scale as `brandRank`. |
| `brandsNamed` | `["Asana", "Trello", "Monday.com", "ClickUp"]` | Every brand the answer names, tracked or not: the competitors you didn't know about. |
| `citedUrls`, `brandCited` | `["https://trello.com/guide"]`, `true` | Links the answer cites or writes out; `true` when one is on your domain. |
| `answer` | `"For a small team, these stand out: ..."` | The full answer, up to about 1,000 tokens. |
| `prompt`, `model`, `sample` | `"What are the best ..."`, `"openai/gpt-4.1-mini"`, `1` | Which question, which model, which ask. |
| `changed` | `false` | Whether the mention, rank or competitors differ from the same check last run; `null` the first time. |
| `valid`, `errors` | `true`, `[]` | Only valid checks are charged and counted in the summary. |
| `mentionRate` (summary) | `0.67` | Share of valid checks that name your brand, overall and per model. |
| `shareOfVoice` (summary) | `[{"brand": "Trello", "shareOfVoice": 0.33, ...}]` | Each tracked brand's share of all tracked-brand mentions, with mention rate and average rank. |
| `changes` (summary) | `{"mentionRate": {"now": 0.67, "before": 0.5, "change": 0.17}, ...}` | Against your last run with the same brand and questions. |

The full list is under [Output](#output).

### How much does it cost to track brand visibility in AI answers?

Two parts, both on your Apify account:

1. **This actor: $15.00 per 1,000 checks** ($0.015 a check), plus $0.00005 each time a run starts. A check is one
   question asked once of one model, and only checks whose answer came back and was read are charged.
2. **The models' tokens**, billed by Apify's own [OpenRouter actor](https://apify.com/apify/openrouter), which this
   actor calls with your run's token. On paid Apify plans that's OpenRouter's list price; on the Free plan the
   OpenRouter actor charges 10 times as much (its pricing, not ours). Each check is two calls: the answer (capped at
   1,000 tokens) and a short call on `openai/gpt-4.1-mini` that lists the brands it names. With the default model
   that's about **$1 per 1,000 checks** on a paid plan; bigger models cost more.

- **The example below:** 1 check × $0.015, plus the start fee and about $0.001 of tokens.
- **A month, for example:** an agency tracking 4 clients weekly, each with 10 questions × 3 models × 3 samples =
  90 checks a week: 4 × 90 × 4.3 weeks ≈ 1,550 checks ≈ **$23**, plus roughly $2-10 of tokens depending on the models.
- **Caps:** **Max checks per run** in the input, and **Maximum cost per run** in the run options (it covers this
  actor's charges; the token charges are the OpenRouter actor's, so cap those with the number of questions, models
  and samples). The run stops cleanly at whichever comes first: each check is counted against the limit before it's
  asked, and the count is given back if it fails.

**Never charged by this actor:** checks whose model call failed, empty answers, answers whose brand list couldn't
be read, and the summary row. (A call that reached the model still used its tokens.)

### How to track your brand's visibility in AI answers

1. Open AI Brand Visibility Tracker and click **Try for free** (or **Start** if you're signed in).
2. Put your brand in **Your brand** (add other names after a `|`, e.g. `Trello | trello.com`) and your rivals in
   **Competitors**, one per line.
3. Write the questions your buyers ask in **Questions to ask**, **without your brand in them**: "best CRM for a
   10-person agency", not "is HubSpot good?".
4. Pick the **Models** and **Samples per question** (3 gives a steadier rate than 1), then click **Start**.
5. Open the **Output** tab: the summary row has the rates; the check rows have each answer. Export as JSON, CSV or
   Excel.

### Track it weekly: changes since the last run, in Slack, email or a webhook

Every run remembers its figures for the same brand and questions, and the next run's summary row says what changed:
mention rate overall and per model, share of voice per brand, and which brands the answers started or stopped
naming. Adding a competitor or a model keeps the history; changing a question starts a new one.

1. Fill in your brand, competitors and questions and click **Start**. This first run is the baseline.
2. Click **Save as a new task** (top right of the actor page).
3. In Apify Console, open **Schedules**, click **Create new**, set how often (for example weekly, Monday 07:00), then
   **Add** your task.
4. On the task, open the **Integrations** tab and pick where the results go:
   - **Slack**: click **Configure**, sign in, pick the channel and the "run succeeded" event. A useful message:
     `{{resource.statusMessage}}` (for example "Trello named in 8 of 12 checks (67%)") and a link,
     `<https://console.apify.com/storage/datasets/{{resource.defaultDatasetId}}|results>`.
   - **Gmail**: click **Connect with Google**, set the subject and body, and attach the dataset.
   - **HTTP webhook**: event `ACTOR.RUN.SUCCEEDED`, your URL; fetch
     `GET https://api.apify.com/v2/datasets/<defaultDatasetId>/items?format=json` (with your API token).

Turn on **Only checks that changed since the last run** (`onlyChanges`) to leave unchanged checks out of the
dataset. The summary row still covers them, and they're still charged: the question was still asked.

### Example: Trello vs Asana and Monday.com

The pre-filled input:

```json
{
  "brand": "Trello",
  "competitors": ["Asana", "Monday.com"],
  "prompts": ["What are the best project management tools for a small team?"],
  "models": ["openai/gpt-4.1-mini"],
  "samples": 1
}
```

It ran in 19 seconds on Apify (2026-10-02) and used 741 input and 485 output tokens across both calls. The check
row, answer shortened:

```json
{
  "rowType": "check",
  "brand": "Trello",
  "prompt": "What are the best project management tools for a small team?",
  "model": "openai/gpt-4.1-mini",
  "sample": 1,
  "webSearch": false,
  "answer": "For a small team, the best project management tools are those that combine ease of use, essential features, and affordability. Here are some of the top options:\n\n1. **Trello**\n   - Visual, card-based organization ... \n\n2. **Asana** ...",
  "answerTruncated": false,
  "brandMentioned": true,
  "brandRank": 1,
  "brandCited": false,
  "competitorsMentioned": ["Asana", "Monday.com"],
  "competitorRanks": {"Asana": 2, "Monday.com": 4},
  "brandsNamed": ["Trello", "Asana", "ClickUp", "Monday.com", "Basecamp", "Notion"],
  "citedUrls": [],
  "valid": true,
  "errors": [],
  "changed": null,
  "inputTokens": 741,
  "outputTokens": 485,
  "checkedAt": "2026-10-02T14:19:06.335185Z"
}
```

And the summary row (the first run, so `changes` is `null`; `topBrandsNamed` shortened):

```json
{
  "rowType": "summary",
  "brand": "Trello",
  "competitors": ["Asana", "Monday.com"],
  "prompts": ["What are the best project management tools for a small team?"],
  "samples": 1,
  "webSearch": false,
  "checksFailed": 0,
  "checks": 1,
  "mentions": 1,
  "mentionRate": 1,
  "models": [{"model": "openai/gpt-4.1-mini", "checks": 1, "mentions": 1, "mentionRate": 1,
              "sampleMentionRates": [1], "spread": 0, "averageRank": 1}],
  "shareOfVoice": [
    {"brand": "Trello", "tracked": "brand", "mentions": 1, "mentionRate": 1, "shareOfVoice": 0.333, "averageRank": 1},
    {"brand": "Asana", "tracked": "competitor", "mentions": 1, "mentionRate": 1, "shareOfVoice": 0.333, "averageRank": 2},
    {"brand": "Monday.com", "tracked": "competitor", "mentions": 1, "mentionRate": 1, "shareOfVoice": 0.333, "averageRank": 4}
  ],
  "topBrandsNamed": [{"brand": "Trello", "checks": 1, "rate": 1}, {"brand": "Asana", "checks": 1, "rate": 1}, "..."],
  "changes": null,
  "checkedAt": "2026-10-02T14:19:06.198691Z"
}
```

Run the same input again and the summary's `changes` compares with this run: mention rate, per model, share of
voice, and the brands newly named or no longer named; each check row says whether it `changed`.

### Input

| Field | What it does |
|---|---|
| **Your brand** (`brand`) | The company, product or website to track. Other names after `\|`; a domain marks links to it. |
| Competitors (`competitors`) | Up to 20 rivals, one per line, same format. |
| **Questions to ask** (`prompts`) | Up to 100 buyer questions, written without your brand. |
| Models (`models`) | Up to 5 OpenRouter model ids. Default `openai/gpt-4.1-mini`. |
| Samples per question (`samples`) | 1-5 asks of each question per model. Default 1. |
| Only checks that changed (`onlyChanges`) | Leave unchanged checks out of the dataset. Default off. |
| Max checks per run (`maxChecks`) | Stop after this many valid checks. |

```json
{
  "brand": "Trello | trello.com",
  "competitors": ["Asana", "Monday.com | monday", "ClickUp"],
  "prompts": ["What are the best project management tools for a small team?",
              "Which kanban app is easiest for non-technical people?"],
  "models": ["openai/gpt-4.1-mini", "anthropic/claude-haiku-4.5", "google/gemini-2.5-flash-lite"],
  "samples": 3,
  "maxChecks": 100
}
```

### Output

Check rows (`rowType: "check"`) have the fields in the table above, plus `webSearch`, `answerTruncated` (the answer
reached the 1,000-token cap), `inputTokens` and `outputTokens` (both calls) and `checkedAt`. The summary row
(`rowType: "summary"`) has `brand`, `competitors`, `prompts`, `samples`, `checks`, `checksFailed`, `mentions`,
`mentionRate`, and:

- `models`: per model, `checks`, `mentions`, `mentionRate`, `sampleMentionRates` (the rate in each sample round) and
  `spread` (highest minus lowest round: how much the answers wobble), `averageRank`.
- `shareOfVoice`: per tracked brand, `mentions`, `mentionRate`, `shareOfVoice`, `averageRank`.
- `topBrandsNamed`: the 20 brands the answers name most, tracked or not, with how many checks named each.
- `changes`: against the last run, `null` on the first.

The run's `RUN_STATS` record counts valid, failed and unchanged checks, tokens, and the first error.

### Run it on a schedule, or from your own code

1. Save your input as a [task](https://docs.apify.com/platform/actors/running/tasks) (**Save as a new task**, top right
   of the actor page) and add it to a [schedule](https://docs.apify.com/platform/schedules) (Console → Schedules →
   **Create new**).
2. Collect results: download the dataset as JSON, CSV or Excel; fetch the latest run's results from the
   [API](https://apify.com/humble-echidna/ai-visibility/api)
   (`GET https://api.apify.com/v2/actor-tasks/<task id>/runs/last/dataset/items?status=SUCCEEDED&format=csv`, with
   your API token); let a [webhook](https://docs.apify.com/platform/integrations/webhooks) tell your system when a
   run succeeds; or connect it to Make, Zapier or n8n through
   [Apify's integrations](https://docs.apify.com/platform/integrations).

#### Can I use AI Brand Visibility Tracker from an AI agent (MCP)?

Yes, through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp), from Claude, ChatGPT, Cursor or
any other MCP client. Add this to your client's MCP configuration; your client signs you in to Apify:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=humble-echidna/ai-visibility"
    }
  }
}
```

To use an [Apify API token](https://console.apify.com/settings/integrations) instead of signing in, add
`"headers": {"Authorization": "Bearer <APIFY_TOKEN>"}` next to `url`.

The agent passes `{"brand": "Trello", "competitors": ["Asana"], "prompts": ["best kanban app for a small team?"]}`
and reads the summary row (`rowType: "summary"`) for the rates.

### Who it's for

SEO and marketing agencies, and in-house marketers, who check every week or month whether AI models recommend their
client's brand for the questions buyers ask, which competitors they name instead, and whether that's moving.

### Why this one?

- **Ranks against every brand named, not just yours.** `brandRank` counts the brands you didn't list, and
  `brandsNamed` / `topBrandsNamed` show who they are.
- **Sampling with its spread.** Ask each question up to 5 times per model; the summary shows the rate in each round
  and how far they differ, so one lucky answer doesn't read as a trend.
- **History built in.** Each run compares itself with the last run of the same brand and questions, in your own
  account. No spreadsheet to keep.
- **Honest matching.** Names match as whole words, only the names you give ("Monday.com" doesn't match the weekday),
  and the brand list comes from a separate, validated structured-output call.
- **You pay for what worked.** Failed calls, empty answers and unreadable ones are rows with the reason, not charges.

### Limits

- **API answers, not the consumer apps.** No ChatGPT, Gemini or Perplexity app pages, no Google AI Overviews and no
  scraping of any app. The apps add their own search, location, memory and personalisation, so their answers can
  differ from these.
- **No web search option in this version**: answers come from what each model learned in training. Apify's
  OpenRouter actor didn't pass OpenRouter's web search through when tested (2026-10-02). `perplexity/sonar` searches
  the web itself, so its answers reflect current pages and cite them in `citedUrls` (21 links on the example
  question).
- **Answers are capped at about 1,000 tokens.** A model that "thinks" first (reasoning models) can spend that on
  thinking and return an empty answer, which isn't charged; pick a non-reasoning model.
- **Brands, not people.** Don't use it to track private individuals.
- Up to 100 questions, 5 models, 5 samples and 20 competitors per run.

### FAQ

#### Are these the answers ChatGPT, Gemini or Perplexity users see?

No. They're the answers the same companies' models give through their APIs, to the question exactly as you wrote
it, with no system prompt, no user history and no location. The apps add their own instructions, web search,
memory and personalisation. API answers are a consistent, repeatable measure of what a model says about your
category; they aren't a screenshot of any one user's chat.

#### Why ask the same question several times?

Models don't answer the same way twice. One ask can name your brand and the next can't. With 3 samples, the
`mentionRate` is the share of all asks, and `sampleMentionRates` / `spread` show how much it varies between rounds.

#### How is the rank worked out?

A second, small call on `openai/gpt-4.1-mini` lists every brand the answer names, in the answer's order (its
numbered list, else the order they first appear). Your brand's rank is its position in that list. That list is
checked against a JSON Schema; if it doesn't validate, the check isn't charged. Whether your brand is named at all is
also matched directly in the answer text, so the two never contradict each other.

#### Who pays for the model?

You do, on your own Apify account, through Apify's [OpenRouter actor](https://apify.com/apify/openrouter): this actor
calls it with your run's token. No API key is needed, and we never see one.

#### Is it legal to track brand mentions in AI answers?

This actor scrapes nothing: it sends your questions to AI models through Apify's official OpenRouter actor, the
providers' APIs, and reads the answers. Track companies, products and websites; don't use it for people. You're
responsible for the questions you send and for following each model provider's usage policies.

#### Can I get only what changed since my last run?

Yes: the summary row's `changes` compares every run with the last one for the same brand and questions, and
**Only checks that changed** leaves unchanged check rows out ([how to schedule it](#track-it-weekly-changes-since-the-last-run-in-slack-email-or-a-webhook)).

### Related actors

| Actor | Use it when |
|---|---|
| [SEO Audit Crawler](https://apify.com/humble-echidna/seo-audit) | You also want the classic on-page SEO checks for the same client sites. |
| [AI Data Extractor](https://apify.com/humble-echidna/ai-extract) | You want structured data from the pages the answers cite. |

### Feedback and support

Found a bug, or need a field or model option that isn't here? Open an issue on the **Issues** tab with the input you
used.

### Versions

Current version: **0.1**. See the Changelog tab for what changed in each version.

# Changelog

This Actor's version history is a separate document: https://apify.com/humble-echidna/ai-visibility/changelog.md

# Actor input Schema

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

The company, product or website to track, e.g. `Trello`. Brands, not people: don't track private individuals. Add other names after a | to count them too, e.g. `Monday.com | monday`; each is matched as a whole word, case-insensitive. A domain among them (trello.com) also marks links to that site as brandCited.

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

Competing brands to count in the same answers, one per line, e.g. `Asana`, `Monday.com | monday`. Up to 20. They get their own mention rate, rank and share of voice in the summary row. Every other brand the answers name is listed too (brandsNamed), tracked or not.

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

The questions your buyers ask an AI assistant, one per line, written without your brand, e.g. `What are the best project management tools for a small team?`. Up to 100, each at most 2,000 characters. Each is sent as is to every model, samples times.

## `models` (type: `array`):

The AI models to ask, as OpenRouter model ids, one per line; up to 5. Default `openai/gpt-4.1-mini`. Others, e.g. `anthropic/claude-haiku-4.5`, `google/gemini-2.5-flash-lite`, or `perplexity/sonar` (searches the web itself and cites sources). These are API answers, not the ChatGPT or Gemini apps. Tokens are billed to your Apify account by Apify's OpenRouter actor.

## `samples` (type: `integer`):

How many times to ask each model each question, from 1 to 5. Default 1. Answers vary between asks, so 3 or more gives a steadier mention rate; the summary row shows each sample round's rate and the spread between them. Each sample is one check.

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

Default false. When true, a check (same question, model and sample) is left out of the dataset when your brand's mention, its rank and the competitors named are all the same as in the last run with this brand and these questions. The summary row always covers every check, and every valid check is charged.

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

Stop after this many valid checks (one question asked once of one model), e.g. 20. From 1 to 2500; leave empty (the default) for questions x models x samples. Checks that fail don't count. The run also stops cleanly at the maximum cost per run you set in the run options, whichever comes first.

## Actor input object example

```json
{
  "brand": "Trello",
  "competitors": [
    "Asana",
    "Monday.com"
  ],
  "prompts": [
    "What are the best project management tools for a small team?"
  ],
  "models": [
    "openai/gpt-4.1-mini"
  ],
  "samples": 1,
  "onlyChanges": false
}
```

# Actor output Schema

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

No description

## `runStats` (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": "Trello",
    "competitors": [
        "Asana",
        "Monday.com"
    ],
    "prompts": [
        "What are the best project management tools for a small team?"
    ],
    "models": [
        "openai/gpt-4.1-mini"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("humble-echidna/ai-visibility").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "brand": "Trello",
    "competitors": [
        "Asana",
        "Monday.com",
    ],
    "prompts": ["What are the best project management tools for a small team?"],
    "models": ["openai/gpt-4.1-mini"],
}

# Run the Actor and wait for it to finish
run = client.actor("humble-echidna/ai-visibility").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "brand": "Trello",
  "competitors": [
    "Asana",
    "Monday.com"
  ],
  "prompts": [
    "What are the best project management tools for a small team?"
  ],
  "models": [
    "openai/gpt-4.1-mini"
  ]
}' |
apify call humble-echidna/ai-visibility --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RlFpCo91wiGPVWpYu/builds/zxDcNAqEOHT4sKQEb/openapi.json
