# AEO/GEO Optimizer - AI Brand Monitoring (`inovaflow/ai-brand-monitoring`) Actor

Track how your brand shows up in Google's AI Overview answers. Schedule a prompt list daily; get one dataset row per prompt with the AI answer, citations, brand and competitor mention counts. Includes an MCP server so AI agents can run ad-hoc 'where does my brand appear?' checks.

- **URL**: https://apify.com/inovaflow/ai-brand-monitoring.md
- **Developed by:** [inovaflow](https://apify.com/inovaflow) (community)
- **Categories:** MCP servers, SEO tools, Agents
- **Stats:** 3 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / actor start

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

**See whether AI recommends your brand — or your competitor — when customers ask.**

Your customers don't scroll ten blue links anymore. They ask ChatGPT, Google's AI, or Perplexity *"what's the best [your thing]?"* and trust whatever it says back. If your brand isn't in that answer, you're invisible — and no rank tracker will tell you, because there's no link to rank.

So we built this to watch those answers for you. Give it the questions your customers ask and your brand name, and it checks who the AI actually names — across **Google AI Overview, Google AI Mode, Gemini, Perplexity, ChatGPT, and Copilot**. You get a simple 0–100 visibility score and its trend, the exact answers that named or cited you, who's winning instead of you, and — the part no other tool does — it reads the *exact page* a competitor was cited from and tells you, in plain English, what to change to win that answer back.

**Behind the scenes, this is an orchestrator** — it doesn't scrape anything itself. It runs other specialized Apify Actors for you in the background and merges their results into one report. Every AI answer comes from [apify/google-search-scraper](https://apify.com/apify/google-search-scraper); the competitor deep-dive crawls the winning page with [apify/website-content-crawler](https://apify.com/apify/website-content-crawler). **Those background runs are billed to you too — see [Costs](#costs).**

> 🧪 **Early access.** This is new and **priced lean** — a small **$0.05** per-run start fee, plus platform usage + the background Actors you'd pay anyway. The only AI charge is for the optional competitor deep-dive (and it's free with your own key). No per-result markup. Tell us what to add next or if anything feels off → open an issue on the **Issues** tab. 🙏

### The Apify Actors it runs

You don't run anything yourself — this Actor calls these proven Apify Actors for you, on your own account:

