# AI Search Visibility Action Plan (`gtm_solutions/ai-search-visibility-action-plan`) Actor

Check whether the AI search engines can fetch, read and cite your site, see what ChatGPT and Perplexity actually answer for your topics, and get a ranked fix list where every recommendation points at the evidence behind it. Pay per report.

- **URL**: https://apify.com/gtm\_solutions/ai-search-visibility-action-plan.md
- **Developed by:** [Clance Hoskin](https://apify.com/gtm_solutions) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4,950.00 / 1,000 visibility report (your own engine keys)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 Action Plan

**Can ChatGPT and Perplexity find your business? Run one report and see what they say about you, what is stopping them, and the three things to fix first.**

![AI Search Visibility Action Plan — cover](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/aiv-cover.png)

Give it your domain and your brand. It checks whether the AI search crawlers can fetch and read your site, asks ChatGPT and Perplexity your buyers' questions on your own API keys, and hands back a ranked fix list where every recommendation points at the evidence behind it. One domain per run, pay per report, no subscription.

### Who it's for

- Marketing and SEO leads who are asked "why aren't we in ChatGPT's answer?" and need something better than a guess.
- Agencies producing an AI-visibility audit for a client — the report is the deliverable, with the evidence attached.
- Founders and product marketers checking a launch site before the first campaign.

It is for domains you control or are allowed to audit.

### What you get

Three tiers, in the order to act on them:

1. **Can they reach you?** — the technical checks (what the Actor calls eligibility): which AI crawlers your robots.txt allows (search bots told apart from training bots — blocking `GPTBot` is a policy choice; blocking `OAI-SearchBot` hides you from answers), whether a WAF challenges the search bots while browsers pass, whether the main content is in the HTML or needs JavaScript (the crawlers don't run it), `noindex`/`nosnippet` directives, canonicals and redirect chains, Organization JSON-LD, `sameAs` profile links, the sitemap, and `llms.txt` (reported, not scored).
2. **What they said about you** — what the Actor calls observed inclusion: for each prompt and each engine you gave a key for: was the brand mentioned, was your domain cited, which competitors were named, and which sites the engine cited instead. Rolled up into mention rate, citation rate, share of voice and the top cited hosts per engine. An engine you did not query is absent, never zero.
3. **What to do first** — what the Actor calls inferred opportunity: where the engines go for answers on your topics and you are not yet: directories and review sites to get listed on, prompts where a competitor is named and you are not.

Outputs: `OUTPUT` (the report as JSON), `REPORT.md` (the action plan for people), and a dataset with one row per finding, observation and recommendation. Every recommendation carries the ids of the findings it rests on; the Actor refuses to write a plan that doesn't.

![How it works](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/aiv-how-it-works.png)

### How the check works

The technical layer fetches your robots.txt, your sitemap, the homepage and up to five more pages (or the pages you name, up to ten) — once as a normal browser and once as each AI search bot (OAI-SearchBot, PerplexityBot, Claude-SearchBot) — and compares what each received: a 403, a challenge page or a body a fifth the size is a block. It then reads the raw HTML the way a crawler does, without running scripts: how many words are actually there, the title and description, robots directives in the tag and the header, the canonical, the JSON-LD, the profile links. At most 60 requests, two per second, no headless browser.

The engine layer sends each prompt to Perplexity's Agent API (the tier's preset, with web search) and to OpenAI's Responses API with its web-search tool, on your keys, and keeps the answer text, the citations and the token usage. It looks for your brand and your competitors in each answer and for your domain among the citations. The plan is a fixed rule table over those findings and metrics — no model writes the recommendations, so the same site with the same answers gets the same plan.

**Don't know your topics?** Leave them empty. The Actor reads your homepage and asks your own engine key for the things a customer would search for, keeps four, and where the homepage gives too little it fills the rest with questions about your brand by name — the report says which topics came from where. Tick *Just suggest topics* to see them first without buying a report.

![Sample output](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/aiv-sample.png)

### Which AI should we ask?

One report asks one tier of models — the same tier on both engines:

| Tier | Perplexity | OpenAI | When |
|---|---|---|---|
| **Quick** | `fast` | `gpt-5.6-luna` | The cheapest models on your keys. A first look. |
| **Standard** (default) | `medium` | `gpt-5.6-terra` | The models closest to what the ChatGPT and Perplexity apps show most people. |
| **Deep** | `high` | `gpt-6-astra` | Their strongest models — what a paying app user may see. |

Answers come from the engines' official APIs — the same model families the apps use — without a person's history or settings, so what one customer sees can differ. To see what another tier says, run another report; the report price is the same, and the bigger models cost more on your own keys.

### Input

| Field | Meaning |
|---|---|
| `domain` | The site to check, as a hostname or URL. One per run. |
| `brand` | The name the engines should mention, as customers write it. |
| `aliases` | Other spellings or short names that count as a mention (up to 5). |
| `competitors` | Names to look for in answers, optionally `name|domain` (up to 5). |
| `topics` | What you want to be found for (up to 10); each becomes five prompts. Leave empty and the Actor reads your homepage and chooses four — an engine key is needed to ask them. |
| `suggestOnly` | Reads your homepage, writes the topics it would ask about, and stops. No report is charged; a key you give makes one small call. Paste the ones you want into `topics` and run again. |
| `locations` | Places added to the questions made from topics you typed, e.g. 'Taipei' (up to 3). Not used when topics are chosen for you. |
| `prompts` | Your own questions for the engines. 20 are included in the report price; each prompt above 20 is an `extraPrompts` event; 100 at most. |
| `pages` | Pages on the domain to check besides the homepage (up to 10). Empty → the first five sitemap URLs. |
| `modelTier` | Which tier of models to ask — `quick`, `standard` (default) or `deep`. See above. |
| `perplexityApiKey` | Queries Perplexity with your key. Stored as a secret, never written to the output. |
| `perplexityModel` | API only, not on the form: a specific Perplexity preset or model id that overrides the tier for this engine. Empty means the tier decides. |
| `openaiApiKey` | Queries OpenAI with your key. Stored as a secret, never written to the output. |
| `openaiModel` | API only, not on the form: a specific OpenAI model id that overrides the tier for this engine. Empty means the tier decides. |
| `includeEvidence` | Include short page and answer excerpts in the output (default on). |
| `managed` | Operator-only; refused on the public Actor. |

Without any engine key the report covers the eligibility tier only, and is still one report.

### Pricing

Pay per report, charged only when the report is written:

| Event | Price | What it covers |
|---|---|---|
| `byokReport` | **US$4.95** | One domain, one model tier of your choice, 20 prompts on your own engine keys |
| `extraPrompts` | **US$0.10** | Each prompt above the 20 included, up to 100 |
| `managedReport` | **US$14.95** | The same report on our engine keys — not yet available on the Store |

Your engine keys are billed by Perplexity and OpenAI directly, at their list prices, for the prompts the report asks; the report's `costs` block shows the tokens and searches each engine used. A run that fails — an invalid domain, a rejected key — charges nothing.

### Limits — please read

- One domain per run; up to 10 extra pages; up to 100 prompts.
- At most 60 requests to the site per run, two per second, ten seconds each; no headless browser — a page that needs JavaScript to show its content is reported as such, not rendered.
- Two engines in this version: Perplexity and OpenAI. Google's AI Overviews have no API and are not covered; the report says so rather than inventing a number.
- Answers vary between runs: the engines are not deterministic. The technical checks are — re-running them on the same site gives the same verdicts.
- The report is for domains you control or are allowed to audit.
- Chosen topics come from your homepage, four at most; where it gives too little, questions about your brand by name fill the rest — the report says which is which.

### Compared with alternatives

| | This Actor | AI-visibility SaaS (monthly) | A generic SEO crawl |
|---|---|---|---|
| Price | Per report, from US$4.95 | US$30–500 a month | Per crawl or monthly |
| Crawler eligibility with evidence | Yes, per bot, search bots told from training bots | Rarely | No |
| What the engines actually answered | Yes, on your keys, per prompt | Yes, on theirs | No |
| Ranked plan tied to findings | Yes, by rule; every fix cites its evidence | Varies | Generic issues list |
| Runs from code or a schedule | Yes (Apify API) | Sometimes | Sometimes |

### FAQ

**Do you need my API keys?** Only to ask the engines. They are `isSecret` inputs — encrypted at rest, never written to the dataset, the report, the log or an error message. Leave them out and you get the eligibility tier only.

**Why is Google not here?** Google's AI Overviews and AI Mode have no API. Gemini's grounding API is a different product. Rather than pass one off as the other, the report covers what can be observed.

**Does `llms.txt` help?** Nobody has shown that the answer engines read it. The report records whether you have one and scores nothing on it.

**Is this an SEO audit?** No. It checks the things that decide whether an AI engine can fetch, read and cite you, then what the engines actually said, then where to earn a presence. A crawl tool lists issues; this ranks fixes by impact and effort with the evidence attached.

**How current are the answers?** As of the run. Re-run monthly, or after you ship a fix, and compare the metrics.

### Support

Questions, a site the checks misread, a shape change at an engine: open an issue on this Actor's Apify page or write to hello@buildonmarketplaces.com. We answer within two working days. Built in public by BuildOn Marketplaces; the page for this Actor, with a real report on our own domain, is at https://buildonmarketplaces.com/solutions/ai-search-visibility.

### Changelog

- **0.1** — First version: eligibility checks (robots per bot, crawler fetch, content, metadata, structured data, entity signals, sitemap, llms.txt), Perplexity and OpenAI on your keys, the ranked plan, `OUTPUT`/`REPORT.md`/rows.

# Actor input Schema

## `domain` (type: `string`):

The site to check, as a hostname or URL (example.com or https://www.example.com). One domain per run.

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

The name the engines should mention, as customers write it.

## `aliases` (type: `array`):

Other spellings or short names that count as a mention (up to 5).

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

Names to look for in the answers, optionally with a domain as name|domain (up to 5).

## `topics` (type: `array`):

What you want to be found for, e.g. 'CRM software for agencies' (up to 10). Leave empty and, with an engine key, we read your homepage and choose them for you.

## `suggestOnly` (type: `boolean`):

Reads your homepage, writes the topics we would ask about, and stops. No report is charged; a key you give makes one small call. Paste the ones you want into Topics and run the report.

## `locations` (type: `array`):

Places added to the questions made from topics you typed, e.g. 'Taipei' (up to 3). Not used when topics are chosen for you.

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

Questions to ask the engines. Leave empty to generate them from the topics. 20 are included in the report price; each prompt above 20 is an extraPrompts event; 100 at most.

## `pages` (type: `array`):

Pages on the domain to check besides the homepage (up to 10). Leave empty to use the first five sitemap URLs.

## `modelTier` (type: `string`):

Quick asks the engines' cheapest models (a first look). Standard asks the models closest to what the ChatGPT and Perplexity apps show most people. Deep asks their strongest models. One report asks one tier; run another report to compare.

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

Queries Perplexity with your key. Stored as a secret; never written to the output.

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

Developers only (API): a specific Perplexity preset or model id that overrides the dropdown for this engine. Empty means the dropdown decides. Not shown on the form.

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

Queries OpenAI (Responses API with web search) with your key. Stored as a secret; never written to the output.

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

Developers only (API): a specific OpenAI model id that overrides the dropdown for this engine. Empty means the dropdown decides. Not shown on the form.

## `includeEvidence` (type: `boolean`):

Include short page and answer excerpts (up to 400 characters each) in the output.

## `managed` (type: `boolean`):

Operator-only: query the engines on the operator's keys. Refused unless enabled on the Actor's environment.

## Actor input object example

```json
{
  "domain": "example.com",
  "brand": "Example Co",
  "aliases": [],
  "competitors": [],
  "topics": [],
  "suggestOnly": false,
  "locations": [],
  "prompts": [],
  "pages": [],
  "modelTier": "standard",
  "includeEvidence": true,
  "managed": false
}
```

# Actor output Schema

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

Eligibility findings with evidence, per-engine observations and metrics, the ranked plan, coverage and costs.

## `plan` (type: `string`):

The human-readable plan: three tiers, each fix with why, how and its evidence.

## `rows` (type: `string`):

Every finding, observation and recommendation as a dataset row, for piping elsewhere.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gtm_solutions/ai-search-visibility-action-plan").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gtm_solutions/ai-search-visibility-action-plan").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 '{}' |
apify call gtm_solutions/ai-search-visibility-action-plan --silent --output-dataset

```

## MCP server setup

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

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/oMfdxGgR7q1eDIJaI/builds/ObHoogMacoXdp9TsB/openapi.json