# AI Answer Visibility Audit (`techclout/ai-answer-visibility-audit`) Actor

Paste a website URL to see whether AI answers recommend that company for real buyer questions, which competitors they name instead, and which sources they cite. Uses the official OpenAI API with web search. Not affiliated with OpenAI.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Answer Visibility Audit

**Paste a website URL and see whether AI answer engines recommend that company when buyers ask for help, which competitors they name instead, and which sources they cite.**

The Actor reads the homepage, works out what the company sells and who buys it, writes realistic buyer questions, finds current competitors, and asks each question through the official OpenAI API with web search turned on (the engine behind ChatGPT search). You get one evidence row per answer plus a ready-to-share report.

> This is an API benchmark with web search. It is not a recording of the consumer ChatGPT app, and answers there can differ. Not affiliated with OpenAI, Google, or Perplexity.

### What you can use it for

- **Find the buyer questions you are losing.** It lists every question where a competitor or another firm was recommended and your brand was not.
- **See who wins those answers.** Each answer lists the companies it recommends, with their domains when the answer cites them.
- **Build an outreach list from cited sources.** It ranks the domains the engine cites, so you know which pages and directories shape the answers.
- **Check how AI describes your brand.** Optional brand questions ask about the company by name and flag answers that confuse it with a different company.
- **Repeat the same audit for many clients.** Agencies can run it per client and hand over the HTML report.

### How to use it

1. Enter the **Website URL** of the company to audit.
2. Optional: add your own buyer questions or competitors. If you leave them empty, the Actor infers them from the website.
3. Optional: turn on **Brand-prompted questions** to add 2 questions that name the brand. These are scored separately.
4. Start the run. A 10-question audit usually finishes in about 1 to 2 minutes.
5. Open the **Output** tab for the answer table, or the **Storage → Key-value store** for `REPORT_HTML`, `REPORT_MARKDOWN`, and `REPORT` (JSON).

### What you get

**Dataset (one row per question and sample):**