| Actor | What it does here | When it runs |
|---|---|---|
| [apify/google-search-scraper](https://apify.com/apify/google-search-scraper) | Runs every AI-answer check — Google AI Overview, AI Mode, Gemini, Perplexity, ChatGPT, Copilot | Every run |
| [apify/website-content-crawler](https://apify.com/apify/website-content-crawler) | Crawls the exact competitor page the AI cited, for the deep-dive | Only when the competitor deep-dive is on |

Both are **pay-as-you-go Apify Store Actors**, and their runs bill to **your own Apify account** (cents per run) — so you'll see them on your Apify usage alongside this Actor. Results are delivered to **Slack** and **Notion** through their official MCP connectors — connect once, no passwords shared.

### Who it's for

- **SEO & content leads moving into AEO** — *"is AI eating my traffic, and am I even in the answers?"*
- **Founders & marketers** — *"when someone asks AI for the best tool in my market, do they hear my name or my rival's?"*
- **Agencies** — track several clients across countries and AI engines from one place.
- **PR & brand teams** — catch the moment a competitor starts winning answers you don't.

### What you get

- **A visibility score + trend.** Per question, per engine: are you mentioned, are you cited, and is your score climbing or slipping over the last few runs.
- **The exact answers that named you.** For every question where you showed up, the snippet around your mention *and the full AI answer* — so you can verify exactly where and how (clearest in Notion).
- **Who's winning, and where you slipped.** Share of voice vs the competitors you name, a per-engine breakdown, your fresh wins, and the prompts you *lost* this week.
- **🔍 The page that beat you.** When a competitor wins a question you lose, we crawl the *exact page the AI cited*, explain why it won, and hand you a copy-paste fix per question. Nobody else reads the winning page.
- **📬 Delivered where you work.** A `REPORT` you can read right in the Apify Console, a short daily summary in **Slack**, dated **Notion** report pages (plus an optional results **table** you can filter and sort), or just *ask* any AI assistant *"how's my brand doing this week?"* (it's an MCP server too).

### Set it up in 2 minutes

1. Add your **questions** (one per line, in your customers' language) and your **brand**.
2. Pick a **country** and which **AI engines** to check. (Add **competitors** to unlock the deep-dive.)
3. Hit **Start** — and use the **Schedule** tab to run it daily, so you can watch the trend.

The AI checks run on your own Apify account automatically. The competitor deep-dive's write-up uses built-in AI out of the box, or your own Anthropic key if you prefer (both optional).

### Costs

Early access, **priced lean** — pay only when you run, no subscriptions, no per-result markup. You pay:

- **$0.05 each time a run starts** — our one baseline charge.
- **Apify platform usage** (compute) for this Actor — it's mostly orchestration, so it stays small.
- **The background Actors' own fees** — [apify/google-search-scraper](https://apify.com/apify/google-search-scraper) for the AI checks, and [apify/website-content-crawler](https://apify.com/apify/website-content-crawler) for the deep-dive crawl. These run on **your own Apify account**, so they show up on your Apify bill directly (cents per run).

**About AI charges — only the competitor deep-dive uses our AI.** Tracking your visibility uses **no AI of ours**: the AI answers are fetched by the search-scraper Actor (billed to your own account), and we just read them — so the regular checks carry **no extra AI cost**. The only place we charge for AI is the optional **competitor deep-dive** (the "why they win" write-up), and only when you turn it on:

- **$0.02 per analysis on Claude Haiku**, or **$0.06 on Claude Sonnet** — one charge per deep-dive run.
- **$0 if you bring your own Anthropic key** (then you pay Anthropic directly).

So a typical daily run is **a few cents** from us, plus your own background-Actor usage. If anything ever feels expensive, tell us on the **Issues** tab and we'll dig into it.

### Ask your AI assistant (MCP)

It's also an **MCP server**. Connect it to Claude, Cursor, or any MCP client and just ask — *"where does my brand show up for [question]?"* or *"where am I losing this week?"* — live.

### Notes

This reads **publicly visible AI answers** and logs into nothing. The nested Apify Actor runs (search scraper + competitor crawler) bill to your own Apify account. The competitor deep-dive write-up uses AI — our built-in key by default (a small cover-cost charge), or paste your own Anthropic key (then you pay Anthropic directly and we skip that charge).

Found a bug, want another engine or market, or need tailored output? Open an issue on the **Issues** tab — we read every one. 🙏

# Actor input Schema

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

The questions your customers ask AI engines, one per line. Each is checked across every selected engine and country, and the actor notes whether your brand appears, who else does, and who gets cited.
## `brand` (type: `string`):

Your brand name — matched whole-word, case-insensitive in every AI answer. Leave blank and the brand-mention columns stay empty.
## `brandAliases` (type: `array`):

Other spellings of your brand — product names, abbreviations, former names. Each alias counts as a brand mention. Leave empty to match the main brand name only.
## `brandDomains` (type: `array`):

The domains you own, so the actor can detect when an answer cites you (not just names you). Leave empty and citation tracking is skipped.
## `competitors` (type: `array`):

Rival brand names to track alongside yours, one per line. Drives share-of-voice comparisons and selects the competitor for the deep-dive. Leave empty to monitor your brand alone.
## `country` (type: `array`):

Which countries' AI answers to check. Each country runs the questions in its regional language and locale, so you see what local customers see. Default: United States.
## `surfaces` (type: `array`):

Which AI engines to check each question on. Each engine adds one check per question per country. Default: Google AI Overview + Perplexity.
## `slackConnector` (type: `string`):

Connect Slack to receive a short daily summary — visibility score, trend, wins and losses, and competitor moves — in your team's channel. Leave unconnected and results are saved to the dataset only.
## `slackChannel` (type: `string`):

The Slack channel to post the summary in — channel name (#ai-visibility) or channel ID (C0123ABCD). Only used when a Slack connector is set.
## `notionConnector` (type: `string`):

Connect Notion to get a dated summary page each run with score trends, per-engine breakdowns, and competitor teardowns. Leave unconnected and results are saved to the dataset only.
## `notionParentPage` (type: `string`):

The Notion page where dated run-summary pages are created inside. Paste the full page link or just its 32-character ID. Only used when a Notion connector is set.
## `notionResultsPage` (type: `string`):

A Notion page or database that accumulates one row per question × engine × country on every run. Paste a blank page and the table is built on first run; paste an existing database to append directly. Leave empty to skip the growing table.
## `watchCompetitors` (type: `boolean`):

Enables the competitor deep-dive: one competitor per run is crawled, analysed, and turned into copy-paste fixes for your losing questions. Rotates competitors so the same one isn't re-analysed within 7 days. Off by default; adds a small extra cost.
## `competitorDomains` (type: `array`):

Competitor websites used when the AI answers don't already cite a URL, so the deep-dive can crawl the right page. Leave empty to use only URLs the AI answers provide. Only used when the deep-dive is on.
## `deepDivePrompt` (type: `string`):

Custom instructions for the competitor write-up. Leave blank to use the built-in AEO analyst prompt. Only used when the deep-dive is on.
## `deepDiveModel` (type: `string`):

Which Claude model writes the deep-dive analysis. Haiku is fast and cheap (default); Sonnet is more thorough but costs more. Only used when the deep-dive is on.
## `anthropicApiKey` (type: `string`):

Your Anthropic API key (sk-ant-…). With it, the AI write-up charges go to your Anthropic account and the actor doesn't bill the AI step. Leave blank to use the built-in AI for a small flat charge. Only used when the deep-dive is on.
## `apifyMcpConnector` (type: `string`):

An Apify MCP connector for a different Apify account, so the scraper and crawler runs bill to that account instead of the one running this actor. Leave unconnected to use the current account automatically. Server URL: https://mcp.apify.com/?tools=actors.
## `apifyToken` (type: `string`):

An API token from a different Apify account — same purpose as the connector above, without the OAuth flow. Leave blank to use the account running this actor.

## Actor input object example

```json
{
  "prompts": [
    "best CRM for small business",
    "top project management tools"
  ],
  "brand": "",
  "brandAliases": [],
  "brandDomains": [],
  "competitors": [],
  "country": [
    "us"
  ],
  "surfaces": [
    "aio",
    "perplexity"
  ],
  "slackChannel": "#ai-visibility",
  "watchCompetitors": false,
  "competitorDomains": [],
  "deepDiveModel": "haiku"
}
````

# Actor output Schema

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

The full run summary in Markdown — visibility score + trend, per-engine breakdown, wins/losses, where your brand was named or cited (with the snippet + full AI answer), and the competitor deep-dive. The same content is sent to Slack/Notion when connected.

## `dataset` (type: `string`):

One row per (question × engine × country × run) with the full AI answer, citations, and brand/competitor mention counts. Filter by `surface` to compare engines; filter by `invocation_source = scheduled` for clean trend charts.

# 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 = {
    "prompts": [
        "best CRM for small business",
        "top project management tools"
    ],
    "brand": "",
    "slackChannel": "#ai-visibility",
    "deepDiveModel": "haiku"
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/ai-brand-monitoring").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 = {
    "prompts": [
        "best CRM for small business",
        "top project management tools",
    ],
    "brand": "",
    "slackChannel": "#ai-visibility",
    "deepDiveModel": "haiku",
}

# Run the Actor and wait for it to finish
run = client.actor("inovaflow/ai-brand-monitoring").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "prompts": [
    "best CRM for small business",
    "top project management tools"
  ],
  "brand": "",
  "slackChannel": "#ai-visibility",
  "deepDiveModel": "haiku"
}' |
apify call inovaflow/ai-brand-monitoring --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=inovaflow/ai-brand-monitoring",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AEO/GEO Optimizer - AI Brand Monitoring",
        "description": "Track how your brand shows up in Google's AI Overview answers. Schedule a prompt list daily; get one dataset row per prompt with the AI answer, citations, brand and competitor mention counts. Includes an MCP server so AI agents can run ad-hoc 'where does my brand appear?' checks.",
        "version": "0.8",
        "x-build-id": "Z1kltIH3n9qpl5rKJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/inovaflow~ai-brand-monitoring/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-inovaflow-ai-brand-monitoring",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/inovaflow~ai-brand-monitoring/runs": {
            "post": {
                "operationId": "runs-sync-inovaflow-ai-brand-monitoring",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/inovaflow~ai-brand-monitoring/run-sync": {
            "post": {
                "operationId": "run-sync-inovaflow-ai-brand-monitoring",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "prompts": {
                        "title": "Questions to track (the AI search prompts your customers ask)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "The questions your customers ask AI engines, one per line. Each is checked across every selected engine and country, and the actor notes whether your brand appears, who else does, and who gets cited.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "brand": {
                        "title": "Your brand name",
                        "type": "string",
                        "description": "Your brand name — matched whole-word, case-insensitive in every AI answer. Leave blank and the brand-mention columns stay empty.",
                        "default": ""
                    },
                    "brandAliases": {
                        "title": "Other names for your brand",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Other spellings of your brand — product names, abbreviations, former names. Each alias counts as a brand mention. Leave empty to match the main brand name only.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "brandDomains": {
                        "title": "Your website domains",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "The domains you own, so the actor can detect when an answer cites you (not just names you). Leave empty and citation tracking is skipped.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "competitors": {
                        "title": "Competitors to watch (share of voice in AI answers)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Rival brand names to track alongside yours, one per line. Drives share-of-voice comparisons and selects the competitor for the deep-dive. Leave empty to monitor your brand alone.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "country": {
                        "title": "Countries to check from",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which countries' AI answers to check. Each country runs the questions in its regional language and locale, so you see what local customers see. Default: United States.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "us",
                                "uk",
                                "ca",
                                "au",
                                "de",
                                "fr",
                                "es",
                                "it",
                                "nl",
                                "cz",
                                "sk",
                                "pl",
                                "jp",
                                "br",
                                "mx",
                                "in"
                            ],
                            "enumTitles": [
                                "United States",
                                "United Kingdom",
                                "Canada",
                                "Australia",
                                "Germany",
                                "France",
                                "Spain",
                                "Italy",
                                "Netherlands",
                                "Czechia",
                                "Slovakia",
                                "Poland",
                                "Japan",
                                "Brazil",
                                "Mexico",
                                "India"
                            ]
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "surfaces": {
                        "title": "AI engines to check",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which AI engines to check each question on. Each engine adds one check per question per country. Default: Google AI Overview + Perplexity.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "aio",
                                "ai_mode",
                                "gemini",
                                "perplexity",
                                "chatgpt",
                                "copilot"
                            ],
                            "enumTitles": [
                                "Google AI Overview",
                                "Google AI Mode",
                                "Google Gemini",
                                "Perplexity",
                                "ChatGPT",
                                "Microsoft Copilot"
                            ]
                        },
                        "default": [
                            "aio",
                            "perplexity"
                        ]
                    },
                    "slackConnector": {
                        "title": "Slack account (optional)",
                        "type": "string",
                        "description": "Connect Slack to receive a short daily summary — visibility score, trend, wins and losses, and competitor moves — in your team's channel. Leave unconnected and results are saved to the dataset only."
                    },
                    "slackChannel": {
                        "title": "Slack channel",
                        "type": "string",
                        "description": "The Slack channel to post the summary in — channel name (#ai-visibility) or channel ID (C0123ABCD). Only used when a Slack connector is set."
                    },
                    "notionConnector": {
                        "title": "Notion account",
                        "type": "string",
                        "description": "Connect Notion to get a dated summary page each run with score trends, per-engine breakdowns, and competitor teardowns. Leave unconnected and results are saved to the dataset only."
                    },
                    "notionParentPage": {
                        "title": "Notion page for the dated reports (link or ID)",
                        "type": "string",
                        "description": "The Notion page where dated run-summary pages are created inside. Paste the full page link or just its 32-character ID. Only used when a Notion connector is set."
                    },
                    "notionResultsPage": {
                        "title": "Notion results table (link or ID, optional)",
                        "type": "string",
                        "description": "A Notion page or database that accumulates one row per question × engine × country on every run. Paste a blank page and the table is built on first run; paste an existing database to append directly. Leave empty to skip the growing table."
                    },
                    "watchCompetitors": {
                        "title": "Competitor deep-dive — read the page that beat you",
                        "type": "boolean",
                        "description": "Enables the competitor deep-dive: one competitor per run is crawled, analysed, and turned into copy-paste fixes for your losing questions. Rotates competitors so the same one isn't re-analysed within 7 days. Off by default; adds a small extra cost.",
                        "default": false
                    },
                    "competitorDomains": {
                        "title": "Competitor websites (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Competitor websites used when the AI answers don't already cite a URL, so the deep-dive can crawl the right page. Leave empty to use only URLs the AI answers provide. Only used when the deep-dive is on.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "deepDivePrompt": {
                        "title": "Custom write-up prompt (optional)",
                        "type": "string",
                        "description": "Custom instructions for the competitor write-up. Leave blank to use the built-in AEO analyst prompt. Only used when the deep-dive is on."
                    },
                    "deepDiveModel": {
                        "title": "Write-up model",
                        "enum": [
                            "haiku",
                            "sonnet"
                        ],
                        "type": "string",
                        "description": "Which Claude model writes the deep-dive analysis. Haiku is fast and cheap (default); Sonnet is more thorough but costs more. Only used when the deep-dive is on.",
                        "default": "haiku"
                    },
                    "anthropicApiKey": {
                        "title": "Your Anthropic API key (optional)",
                        "type": "string",
                        "description": "Your Anthropic API key (sk-ant-…). With it, the AI write-up charges go to your Anthropic account and the actor doesn't bill the AI step. Leave blank to use the built-in AI for a small flat charge. Only used when the deep-dive is on."
                    },
                    "apifyMcpConnector": {
                        "title": "Run the scrapers on a specific Apify account (MCP connector)",
                        "type": "string",
                        "description": "An Apify MCP connector for a different Apify account, so the scraper and crawler runs bill to that account instead of the one running this actor. Leave unconnected to use the current account automatically. Server URL: https://mcp.apify.com/?tools=actors."
                    },
                    "apifyToken": {
                        "title": "…or paste an Apify API token",
                        "type": "string",
                        "description": "An API token from a different Apify account — same purpose as the connector above, without the OAuth flow. Leave blank to use the account running this actor."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
