# AI Search Visibility Tracker: AI Overviews & AI Mode Citations (`jaybird/ai-search-visibility-tracker`) Actor

\[$0.008/check] Does Google's AI cite your brand? Track queries across Google AI Overviews & AI Mode: full AI answers, cited sources with positions, brand & competitor citation/mention detection, and share of voice. Generative engine optimization (GEO/AEO) monitoring as clean JSON.

- **URL**: https://apify.com/jaybird/ai-search-visibility-tracker.md
- **Developed by:** [Jaybird Technologies](https://apify.com/jaybird) (community)
- **Categories:** AI, Agents, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 ai overview checks

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/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

## AI Search Visibility Tracker — Google AI Overviews & AI Mode Brand Citations

**Does Google's AI cite your brand?** For every query you track, this Actor captures the Google **AI Overview** and **AI Mode** answer, extracts every **cited source with its position**, and — when you add your brand — tells you whether you were **cited**, **mentioned**, and what your **share of voice** is against competitors. Clean JSON, ready for dashboards, schedules, and AI agents.

🔍 AI Overview scraper · 🤖 AI Mode scraper · 🏷️ Brand & competitor citation detection · 📊 Share of voice + run summary report · 🌍 Geo-localized (any country/language/device) · 💰 From $0.008/check

```json
{
    "query": "best crm for small business",
    "engine": "aiOverview",
    "status": "ok",
    "aiAnswerPresent": true,
    "answerText": "The best CRM for a small business depends on your primary focus…",
    "sources": [
        { "position": 1, "url": "https://www.example.com/best-crm", "domain": "example.com", "title": "Best CRM Software Compared" },
        { "position": 2, "url": "https://www.hubspot.com/products/crm", "domain": "hubspot.com", "title": "HubSpot CRM" }
    ],
    "brandMentioned": true,
    "brandCited": true,
    "brandCitationPositions": [2],
    "competitorMatrix": {
        "pipedrive.com": { "cited": true, "mentioned": true, "positions": [4] },
        "zoho.com": { "cited": false, "mentioned": false, "positions": [] }
    },
    "shareOfVoice": 0.5,
    "country": "us",
    "language": "en",
    "device": "desktop",
    "scrapedAt": "2026-07-02T12:00:00.000Z"
}
````

### What does AI Search Visibility Tracker do?

Google now answers a large share of searches directly — with an **AI Overview** above the classic results, and with **AI Mode**, its fully conversational search surface. If the AI's answer recommends your competitors and never cites you, that traffic is gone before anyone sees a blue link. This is what **generative engine optimization (GEO/AEO)** teams and agencies are hired to fix — and you can't fix what you don't measure.

For each query × engine pair, the tracker:

1. Runs the query on Google, geo-pinned to your chosen country — AI Overviews over a dedicated captcha-free SERP route, AI Mode in a real hardened browser
2. Captures the AI Overview or AI Mode answer — full text and every cited source with its position
3. Detects whether an AI answer was shown at all (`aiAnswerPresent` — AI Overviews don't trigger on every query, and knowing that *is* the data point)
4. Matches your brand and competitors against citations (by domain, subdomains included) and against the answer text (by name and aliases)
5. Computes **share of voice**: your citations ÷ (your citations + competitor citations)

### Why use this tracker?

- **Built for reliability.** This category is young and shaky — the most-used tracker holds a 1★ rating and another entrant completes fewer than 1 in 5 runs. This Actor routes each surface through the path that's most reliable for it: AI Overviews travel a dedicated captcha-free SERP route (no browser to block), and AI Mode runs in a hardened real browser with warmed sessions, escalating proxies, and consent handling. No login, no API keys, no bring-your-own-SERP-API.
- **Tracker, not just a scraper.** Raw AI Overview extraction exists elsewhere. The value here is the packaging: brand-match detection, competitor matrix, citation positions, and share of voice per query — the numbers a GEO report is actually made of.
- **Deferred generation handled.** Google often generates AI Overviews asynchronously after the page loads. Checks wait for generation to resolve and retry when it doesn't — a check never silently reports "no AI answer" because Google was slow. If it can't be resolved after retries, the row is marked `failed` and **not charged**.
- **Real localization.** `countryCode` isn't just passed through — checks run from a residential exit IP in that country with matching `gl`, `hl`, and `Accept-Language`, so an agency in Berlin tracking `de` results sees what German users see.
- **Priced to run daily.** AI Overview checks are $8 per 1,000 — versus $10–15 per 1,000 at the closest alternatives. AI Mode checks are $0.06 — 70% below Apify's own Google Search Scraper ($0.20/result) and 25–33% below the $0.08–0.09 AI visibility trackers.
- **A summary that answers the question.** Besides per-check rows, every run writes a `SUMMARY` report: brand citation rate, average share of voice, the **top domains Google's AI cites in your niche**, and the exact queries where your brand is missing — your GEO to-do list, one JSON object.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query`, `engine` | The check: one row per query per surface (`aiOverview`, `aiMode`) |
| `status` | `ok`, `no_ai_answer`, or `failed` (failed rows are never charged) |
| `aiAnswerPresent` | Whether Google showed an AI answer for this query |
| `answerText` / `answerHtml` | Full AI answer text (HTML optional via input toggle) |
| `sources[]` | Every cited source: `position`, `url`, `domain`, `title` |
| `brandMentioned` / `brandCited` | Name/alias found in answer text; domain found in citations |
| `brandCitationPositions[]` | Where in the citation list your brand appears |
| `competitorMatrix` | Per-competitor `cited` / `mentioned` / `positions` |
| `shareOfVoice` | Brand citations ÷ (brand + competitor citations), 0–1 |
| `country`, `language`, `device`, `scrapedAt` | Check context for time-series analysis |

### How to track your AI search visibility

1. Enter your **queries** (the searches your customers make, not your brand name — "best crm for small business", not "HubSpot")
2. Pick the **engines** — AI Overview, AI Mode, or both
3. Optionally add **brandName**, **brandDomain**, **brandAliases**, and **competitorDomains** to unlock brand detection and share of voice
4. Set **countryCode** / **languageCode** / **device** for the market you care about
5. Run it — or better, **schedule it** (see below)

#### Track daily (recommended)

Visibility in AI answers moves constantly — Google regenerates answers, citations rotate, and competitors publish. Create a [Schedule](https://docs.apify.com/platform/schedules) in Apify Console (e.g. every morning at 6:00), point it at this Actor with your saved input, and you get a dataset per day. Feed those into Looker Studio, Google Sheets, or your warehouse via [integrations](https://apify.com/integrations) and you have a longitudinal GEO dashboard: share of voice over time, per query, per market.

#### Ask it from an AI agent (MCP)

"Is my brand cited by Google's AI for this query?" is a question AI agents ask naturally. This Actor is exposed through Apify's [MCP server](https://mcp.apify.com), so you can wire it into Claude, or any MCP-capable agent, and get structured visibility answers inside the conversation.

### How much will it cost?

Pricing is pay-per-event — you pay per check, not per compute-hour:

| Event | Price | When it's charged |
| --- | --- | --- |
| AI Overview check | **$0.008** | Per completed check, whether or not an AI answer was present |
| AI Mode check | **$0.06** | Per completed check — AI Mode answers are JS-streamed and need a real browser with premium proxies, a much heavier retrieval |
| Brand match detected | **$0.002** | Bonus, only when your brand domain matches a citation |
| Actor start | $0.00005 | Once per run |

**Examples:** a one-off 1,000-query AI Overview audit: **$8**. 50 queries tracked daily on AI Overviews: **$0.40/day** (~$12/month). Add AI Mode for the full two-surface feed: **$3.40/day**.

**How that compares:** Apify's own Google Search Scraper charges **$0.20 per AI Mode result** — we're 70% below it. AI visibility trackers on the Store run **$0.08–0.09 per check** on any surface — our AI Overview checks are a tenth of that, and AI Mode checks 25–33% less.

**Why checks without an AI answer are still charged:** the Actor does the same full retrieval work to *verify* no AI Overview triggered — absence is only ever reported from a verifiably healthy results page — and for a tracker, "your query stopped triggering an AI Overview" is exactly the alert you want. What's never charged: rows with `status: "failed"`.

Subscription tiers (Bronze → Diamond) get automatic per-event discounts of up to ~10%.

### Input

Minimal input:

```json
{
    "queries": ["best crm for small business", "crm with free tier"]
}
```

Full brand tracking:

```json
{
    "queries": ["best crm for small business", "best sales pipeline software"],
    "engines": ["aiOverview", "aiMode"],
    "brandName": "HubSpot",
    "brandDomain": "hubspot.com",
    "brandAliases": ["HubSpot CRM"],
    "competitorDomains": ["pipedrive.com", "zoho.com", "salesforce.com"],
    "countryCode": "us",
    "languageCode": "en",
    "device": "desktop"
}
```

### Output

One dataset item per query × engine (see the example at the top). Items with `status: "no_ai_answer"` have `aiAnswerPresent: false` and empty `sources` — that's a real, billable finding, not an error. Items with `status: "failed"` include an `errorMessage` and are not charged.

#### Run summary report

Every run also writes a `SUMMARY` record to the key-value store (linked from the run's Output tab) that answers the visibility question directly — no aggregation needed:

```json
{
    "totalChecks": 40,
    "checksWithAiAnswer": 31,
    "byEngine": { "aiOverview": { "checks": 20, "withAiAnswer": 13, "withoutAiAnswer": 7 }, "aiMode": { "checks": 20, "withAiAnswer": 18, "withoutAiAnswer": 2 } },
    "brand": {
        "name": "HubSpot",
        "citationRate": 0.45,
        "averageShareOfVoice": 0.38,
        "answersWithoutBrandCitation": [ { "query": "best free crm", "engine": "aiOverview" } ]
    },
    "topCitedDomains": [
        { "domain": "salesforce.com", "citations": 14, "appearsInChecks": 9 },
        { "domain": "reddit.com", "citations": 11, "appearsInChecks": 8 }
    ]
}
```

`topCitedDomains` is competitive intel on its own: the domains Google's AI trusts in your niche — the sites to study, pitch, or get cited by. `answersWithoutBrandCitation` is your GEO work queue.

### Tips

- **Mix query types.** Informational queries ("how to…", "what is…", "best…") trigger AI Overviews far more often than navigational ones. Tracking a few non-triggering queries is useful — you'll see when Google *starts* answering them.
- **Aliases matter for mentions.** The AI often writes "HubSpot's free CRM" rather than your exact product name. Add the variants people actually say.
- **Competitor domains drive share of voice.** Without `competitorDomains`, `shareOfVoice` stays null — the metric is defined against a competitive set.
- **AI Mode nearly always answers; AI Overviews don't.** Expect `aiAnswerPresent: false` mostly on the `aiOverview` engine — that asymmetry is itself insight.
- **Different markets, different runs.** One run = one country/language/device combination, so each dataset is a clean cohort. Schedule one run per market.

### Integrations

Works with all [Apify integrations](https://apify.com/integrations): export to Google Sheets, BigQuery, Airbyte, Make, Zapier, n8n, or fetch the dataset via the [Apify API](https://docs.apify.com/api/v2) (`…/datasets/{id}/items?format=json`). Webhooks can notify Slack when a run finishes — or when your share of voice moves.

### FAQ

#### Which AI search engines are supported?

Google AI Overviews and Google AI Mode. The `engines` input and output schema are designed so ChatGPT Search and Perplexity can be added without breaking changes — they're on the roadmap.

#### Why does my query show `aiAnswerPresent: false`?

Google doesn't generate an AI Overview for every query — trigger rates vary by query type, country, and device, and Google adjusts them constantly. The check verified that the results page rendered fine and no AI answer was shown. That verification costs the same retrieval work as a capture, which is why it's a billable check (documented above — no surprises).

#### How is `shareOfVoice` calculated?

`brand citations ÷ (brand citations + competitor citations)` within one AI answer, using citation counts by domain (subdomains included). It's `null` when you haven't configured a brand domain and competitors, or when neither side is cited; it's `0` when competitors are cited and you aren't — which is the number that should worry you.

#### Does it handle Google's deferred AI Overview generation?

Yes. When Google renders the AI Overview container but generates the answer asynchronously, the check waits for generation to settle and retries on timeout. It never reports `aiAnswerPresent: false` just because generation was slow — that distinction is load-bearing for a tracker.

#### Can I use this as a plain Google AI Overview scraper or AI Mode scraper?

Yes — leave the brand fields empty and it's a straight scraper: full answer text (`answerText`, optional `answerHtml`) plus every cited source with position, for either surface. The brand/competitor analytics only activate when you configure them.

#### How do I export results to Excel, CSV, or Google Sheets?

The dataset downloads in JSON, CSV, Excel, XML, or HTML straight from the run's Storage tab (or via API with `?format=csv`). For recurring exports, the [Google Sheets integration](https://apify.com/integrations) appends each scheduled run to a sheet automatically.

#### Can an AI agent read the results without parsing every row?

Yes — the `SUMMARY` key-value record is designed for exactly that: one JSON object with citation rate, average share of voice, top cited domains, and the queries missing a brand citation. Agents connected through [Apify's MCP server](https://mcp.apify.com) can call the Actor and read the summary in one round trip.

#### Is this legal?

The Actor scrapes only publicly available search results, operates no accounts, and stores no personal data. You're responsible for using the extracted data in compliance with applicable laws and Google's terms in your jurisdiction.

#### Can I run it for markets outside the US?

Yes — set `countryCode` and `languageCode`. Checks are geo-pinned to the target country (country-routed SERP requests for AI Overviews, in-country residential exit IPs for AI Mode) with matching search parameters and headers, so localized AI answers are the real thing, not a US proxy of them.

***

*Keywords: AI visibility, AI overview scraper, AI overview tracking, AI mode scraper, generative engine optimization, GEO, AEO, LLM SEO, brand citations, AI search monitoring, share of voice, answer engine optimization, ChatGPT SEO, brand visibility in AI search.*

# Actor input Schema

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

Search queries to check, one per line. Use the searches your customers make ("best crm for small business"), not your brand name — the tracker then tells you whether the AI's answer cites you. Each query is checked once per selected engine.

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

Which Google AI surfaces to capture for every query. Each query × engine pair is one billable check: AI Overview checks bill at the base rate ($0.008), AI Mode checks are a premium surface ($0.06 — JS-streamed answers need a real browser and premium proxies). Cost-conscious tracking: start with aiOverview only. ChatGPT Search and Perplexity are planned for a future release.

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

Your brand's name as it would appear in an AI answer (e.g. "HubSpot"). Enables brand mention detection.

## `brandDomain` (type: `string`):

Your brand's domain (e.g. "hubspot.com"). Subdomains count as matches. Enables citation detection and share of voice.

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

Alternative names that also count as a brand mention (e.g. "HubSpot CRM", "HubSpot Marketing Hub").

## `competitorDomains` (type: `array`):

Competitor domains to compare against (e.g. "pipedrive.com"). Each result includes a per-competitor cited/mentioned matrix, and share of voice is computed as brand citations ÷ (brand + competitor citations).

## `countryCode` (type: `string`):

Two-letter ISO 3166-1 country code (e.g. "us", "gb", "de"). Applied via the gl parameter AND a residential proxy exit in that country — results reflect what real users there see.

## `languageCode` (type: `string`):

ISO 639-1 language code (e.g. "en", "de", "pt-br"). Applied via the hl parameter and the Accept-Language header.

## `device` (type: `string`):

Emulated device class. AI Overview trigger rates differ between desktop and mobile.

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

Hard cap on how many queries are processed in one run, protecting against accidentally large inputs. Maximum 1000.

## `includeAnswerHtml` (type: `boolean`):

Also return the raw HTML of the AI answer block (answerHtml). Increases dataset size considerably.

## Actor input object example

```json
{
  "queries": [
    "best crm for small business",
    "what is generative engine optimization"
  ],
  "engines": [
    "aiOverview",
    "aiMode"
  ],
  "countryCode": "us",
  "languageCode": "en",
  "device": "desktop",
  "maxQueries": 100,
  "includeAnswerHtml": false
}
```

# Actor output Schema

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

One-object run report: brand citation rate, average share of voice, top cited domains, and the queries where your brand is missing

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

Dataset containing every per-query visibility check

# 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 = {
    "queries": [
        "best crm for small business",
        "what is generative engine optimization"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jaybird/ai-search-visibility-tracker").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 = { "queries": [
        "best crm for small business",
        "what is generative engine optimization",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jaybird/ai-search-visibility-tracker").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 '{
  "queries": [
    "best crm for small business",
    "what is generative engine optimization"
  ]
}' |
apify call jaybird/ai-search-visibility-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Search Visibility Tracker: AI Overviews & AI Mode Citations",
        "description": "[$0.008/check] Does Google's AI cite your brand? Track queries across Google AI Overviews & AI Mode: full AI answers, cited sources with positions, brand & competitor citation/mention detection, and share of voice. Generative engine optimization (GEO/AEO) monitoring as clean JSON.",
        "version": "0.1",
        "x-build-id": "PFhcyan4O0JcsL4az"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jaybird~ai-search-visibility-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jaybird-ai-search-visibility-tracker",
                "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/jaybird~ai-search-visibility-tracker/runs": {
            "post": {
                "operationId": "runs-sync-jaybird-ai-search-visibility-tracker",
                "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/jaybird~ai-search-visibility-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-jaybird-ai-search-visibility-tracker",
                "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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Search queries to check, one per line. Use the searches your customers make (\"best crm for small business\"), not your brand name — the tracker then tells you whether the AI's answer cites you. Each query is checked once per selected engine.",
                        "default": [
                            "what is generative engine optimization"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "engines": {
                        "title": "AI surfaces to check",
                        "type": "array",
                        "description": "Which Google AI surfaces to capture for every query. Each query × engine pair is one billable check: AI Overview checks bill at the base rate ($0.008), AI Mode checks are a premium surface ($0.06 — JS-streamed answers need a real browser and premium proxies). Cost-conscious tracking: start with aiOverview only. ChatGPT Search and Perplexity are planned for a future release.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "aiOverview",
                                "aiMode"
                            ],
                            "enumTitles": [
                                "Google AI Overview",
                                "Google AI Mode"
                            ]
                        },
                        "default": [
                            "aiOverview",
                            "aiMode"
                        ]
                    },
                    "brandName": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "Your brand's name as it would appear in an AI answer (e.g. \"HubSpot\"). Enables brand mention detection."
                    },
                    "brandDomain": {
                        "title": "Brand domain",
                        "type": "string",
                        "description": "Your brand's domain (e.g. \"hubspot.com\"). Subdomains count as matches. Enables citation detection and share of voice."
                    },
                    "brandAliases": {
                        "title": "Brand aliases",
                        "type": "array",
                        "description": "Alternative names that also count as a brand mention (e.g. \"HubSpot CRM\", \"HubSpot Marketing Hub\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitorDomains": {
                        "title": "Competitor domains",
                        "type": "array",
                        "description": "Competitor domains to compare against (e.g. \"pipedrive.com\"). Each result includes a per-competitor cited/mentioned matrix, and share of voice is computed as brand citations ÷ (brand + competitor citations).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryCode": {
                        "title": "Country",
                        "pattern": "^[a-zA-Z]{2}$",
                        "type": "string",
                        "description": "Two-letter ISO 3166-1 country code (e.g. \"us\", \"gb\", \"de\"). Applied via the gl parameter AND a residential proxy exit in that country — results reflect what real users there see.",
                        "default": "us"
                    },
                    "languageCode": {
                        "title": "Language",
                        "pattern": "^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})?$",
                        "type": "string",
                        "description": "ISO 639-1 language code (e.g. \"en\", \"de\", \"pt-br\"). Applied via the hl parameter and the Accept-Language header.",
                        "default": "en"
                    },
                    "device": {
                        "title": "Device",
                        "enum": [
                            "desktop",
                            "mobile"
                        ],
                        "type": "string",
                        "description": "Emulated device class. AI Overview trigger rates differ between desktop and mobile.",
                        "default": "desktop"
                    },
                    "maxQueries": {
                        "title": "Max queries (safety cap)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on how many queries are processed in one run, protecting against accidentally large inputs. Maximum 1000.",
                        "default": 100
                    },
                    "includeAnswerHtml": {
                        "title": "Include answer HTML",
                        "type": "boolean",
                        "description": "Also return the raw HTML of the AI answer block (answerHtml). Increases dataset size considerably.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```