- question, engine, model, method label
- brand status: `cited` (an answer cites the brand's own domain), `mentioned` (named but not cited), `absent`, or `misidentified` (the name is used for a different company)
- status for each tracked competitor
- the companies the answer recommends, with domains when cited
- answer snippet and full answer text
- citation URLs and timestamp
- a `site-profile` row with the inferred company, buyer, questions, and competitors

**Report (key-value store, JSON + Markdown + HTML):**

- Share of Answer and appears rate on questions that do not name the brand
- losing questions, with who appeared instead
- other companies recommended, with counts
- top cited domains, ranked by how many questions cite them
- brand-prompted results in their own section
- method notes and any warnings, such as a provider error

### Input

`websiteUrl` is the only required field.

| Field | Default | Notes |
| --- | --- | --- |
| `websiteUrl` | | Public http(s) homepage. Private and local addresses are rejected. |
| `brandName`, `brandAliases` | inferred | Extra names count as mentions. |
| `competitors` | inferred, 3 to 5 | Objects with `name` and `domain`. Inferred competitors must be operating now, and their domains must resolve. Service firms are compared with service firms of a similar size. |
| `questions` | inferred, 5 to 15 | Your own buyer questions. Inferred questions are full sentences a buyer would ask, mixing "who should I hire", "how do I", and comparison questions, and they never name the brand. |
| `brandPrompted` | false | Adds exactly 2 questions that name the brand. Reported separately. |
| `maxQuestions` | 10 | Maximum 25. |
| `engines` | `openai` | `openai` is the OpenAI Responses API with web search. Gemini and Perplexity options are listed for a later release. If you select one before it is enabled, its rows are marked skipped or error and are not charged. |
| `country`, `language` | US, en | Passed into the prompts. |
| `samplesPerQuestion` | 1 | Up to 3. Answers vary between calls, so more samples give a steadier picture. Each sample is charged. |
| `includeReport` | true | Saves the JSON, Markdown, and HTML report. |
| `timezone` | UTC | Time zone for the date printed on the report, for example `America/New_York`. |

#### Example input

```json
{
  "websiteUrl": "https://apify.com",
  "maxQuestions": 10,
  "engines": ["openai"],
  "brandPrompted": true,
  "includeReport": true
}
```

### Example output

One answer row (shortened):

```json
{
  "recordType": "answer",
  "question": "Which AI automation agencies help small businesses with CRM follow-up?",
  "engine": "openai",
  "model": "gpt-4.1-mini",
  "method": "API benchmark with search",
  "brandName": "Example Co",
  "brandStatus": "absent",
  "competitorStatuses": [
    { "name": "Northline", "domain": "northline.example", "status": "cited" },
    { "name": "Fieldnote", "domain": "fieldnote.example", "status": "absent" }
  ],
  "otherBrands": ["Harbor Automation"],
  "otherBrandDomains": [
    { "name": "Harbor Automation", "domain": "harborautomation.example" }
  ],
  "citationUrls": ["https://northline.example/services/crm"],
  "status": "ok"
}
```

Report summary for the same kind of run:

| Metric | Example |
| --- | --- |
| Answers checked | 10 |
| Brand appears in | 2 of 10 answers |
| Share of Answer | 25% (brand vs. tracked competitors) |
| Losing questions | 6, each with who appeared instead |
| Top cited domains | the 10 domains cited most across questions |

### Pricing

Pay per event. You pay only for successful work, and platform usage is included.

| Event | Price | When it is charged |
| --- | --- | --- |
| Engine answer checked | $0.05 | One successful answer to one question, saved to the dataset. |
| Site profile built | $0.05 | Once per run, when questions or competitors are inferred from the website. |
| Audit report | $0.25 | Once per run, when the report is saved. |

**Example:** 10 questions on one engine, with the inferred profile and the report: `10 × $0.05 + $0.05 + $0.25 = $0.80`. With the 2 brand questions added: $0.90.

Provider errors are saved on the row and are **not charged**. If the profile cannot be built and you gave no questions or competitors, no answers are charged and the run fails with the reason. If the AI provider behind the Actor is temporarily out of credit, the run stops at once and fails with a clear message. Answers that were not delivered and the report are not charged. You can set a maximum cost per run; the Actor stops before going over it.

#### Free Apify plan

Runs started from a free Apify plan are limited to **3 questions, 2 engines, and 1 sample**. The run still finishes and returns results, with the notice "Free tier limit reached". This limit exists because every answer calls a paid AI API. Upgrade to any paid Apify plan to run the full audit.

### How the scores work

- **Share of Answer** = the brand's appearances ÷ all appearances of the brand and the tracked competitors, on questions that do not name the brand. If neither appears, it is shown as n/a with a one-line reason.
- **Appears rate** = the share of answers in which the brand is cited or mentioned.
- **Losing question** = the brand is absent and at least one competitor or another named company is present.
- Scoring uses plain name and URL matching. A model is not asked to grade the answers. A second call to the same engine only lists which companies an answer recommends; it is not charged as a separate event.

### Limits and good practice

- Answers change from day to day and between calls. Treat one run as a snapshot. Re-run on a schedule to see the trend, and raise `samplesPerQuestion` for important audits.
- Results come from the official API with web search. The consumer ChatGPT app can show different answers.
- The homepage is read without a browser. A site that only renders in a browser may give a thin profile. In that case, supply your own questions and competitors.
- This Actor measures visibility. It does not change or guarantee how any AI engine ranks or recommends a company.

### FAQ

**Do I need my own OpenAI key?** No. The Actor uses its own keys, and the cost is included in the event prices.

**Can I audit a competitor's site?** Yes. Any public homepage works.

**Can I use it from an AI agent or via API?** Yes. Call it like any Apify Actor, from the API, the Apify MCP server, or integrations such as Make, Zapier, and n8n.

**Is my data used to train models?** The Actor sends the public homepage text and the questions to the OpenAI API. Under OpenAI's API terms, API data is not used for training by default.

**Something looks wrong?** Open an issue on the Actor's Issues tab with the run ID. We aim to reply within 3 business days.

# Actor input Schema

## `websiteUrl` (type: `string`):

Homepage of the company to audit. Must be a public http or https URL. Private addresses, localhost, and link-local hosts are rejected.

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

Optional override. When empty, the name is taken from the page or inferred.

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

Optional extra names to count as a mention. Matching is case-insensitive and uses word boundaries.

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

Optional. Leave empty to infer 3 to 5 competitors that are operating now. A services firm is matched with service firms or consultancies of a similar buyer size, not software platforms. A domain that does not resolve, or that redirects to a different company, is dropped. Defunct and acquired brands should not be included.

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

Optional. Leave empty to infer 5 to 15 unprompted buyer questions. About 40 percent ask who to hire or the best agency or consultant for the category and buyer, about 40 percent are problem or how-to questions, and about 20 percent are comparisons. Those questions do not name the brand.

## `maxQuestions` (type: `integer`):

How many questions to check, after inference or from the questions you supplied. Default 10. Maximum 25. Free-plan runs are still capped at 3 questions.

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

Official APIs to query. openai is the OpenAI Responses API with web search (the default). Gemini and Perplexity are listed for a later release: until they are enabled, selecting one only adds a skipped or error row for that engine, and those rows are not charged. Free-plan runs use only the first 2 selected engines.

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

Country context passed to the engines. Default US.

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

Language the engines should answer in. Default en.

## `samplesPerQuestion` (type: `integer`):

How many times to ask each question on each engine. Answers vary between calls. Each successful sample is charged as engine-answer-checked. Failed calls are not charged. Default 1. Maximum 3. Free-plan runs use 1.

## `includeReport` (type: `boolean`):

When true, write the REPORT key with Share of Answer, losing questions, and cited domains as JSON, plus Markdown and HTML copies. Charged as audit-report.

## `brandPrompted` (type: `boolean`):

When true, add exactly 2 questions that name the brand and the buyer, such as whether the company is a fit and how it compares with other agencies for that work. Those answers are reported separately and are not included in unprompted Share of Answer. Default false.

## `timezone` (type: `string`):

IANA time zone for the date on the Markdown and HTML report, for example America/New_York. Default UTC, which is labeled UTC. The JSON timestamp stays ISO-8601. An unrecognized zone is rejected.

## `uiObservation` (type: `boolean`):

Advanced. Leave off. This Actor does not open consumer chat websites. Turning this on records a notice and still runs the API benchmark only.

## Actor input object example

```json
{
  "websiteUrl": "https://apify.com",
  "competitors": [],
  "maxQuestions": 10,
  "engines": [
    "openai"
  ],
  "country": "US",
  "language": "en",
  "samplesPerQuestion": 1,
  "includeReport": true,
  "brandPrompted": false,
  "timezone": "UTC",
  "uiObservation": false
}
```

# Actor output Schema

## `answers` (type: `string`):

One dataset item per question, engine, and sample, plus a site-profile item when questions or competitors were inferred.

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

Share of Answer, appears rate, share of voice by engine, losing questions, and top cited domains.

## `reportMarkdown` (type: `string`):

The same report rendered as Markdown for an agency hand-off.

## `reportHtml` (type: `string`):

The same report rendered as a single HTML file.

# 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 = {
    "websiteUrl": "https://apify.com",
    "competitors": [],
    "engines": [
        "openai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("techclout/ai-answer-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 = {
    "websiteUrl": "https://apify.com",
    "competitors": [],
    "engines": ["openai"],
}

# Run the Actor and wait for it to finish
run = client.actor("techclout/ai-answer-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 '{
  "websiteUrl": "https://apify.com",
  "competitors": [],
  "engines": [
    "openai"
  ]
}' |
apify call techclout/ai-answer-visibility-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,techclout/ai-answer-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/Mj8TiZYPiwGKpRTON/builds/SzIxkJHnXKQKWvmP8/openapi.json