# AI Visibility Report — ChatGPT, Perplexity, Claude (`farodata/ai-visibility-report`) Actor

Check if AI assistants recommend your brand when customers ask for advice. See who gets mentioned instead of you, with sources — and what changed since your last check.

- **URL**: https://apify.com/farodata/ai-visibility-report.md
- **Developed by:** [Andrea Moscariello](https://apify.com/farodata) (community)
- **Categories:** AI, SEO tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $80.00 / 1,000 visibility checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## AI Visibility Report — is your brand recommended by ChatGPT, Perplexity and Claude?

Your customers now ask AI assistants what to buy. **This Actor asks the AIs the same questions your customers ask — and tells you whether your brand shows up, who gets recommended instead of you, and why.**

- ✅ **See yourself as the AIs see you**: realistic buyer-intent questions, auto-generated for your industry and language, checked on ChatGPT (with web search), Perplexity and Claude (with web search).
- ✅ **Know who wins instead** — with the sources behind those answers, so you know *where* they come from. Every source comes with a link you can open.
- ✅ **Get a report you can forward as-is**: plain-language insights and three prioritized moves, not a wall of JSON. Run it weekly against your previous results and it tells you exactly what changed.

![Real results: every customer question checked on every AI model, with mentions, competitors and cited sources](https://api.apify.com/v2/key-value-stores/06HZt1FFXiST6Ncc2/records/results-table.png)

### What do you get?

| Field | What it tells you |
|---|---|
| `brandMentioned`, `brandPosition` | Whether (and how prominently) your brand appears in each AI answer |
| `entities` | Every brand the AI recommended, in order — your real competitive set |
| `sources` | The websites behind the answer — where AI answers in your industry come from |
| `sourceUrls` | The full addresses of those pages, so you can open them |
| `totals`, `perModel` | Mention rate and **share of voice**, overall and per AI model |
| `gaps` | The exact customer questions where you never appear |
| `report` | The interpretive report (Markdown): who wins, why, what changed, three moves |
| `delta` | What changed vs. your previous run: new mentions, lost mentions, new competitors |

### Sample output

```json
{
    "type": "check",
    "query": "best project management tool for a small design studio?",
    "model": "perplexity",
    "brandMentioned": false,
    "brandPosition": null,
    "entities": [
        { "name": "Asana", "position": 1, "isBrand": false, "isTrackedCompetitor": true },
        { "name": "Trello", "position": 2, "isBrand": false, "isTrackedCompetitor": false },
        { "name": "ClickUp", "position": 3, "isBrand": false, "isTrackedCompetitor": false }
    ],
    "sources": ["pcmag.com", "reddit.com", "zapier.com"],
    "sourceUrls": [
        "https://www.pcmag.com/picks/the-best-project-management-software",
        "https://www.reddit.com/r/design/comments/...",
        "https://zapier.com/blog/best-project-management-software/"
    ],
    "answerExcerpt": "For a small design studio, the most frequently recommended options are Asana for..."
}
```

And one `summary` item per run with the scores, the gaps, and the full Markdown report (also saved as `REPORT.md` in the key-value store). Here is a real report, generated in the brand's language:

![Sample interpretive report: the picture in one paragraph, who wins instead, and three prioritized moves](https://api.apify.com/v2/key-value-stores/06HZt1FFXiST6Ncc2/records/sample-report.png)

### How much does it cost?

Transparent pay-per-event pricing — you only pay for what runs:

| Event | Price |
|---|---|
| Visibility check (1 question × 1 AI model) | **$0.08** |
| Insight report (1 per run, optional) | **$0.29** |

**A typical run with defaults (10 questions × 3 models + report) costs $2.69.** A weekly check for a client costs ~$11/month. No API keys needed — everything is included.

### How to use it (3 steps)

1. Enter your **brand name** and **website**.
2. (Optional) add competitors to track, or your own questions — otherwise realistic questions are generated for your industry, in your language.
3. Run it. Read `REPORT.md`, or export the dataset to Excel/Sheets/API.

![The input form: brand, website, optional competitors and questions, AI models to check](https://api.apify.com/v2/key-value-stores/06HZt1FFXiST6Ncc2/records/input-form.png)

To track changes over time: in **Previous run results**, pick the dataset of any earlier execution for the same brand — the report will include a "what changed" section. For a clean comparison, reuse the same questions across runs. Use [Apify Schedules](https://docs.apify.com/schedules) to run it weekly.

### Input options

| Field | Required | Notes |
|---|---|---|
| `brand`, `brandUrl` | ✅ | Name + website of the brand to check |
| `competitors` | — | Competitor names to track; auto-detected if empty |
| `queries` | — | Your own questions; auto-generated if empty |
| `maxQueries` | — | 1-30, default 10 |
| `models` | — | Any of `chatgpt`, `perplexity`, `claude` (default: all three) |
| `language` | — | `auto` (detected from your site), or en/it/de/es/fr |
| `previousDataset` | — | Dataset of a previous run: enables the "what changed" comparison |
| `skipReport` | — | Raw checks only, no interpretive report |

### Use cases

- **Marketing & SEO agencies**: add an "AI visibility" section to client reports — a deliverable your competitors don't offer yet.
- **In-house marketing teams**: know whether ChatGPT recommends you or your competitor, and which sources to influence.
- **Founders**: check what the AIs tell your potential customers about your category — before your customers do.
- **GEO/AEO practitioners**: measure the effect of your optimizations over time with weekly runs and deltas.

### Is it legal?

Yes. This Actor talks to the **official APIs** of the AI providers (OpenAI, Perplexity, Anthropic) under their terms — no scraping, no automation of consumer accounts, no logins. Your brand's website is fetched once (a single normal page load) to detect your industry and language, and its `robots.txt` is respected.

**How the checks are run:** questions go to the providers' official APIs (for example the OpenAI API with web search enabled), which approximate — but can differ from — the consumer chat apps.

**Privacy & data flow:** your inputs and the AI answers pass through the developer's paid API accounts at OpenAI, Perplexity and Anthropic (paid tiers, where providers do not train on API data) and the results are stored only in **your** Apify dataset. The developer keeps no copy. Providers may briefly retain requests for abuse monitoring under their own terms; where the API allows it, storage is explicitly disabled on our side.

**AI-generated content:** the interpretive report is written by an AI model. Factual statements should be verified before you rely on them.

### Integrations & API

Works with everything Apify supports out of the box: REST API, scheduled runs, webhooks, and exports to JSON/CSV/Excel. Run it from code:

```js
const run = await client.actor('farodata/ai-visibility-report').call({
    brand: 'YourBrand',
    brandUrl: 'https://yourbrand.com',
});
```

Also available to AI agents via the Apify MCP server — an agent can run visibility checks as a tool.

### FAQ

#### How do I check if my brand is mentioned by ChatGPT?

Run this Actor with your brand name and website. It asks ChatGPT (with web search enabled) the questions your customers ask, and reports every mention with its position.

#### What is AI visibility / GEO (Generative Engine Optimization)?

AI visibility is whether AI assistants mention your brand when users ask for recommendations. GEO is the practice of improving it — the AI-era equivalent of SEO. This Actor is the measuring instrument.

#### Which AI models are checked?

ChatGPT (with web search), Perplexity, and Claude (with web search) — three assistants people actually use for buying advice. Each can be toggled in the input. Every check runs through the providers' official APIs, on terms that allow us to analyse and deliver the results to you.

#### Do I need my own OpenAI or Perplexity API key?

No. All API costs are included in the per-check price.

#### How are the customer questions generated?

From your website: the Actor detects your industry and language, then generates realistic buyer-intent questions (never mentioning your brand, to keep the test honest). You can always supply your own instead.

#### Can I track my competitors?

Yes — list them in `competitors`, or let the Actor auto-detect who the AIs recommend in your space. The `topCompetitors` ranking shows who dominates the AI answers.

#### How do I see what changed since last week?

Select the dataset of an earlier run in **Previous run results** (`previousDataset`). The summary gains a `delta` section and the report a "what changed" chapter: questions where you appeared or disappeared, and new competitors.

#### Why does my brand appear on one AI model but not another?

Each model draws on different sources (check the `sources` field). The report tells you which sites each AI trusts in your industry — that's where visibility is won.

#### How often should I run it?

Weekly is the sweet spot: AI answers shift when the underlying sources change.

**One thing to know if you schedule it.** A Schedule always starts the run with the same saved input, so it would keep comparing every new run against the *same* old dataset — after a month, "what changed" would be measuring the whole month, not the week. And once that dataset expires (datasets are kept for a limited time on most plans), the comparison chapter disappears.

Until the Actor tracks this for you, the reliable habit is: **run it, then update `previousDataset` to the run you just finished.** That way each week is compared with the week before. It takes a few seconds, and it is the difference between a trend and a series of unrelated snapshots.

#### Is the report in my language?

Yes — the report and the generated questions follow your website's language (or the one you select): English, Italian, German, Spanish or French.

### Support & feedback

Found an issue or want a feature (more models, more markets)? Open an issue on the Actor's **Issues** tab — issues are typically answered within hours. Your feedback shapes the roadmap.

***

*This Actor is an independent, **unofficial** tool and is **not affiliated with, endorsed or sponsored by OpenAI, Perplexity or Anthropic**. ChatGPT, Perplexity and Claude are trademarks of their respective owners, used here only to identify the services being measured.*

# Actor input Schema

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

The brand or company name to check, exactly as customers would know it (e.g. "Acme Software").

## `brandUrl` (type: `string`):

The brand's website. Used to detect the industry, the language, and to generate realistic customer questions.

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

Competitor brand names to track. Leave empty to let the tool auto-detect who the AIs recommend instead of you.

## `queries` (type: `array`):

Questions a potential customer would ask an AI assistant. Leave empty to auto-generate realistic buyer-intent questions from the brand's website. Leave empty and we generate them from your website — or reuse the previous run's questions, if you selected one.

## `maxQueries` (type: `integer`):

How many questions to check. This is the cost dial: each question is checked on every selected AI model, and every successful check is charged. 10 questions x 3 models = 30 checks ($2.69 with the report); 30 x 3 = 90 checks ($7.49). It is also the cap on questions you paste yourself: anything above it is not checked.

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

Which AI assistants to ask. Each question is checked on EVERY selected model, so the number of models multiplies the cost (10 questions × 3 models = 30 checks).

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

Language for the generated questions and the report. "auto" detects it from the brand website.

## `previousDataset` (type: `string`):

Select the dataset (results) of a previous execution for the same brand. When provided, the report includes what changed since then (new mentions, lost mentions, competitor movements). Tip: use the same questions across runs for a clean comparison. When you select one, the SAME questions are reused automatically so the two runs are comparable — paste your own in "Custom questions" to override that.

## `skipReport` (type: `boolean`):

Only run the raw visibility checks, without the interpretive report — saves the $0.29 report fee.

## Actor input object example

```json
{
  "brand": "Notion",
  "brandUrl": "https://www.notion.com",
  "competitors": [],
  "queries": [],
  "maxQueries": 10,
  "models": [
    "chatgpt",
    "perplexity",
    "claude"
  ],
  "language": "auto",
  "skipReport": false
}
```

# Actor output Schema

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

One item per customer question per AI model, plus one summary item with totals, gaps, competitors and the delta.

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

The interpretive Markdown report: who wins instead of you, why, what changed, three prioritized moves.

# 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": "Notion",
    "brandUrl": "https://www.notion.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("farodata/ai-visibility-report").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": "Notion",
    "brandUrl": "https://www.notion.com",
}

# Run the Actor and wait for it to finish
run = client.actor("farodata/ai-visibility-report").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": "Notion",
  "brandUrl": "https://www.notion.com"
}' |
apify call farodata/ai-visibility-report --silent --output-dataset

```

## MCP server setup

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

```

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/5nC2yrjxiEzIg86eY/builds/TgfpsZwMI0uUwya5r/openapi.json