# AI Visibility Audit: ChatGPT, Perplexity & Google Brand Report (`zaiq/ai-visibility-audit`) Actor

Audit a brand against competitors across AI answers. Generate buyer questions from a website, measure visibility, inspect cited pages and deliver an HTML report with gaps, recommendations and optional run comparisons. $4 per audit plus gateway AI usage.

- **URL**: https://apify.com/zaiq/ai-visibility-audit.md
- **Developed by:** [Zaiq](https://apify.com/zaiq) (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 $3,200.00 / 1,000 brand audits

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

## AI Visibility Audit: ChatGPT, Perplexity & Google Brand Report

Produce a brand visibility report from up to **20 buyer questions on 3 engines**. Compare your brand with competitors, inspect the sources AI engines cite, and get a transparent visibility score, competitor gaps and a prioritised content review list.

Supply questions yourself, or provide a public website and category to generate questions in one low-cost model call. The engine answers and any question-generation call use Apify’s gateway and are billed to the buyer separately from the audit event.

### What you get

| Field | What it holds |
|---|---|
| Audit row | Delivery status, visibilityScore, usableAnswers, requestedAnswers, resolvedAnswers and reportRecord. |
| Answer rows | Original answer text, engine, model, source URLs, matched brands and returned AI usage. Failure rows are free. |
| REPORT.html | One standalone page with headline metrics, engine and brand tables, competitor gaps, recommendations, questions and answer excerpts. |
| REPORT / SUMMARY | JSON evidence, score components and formula, coverage, question-generation provenance, traffic, notes and charges. |
| CHANGES | With projectName: mention gains/losses, rate moves, cited sites gained/lost and tracked competitors appearing, per question and engine. |
| Named project store | Immutable RUN records plus LATEST; the exact name and run record are in REPORT.monitoring. |

### What people use it for

- **Agency reports:** Share a single HTML file explaining where a brand is visible and what the sample supports.
- **Competitive audits:** Find buyer questions where specified competitors are mentioned or cited without the brand.
- **Content reviews:** Inspect cited page titles and headings alongside topic-specific recommendations.
- **Repeat measurements:** Use a project name and consistent questions to record comparable changes.

### How to use it

1. Enter your brand, website and category, plus competitors as names and domains.
2. Supply up to 20 questions or leave questions empty to generate them from the website and category. Select up to three engines.
3. Set the event budget to at least $4.00, allow for gateway AI usage separately, and start.
4. Open REPORT.html. Check coverage, questions, score formula and evidence before sharing the report.

### Input

| Field | Example | Notes |
|---|---|---|
| brand | `Example Workspace` | Required. |
| website | `https://example.com` | Required for generated questions; optional for supplied questions. Also identifies the subject’s citation domain. |
| category | `Project management software for small teams` | Required with a website when generating questions. |
| competitors | `Example Planner \| planner.example` | Up to 10. Unlisted brands are not guessed. |
| questions | Buyer questions, one per line | Optional; up to 20 distinct questions. Supplied questions skip generation. |
| questionCount | `20` | Number generated when questions are absent; 1–20. |
| engines | `openai`, `perplexity`, `google-ai-overview` | Select 1–3 of the six supported engines. |
| country / language | `US` / `en` | Location where supported; Google result language and question-generation context. |
| projectName | `Example project` | Optional history and comparisons. |
| maxCitedPages | `8` | 0–12 direct public page reads for evidence. |

### Output

Each result is one row in the run's dataset (download it as JSON, CSV, Excel, XML or HTML, or read it through the API). An example row (values shortened):

```json
{
  "kind": "audit",
  "status": "delivered",
  "brand": "Example Workspace",
  "visibilityScore": 82.0,
  "usableAnswers": 5,
  "requestedAnswers": 6,
  "resolvedAnswers": 6,
  "engines": [
    "openai",
    "perplexity",
    "google-ai-overview"
  ],
  "reportRecord": "REPORT.html",
  "note": "Report saved. AI usage is billed separately by the gateway.",
  "charged": true
}
```

This example is the saved audit row from a free offline replay on 17 October 2026 of recorded engine answers from 12 October: 5 usable answers from 6 requests, one without a readable Google overview. Brand names and site addresses have been replaced. The 82.0 score is calculated from that sample; it is not a new live measurement. Page-reading fixtures were used for offline report tests. SUMMARY records the questions, exact score components, coverage and charges.

### Pricing

- **$4.00 per delivered audit**, for up to 20 questions on up to three engines. There are no per-answer events.
- The audit event is charged only after saving the report, with at least one usable answer and at least 80% of requests resolved as an answer or a reported unreadable Google overview. Smaller successful audits use the same price.
- Below that threshold, the diagnostic report and answer rows have no audit event. Failed or absent answers never lower the score by being treated as zero visibility.
- All model usage is separate, billed to the buyer through Apify’s gateway. Question generation uses one newest-Gemini-Flash call without a search plugin. Engine calls use their configured web search.
- No residential proxy is used for cited-page evidence. Google Overview uses the platform’s SERP route; its cost is included in the audit event.
- Measured 17 October 2026: a 3-question audit on Perplexity delivered 3 of 3 answers and its report; the AI usage was about $0.08 on the buyer's account.

What typical jobs cost at the list price:

| Job | Cost |
|---|---|
| 20 questions × 3 engines, supplied questions | $4.00 plus up to 60 engine calls billed by the gateway where applicable |
| 20 generated questions × 3 engines | $4.00 plus one generation call and engine usage |
| 2 supplied questions × 3 engines | $4.00 plus engine usage |
| No usable answers or under 80% resolved requests | $0 audit events; gateway calls may still cost money |

The run’s maximum cost limits Actor event charges. Gateway model usage is billed separately and is not capped by this event limit. Failed or cancelled model calls can still incur gateway charges. Check your gateway/account budget as well.

### Tips

- Use unbranded buyer questions to measure discovery rather than prompting engines to name the brand.
- Keep and review the generated questions before relying on a recurring comparison. Use the same saved questions in later runs.
- Track a consistent competitor set; mention order is relative to those brands.
- For ongoing larger question sets or repeated samples, use the per-answer tracker family.

### Use it through the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaiq/ai-visibility-audit").call(run_input={"brand": "Example Workspace", "website": "https://example.com", "category": "Project management software for small teams", "competitors": ["Example Planner | planner.example"], "questions": ["Which project management tools suit a small remote team?"], "engines": ["openai", "perplexity", "google-ai-overview"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('zaiq/ai-visibility-audit').call({"brand": "Example Workspace", "website": "https://example.com", "category": "Project management software for small teams", "competitors": ["Example Planner | planner.example"], "questions": ["Which project management tools suit a small remote team?"], "engines": ["openai", "perplexity", "google-ai-overview"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP (one call, results back)**

```bash
curl -X POST 'https://api.apify.com/v2/acts/zaiq~ai-visibility-audit/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"brand": "Example Workspace", "website": "https://example.com", "category": "Project management software for small teams", "competitors": ["Example Planner | planner.example"], "questions": ["Which project management tools suit a small remote team?"], "engines": ["openai", "perplexity", "google-ai-overview"]}'
```

### Integrations and schedules

- **Schedules:** run it every hour, day or week from the Apify Console (Schedules) and keep a history of results.
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable:** connect it through Apify's integrations, or send each finished run to a **webhook**.
- **Datasets:** results stay in the run's dataset; export them or read them by API whenever you need them.

### Use it with AI agents (MCP)

Add Apify's MCP server (`https://mcp.apify.com`) to Claude, ChatGPT, Cursor, VS Code or any MCP client. The agent can find this Actor and run it for you: ask it for "audit a brand against its competitors and create an AI visibility report with cited-page evidence". AI agents can also pay for runs directly through Apify's agentic payments.

### Limits

- API answers use vendor models with web search. They can differ from consumer apps because of personalisation, interface behaviour and model settings.
- A mention is a boundary-matched brand name or supplied domain in the answer. A citation is a link to the brand domain or its subdomains. Name-only citation matching is a heuristic; supply a domain for more reliable matches.
- Citation share in the tracker means the fraction of usable answers citing a brand, not its fraction of all source links. Failed answers and unreadable overviews are excluded from visibility rates; coverage is shown separately.
- The first tracked brand is the report subject. Other supplied brands are competitors. Ordinary trackers do not infer unnamed competitors. Shopping reports also use brands returned by the existing product parser.
- Recommendations use bounded page titles, headings and descriptions. They do not prove the brand lacks a page, verify factual accuracy, or promise improved rankings. Blocked, robots-disallowed and unread pages are labelled.
- Project history compares matching question/engine pairs only when successful repeat identities, counts and models match. Changing the tracked brands, country, language or Actor family creates a new baseline. An all-failed run is retained but does not replace the last usable baseline.
- Use a unique project name per engagement and schedule its runs sequentially. Concurrent runs share a last-writer-wins LATEST pointer. Named stores retain immutable run records until you remove them or your account retention policy applies.
- There is no login or CAPTCHA solving. The cited-page reader uses direct public connections, checks robots.txt, and stops using a host after a 429, 401 or 403. It reads at most 12 cited pages and uses no residential route.
- At most 20 questions, three engines and one sample per question/engine. Engine work is bounded to 900 seconds and evidence reading to 120 seconds; unfinished work is reported.
- Question generation requires readable website text and a category. A blocked site, incomplete model response or brand-leading generated question results in a free diagnostic audit; supply your own questions to proceed.
- The score is 100 × (0.60 × mention rate + 0.30 × citation rate + 0.10 × first-mention rate), with usable answers as the denominator. It is a transparent sample index, not an industry benchmark.

### FAQ

**Does this log into the AI apps?**

No. Model answers come through the gateway’s official model APIs with web search; Google Overview comes from its results page.

**Are AI costs included in $4.00?**

No. Gateway usage is separate and can exceed the Actor event price.

**Can I get a report without generated questions?**

Yes. Supply questions; no question-generation call is made.

**Does a zero score mean the engine failed?**

No. Zero means usable answers gave the brand no measured visibility. When there are no usable answers, the score is null and displayed as Not measured.

**Can this guarantee more AI citations?**

No. Recommendations are evidence for a content review, not ranking guarantees.

### Related Actors from Zaiq

- [ai-answer-tracker](https://apify.com/zaiq/ai-answer-tracker): Ongoing monitoring with per-answer pricing and repeated samples.
- [ai-shopping-tracker](https://apify.com/zaiq/ai-shopping-tracker): Product recommendation and shopping visibility tracking.

### Support

Questions, a site that changed, or a field you need? Open an issue on this Actor's **Issues** tab: we answer there, usually within a day.

***

Also found as: AI visibility audit, AI brand report, AI competitor audit, GEO audit, AI citation report.

# Actor input Schema

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

The brand being audited. Use its actual name for your own audit.

## `website` (type: `string`):

Public homepage URL. Required when questions are omitted; read without login or proxy.

## `category` (type: `string`):

Explain what the brand sells and who buys it. Used with the website to generate buyer questions.

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

Up to 10 names, domains or Name | domain entries. The report compares these brands; it does not guess unlisted companies.

## `questions` (type: `array`):

Up to 20 distinct buyer questions. Leave empty to generate questions in one model call using the website and category. Supplied questions skip that call.

## `questionCount` (type: `integer`):

Used only when questions are omitted. One low-cost model call generates this many questions; no silent template fallback.

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

Choose 1 to 3 engines. API answers can differ from consumer apps. Google AI Overview uses the platform SERP route.

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

The searcher's country (two-letter code). ChatGPT, Perplexity, Claude and Grok search as from there and Google's AI Overview is read from that country's Google; Gemini does not take a location.

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

Language of Google's results page, e.g. en, de, fr, pt-BR. Empty: the country's usual language.

## `projectName` (type: `string`):

Opt in to reports and persistent run history in a named key-value store. Reuse exactly the same project name for comparisons; schedule runs sequentially. Failed or incomparable answers do not become losses.

## `maxCitedPages` (type: `integer`):

Maximum public cited pages read for recommendations when reporting is enabled. Zero uses citation URLs only and labels coverage unknown. No proxy or AI calls are used.

## Actor input object example

```json
{
  "brand": "Example Workspace",
  "website": "https://example.com",
  "category": "Project management software for small teams",
  "competitors": [
    "Example Planner | planner.example"
  ],
  "questions": [
    "Which project management tools suit a small remote team?",
    "How should a small team compare project management software?"
  ],
  "questionCount": 20,
  "engines": [
    "openai",
    "perplexity",
    "google-ai-overview"
  ],
  "country": "US",
  "maxCitedPages": 8
}
```

# Actor output Schema

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

Dataset: the results.

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

What each input returned, and notes.

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

A one-page view of the results to open in a browser.

# 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": "Example Workspace",
    "website": "https://example.com",
    "category": "Project management software for small teams",
    "competitors": [
        "Example Planner | planner.example"
    ],
    "questions": [
        "Which project management tools suit a small remote team?",
        "How should a small team compare project management software?"
    ],
    "engines": [
        "openai",
        "perplexity",
        "google-ai-overview"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaiq/ai-visibility-audit").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": "Example Workspace",
    "website": "https://example.com",
    "category": "Project management software for small teams",
    "competitors": ["Example Planner | planner.example"],
    "questions": [
        "Which project management tools suit a small remote team?",
        "How should a small team compare project management software?",
    ],
    "engines": [
        "openai",
        "perplexity",
        "google-ai-overview",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("zaiq/ai-visibility-audit").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": "Example Workspace",
  "website": "https://example.com",
  "category": "Project management software for small teams",
  "competitors": [
    "Example Planner | planner.example"
  ],
  "questions": [
    "Which project management tools suit a small remote team?",
    "How should a small team compare project management software?"
  ],
  "engines": [
    "openai",
    "perplexity",
    "google-ai-overview"
  ]
}' |
apify call zaiq/ai-visibility-audit --silent --output-dataset

```

## MCP server setup

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

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/COAzb2aceHrjADeNq/builds/8eSIwNgGGEyZB360X/openapi.json