# AI Search Visibility Tracker — ChatGPT, Perplexity, Gemini (`highbrow_fame/ai-search-visibility-tracker`) Actor

Track brand citations in ChatGPT, Perplexity, Gemini, Google AI Overviews. Multilingual (24 languages incl. Hungarian, German, French, Polish, Czech). Bring-your-own-key — start FREE with Gemini's free tier. Daily diff. Pay-per-query, no monthly minimums. Cheapest GEO/AEO tracker on Apify.

- **URL**: https://apify.com/highbrow\_fame/ai-search-visibility-tracker.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 — ChatGPT, Perplexity, Gemini, Google AIO

Track if your brand or domain gets cited in **ChatGPT, Perplexity, Gemini, and Google AI Overviews** — across 24 languages, with daily diff alerts and a stability score across multiple samples. **Bring-your-own-key** model — start at $0/month with Gemini's free tier.

![Multilingual edge — same intent in 4 languages, real cloud run](https://api.apify.com/v2/key-value-stores/DxruSC8pQlvOevATQ/records/multilingual-edge.png)
<sub>*Live demo: the same "best CRM for small business" intent run in EN / DE / FR / HU. German prompt surfaces 5/7 .de/.at/.ch sources, Hungarian 3/7 .hu sources — the multilingual edge incumbents like Otterly and Profound miss.*</sub>

> ⭐ **If this actor saves you time, please rate it on Apify.** Reviews raise its Store visibility and help the next person find it.

### Why this actor

The Generative Engine Optimization (GEO) tracker market in 2026 is dominated by enterprise tools — Otterly ($29–489/mo), Profound ($99–2k+/mo, no free trial), Peec AI (€89–199/mo), Semrush AI Toolkit ($99–549/mo), Ahrefs Brand Radar ($328+/mo). They share three blind spots:

1. **Pricing locks out indie SEOs and small agencies** — the cheapest viable tier is $29/mo for 15 prompts.
2. **Multilingual coverage is shallow** — Semrush admits "US English only," Profound and Otterly are English-first.
3. **No bring-your-own-key option** — you pay them, they pay the LLM vendors, and you can't see the underlying call.

This actor flips all three:

- **$0/month entry point** — supply your own free Gemini API key (250 queries/day on the free tier) and run end-to-end at zero marginal cost.
- **24 languages** — Hungarian, German, French, Spanish, Italian, Polish, Czech, Romanian, Turkish, Japanese, Korean, Russian, Ukrainian, and 11 more.
- **BYOK transparency** — your OpenAI / Perplexity / Anthropic keys, your bills, your data. The actor never proxies your traffic through our account.

### What it does

Given a list of queries (e.g. *"best CRM for small business"*, *"top fogorvosok Budapesten"*) and one or more domains you care about, the actor:

1. Fans out each query to every selected engine — Gemini, ChatGPT (gpt-4o-mini-search-preview), Perplexity Sonar, Anthropic Claude with web_search.
2. Captures the answer text **plus** structured citations (URL + title + snippet).
3. Detects whether each tracked domain appears — via citation OR via brand mention in the answer text.
4. Computes citation share-of-voice across your domains and competitor domains.
5. Optionally runs each query N times and reports a **stability score** (how consistently each source is cited — useful for filtering one-shot hallucinations).
6. Optionally **diffs against a previous run** and surfaces gained/lost citations per query (delta mode).

### Quick start ($0)

1. Get a free Gemini key: <https://aistudio.google.com/apikey> (Google account, no credit card).
2. Run the actor with this minimal input:

```json
{
    "queries": ["best CRM for small business", "top project management tools"],
    "brandDomains": ["yourcompany.com"],
    "engines": ["gemini"],
    "geminiApiKey": "AIza..."
}
````

That's it. Free tier covers 250 queries/day on Gemini 2.5 Flash — enough to track ~250 prompts daily for $0.

### Going further (BYOK paid engines)

Add any combination of these to the input:

| Engine | Where to get a key | Approx cost / query |
|---|---|---|
| OpenAI / ChatGPT | <https://platform.openai.com/api-keys> | ~$0.025 |
| Perplexity Sonar | <https://www.perplexity.ai/settings/api> | ~$0.005–0.015 |
| Anthropic Claude | <https://console.anthropic.com/> | ~$0.01–0.02 |

A single query across **all four** engines costs you ~$0.05–0.08 in third-party API fees. You pay them directly.

### Output

![A single citation record — real cloud run output](https://api.apify.com/v2/key-value-stores/DxruSC8pQlvOevATQ/records/citation-detail.png) <sub>*Real run sIXsrVM5qKzAHY8HP — 1 query, 22 sec, all 3 tracked brands cited, $0 to the user (free Gemini key).*</sub>

Each engine call writes one record to the dataset:

```json
{
    "type": "citation",
    "engine": "gemini",
    "model": "gemini-2.5-flash",
    "query": "best CRM for small business",
    "language": "en",
    "answerText": "...",
    "citationCount": 7,
    "citations": [
        {"url": "https://...", "host": "hubspot.com", "registrable": "hubspot.com", "title": "..."}
    ],
    "brandMatches": {
        "yourcompany.com": {"cited": true, "viaCitation": true, "viaText": false, "matchedUrls": ["https://yourcompany.com/pricing"]}
    },
    "competitorMatches": {
        "competitor.com": {"cited": false, "viaCitation": false, "viaText": false, "matchedUrls": []}
    },
    "citationShare": {
        "yourcompany.com": {"hits": 1, "sharePct": 14.3},
        "competitor.com": {"hits": 0, "sharePct": 0}
    },
    "latencyMs": 2104
}
```

When `samplesPerQuery > 1` the actor also writes one `stability` record per (query, engine):

```json
{
    "type": "stability",
    "engine": "gemini",
    "query": "best CRM for small business",
    "samples": 3,
    "stability": {
        "hubspot.com":   {"occurrences": 3, "samples": 3, "stability": 1.0},
        "salesforce.com":{"occurrences": 2, "samples": 3, "stability": 0.67},
        "pipedrive.com": {"occurrences": 1, "samples": 3, "stability": 0.33}
    }
}
```

When `previousRunDatasetId` is set, the actor writes a `delta` record showing per-query gained/lost citations versus the prior run.

A final `summary` record closes every run with stats and finishedAt.

### Recipes

#### Daily monitoring with weekly diff

Schedule the actor daily. Use `Apify schedules` to run it every morning. Pass last week's `defaultDatasetId` as `previousRunDatasetId` to get a weekly diff alongside today's snapshot.

#### Multilingual brand share-of-voice

Set `language: "hu"` (or `de`, `fr`, …) and Gemini will reply in that language and prefer same-language sources. Especially useful for European B2B SaaS, agencies running multi-country pipelines, or local SEO consultants.

#### Stability filter for hallucinations

Set `samplesPerQuery: 3` and ignore citations whose `stability < 0.5` — these are likely one-shot hallucinations rather than reliable AI rankings.

### Local development

```bash
## install deps
npm install

## unit tests on pure-JS utils (no API keys, no network)
npm test

## end-to-end smoke test against real engines
GEMINI_API_KEY=AIza... npm run smoke
```

`scripts/test-utils.js` validates the citation parser, brand-detector, share-of-voice math, stability computation and delta diff with hand-crafted fixtures — runs in under 100ms with no network.

`scripts/smoke.js` calls each engine for which a key is set and prints a compact citation report. Useful for verifying the adapters still work after API surface changes.

### Architecture

```
.
├── .actor/                 Apify actor metadata (actor.json, input_schema.json)
├── src/
│   ├── main.js             entry point — reads input, fans out, writes dataset
│   ├── utils.js            pure helpers (no I/O): canonicalHost, citation parsing, share-of-voice, delta diff
│   └── engines/
│       ├── gemini.js       Gemini 2.5 Flash + google_search grounding (free tier)
│       ├── openai.js       Responses API + web_search_preview tool
│       ├── perplexity.js   Chat completions + sonar model
│       └── anthropic.js    Messages API + web_search tool
├── scripts/
│   ├── test-utils.js       offline assertions for utils.js
│   └── smoke.js            live-network smoke test for the engine adapters
└── INPUT_SCHEMA.json       legacy top-level schema (also at .actor/input_schema.json)
```

The four engine adapters share the same return shape so `main.js` doesn't care which engine produced a record. Adding a new engine = one file under `src/engines/` plus one entry in `engineAdapters` in `main.js`.

### Limitations / honest disclosure

- **AI answers are non-deterministic.** A single sample of a single query can miss citations that appear most of the time — that's why we expose `samplesPerQuery` and a stability score. Don't make business decisions on a `samplesPerQuery: 1` snapshot; use 3+ for monitoring you trust.
- **Free Gemini tier has rate limits.** 10 requests/minute, 250 requests/day on `gemini-2.5-flash`. The actor's `maxConcurrency` defaults to 4 to stay well under the per-minute cap. For higher volume, upgrade to Gemini's paid tier (still cheaper than any GEO SaaS).
- **Google AI Overviews are not yet covered** in this v0.1 build. Gemini grounded answers are a strong proxy (same underlying LLM and search index) but the literal SERP AIO block is a separate feature. v0.2 will add it via Apify's `apify/google-search-scraper` actor.
- **Engines may shift their APIs.** OpenAI's `web_search_preview` and Anthropic's `web_search_20250305` are explicitly versioned tools. We pin sensible defaults; if a vendor breaks compatibility, the relevant adapter file is the only file that needs to change.

### Roadmap

- v0.2 — Google AI Overview capture via the existing `apify/google-search-scraper` actor (chained, BYOK Apify proxy).
- v0.3 — Slack / webhook alerting on citation gains/losses.
- v0.4 — White-label CSV export with agency branding.
- v0.5 — Public weekly leaderboards (e.g. "Top 50 brands cited in ChatGPT for project management software, EN/DE/HU") generated from aggregated runs of consenting users — distribution / SEO play.

### License

ISC.

# Actor input Schema

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

List of search queries / prompts you want to monitor. Examples: 'best CRM for small business', 'top dental clinics in Budapest', 'fastest electric SUV 2026'. Each query is run on every selected engine.

## `brandDomains` (type: `array`):

Domains you own and want to track. The actor reports whether each engine cites these domains for each query. Use bare hostnames, e.g. 'example.com' (no https://, no www.).

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

Optional. Domains of your competitors. The actor reports head-to-head citation share for each query.

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

Which AI engines to query. Gemini has a free tier — you can start at $0 with just a Google account. The others require their own paid API keys (BYOK).

## `geminiApiKey` (type: `string`):

Get a free key at https://aistudio.google.com/apikey — Google's free tier covers up to 250 queries/day. Used for Gemini engine and as the default citation parser.

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

Optional. Get one at https://platform.openai.com/api-keys. Used for ChatGPT engine via the gpt-4o-mini-search-preview model. ~$0.025 per query.

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

Optional. Get one at https://www.perplexity.ai/settings/api. Used for Perplexity engine via the 'sonar' model. ~$0.005-0.015 per query.

## `anthropicApiKey` (type: `string`):

Optional. Get one at https://console.anthropic.com/. Used for Claude engine with the web\_search tool. ~$0.01 per search + tokens.

## `geminiModel` (type: `string`):

Optional. Default: gemini-2.5-flash (free tier). Try gemini-2.5-flash-lite for higher daily quota, or gemini-2.5-pro / gemini-3-flash-preview if you have billing enabled.

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

Optional. Default: gpt-4o-mini-search-preview.

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

Optional. Default: sonar. Try sonar-pro for richer citations.

## `anthropicModel` (type: `string`):

Optional. Default: claude-haiku-4-5-20251001.

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

Language hint for the engines. Influences the language of answers and which sources get cited. Multilingual coverage is our differentiator vs Otterly/Profound/Semrush which are mostly US-English-only.

## `samplesPerQuery` (type: `integer`):

How many times each query is run on each engine. AI answers are non-deterministic — running 3 samples gives a stability score showing how consistently a source is cited. 1 = single shot (cheapest), 3 = recommended, 5 = high-confidence.

## `previousRunDatasetId` (type: `string`):

Optional. Provide a dataset ID from a previous run. The actor will compute citation gains/losses week-over-week and surface the diff. Perfect for daily/weekly scheduled tracking.

## `maxConcurrency` (type: `integer`):

How many engine requests to run in parallel. Lower if you hit rate limits on the free Gemini tier (10 req/min on Gemini 2.5 Flash free).

## Actor input object example

```json
{
  "queries": [
    "best CRM for small business",
    "top project management tools for remote teams"
  ],
  "brandDomains": [
    "example.com"
  ],
  "competitorDomains": [],
  "engines": [
    "gemini"
  ],
  "language": "en",
  "samplesPerQuery": 1,
  "maxConcurrency": 4
}
```

# 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",
        "top project management tools for remote teams"
    ],
    "brandDomains": [
        "example.com"
    ],
    "competitorDomains": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/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",
        "top project management tools for remote teams",
    ],
    "brandDomains": ["example.com"],
    "competitorDomains": [],
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/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",
    "top project management tools for remote teams"
  ],
  "brandDomains": [
    "example.com"
  ],
  "competitorDomains": []
}' |
apify call highbrow_fame/ai-search-visibility-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Search Visibility Tracker — ChatGPT, Perplexity, Gemini",
        "description": "Track brand citations in ChatGPT, Perplexity, Gemini, Google AI Overviews. Multilingual (24 languages incl. Hungarian, German, French, Polish, Czech). Bring-your-own-key — start FREE with Gemini's free tier. Daily diff. Pay-per-query, no monthly minimums. Cheapest GEO/AEO tracker on Apify.",
        "version": "0.1",
        "x-build-id": "9Mx0bfdPIYnkqczjE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/highbrow_fame~ai-search-visibility-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-highbrow_fame-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/highbrow_fame~ai-search-visibility-tracker/runs": {
            "post": {
                "operationId": "runs-sync-highbrow_fame-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/highbrow_fame~ai-search-visibility-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-highbrow_fame-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",
                    "brandDomains",
                    "engines"
                ],
                "properties": {
                    "queries": {
                        "title": "Queries to track",
                        "minItems": 1,
                        "maxItems": 200,
                        "type": "array",
                        "description": "List of search queries / prompts you want to monitor. Examples: 'best CRM for small business', 'top dental clinics in Budapest', 'fastest electric SUV 2026'. Each query is run on every selected engine.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandDomains": {
                        "title": "Your brand domain(s)",
                        "minItems": 1,
                        "type": "array",
                        "description": "Domains you own and want to track. The actor reports whether each engine cites these domains for each query. Use bare hostnames, e.g. 'example.com' (no https://, no www.).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitorDomains": {
                        "title": "Competitor domain(s)",
                        "type": "array",
                        "description": "Optional. Domains of your competitors. The actor reports head-to-head citation share for each query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "engines": {
                        "title": "Engines to query",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which AI engines to query. Gemini has a free tier — you can start at $0 with just a Google account. The others require their own paid API keys (BYOK).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "gemini",
                                "openai",
                                "perplexity",
                                "anthropic"
                            ],
                            "enumTitles": [
                                "Google Gemini (free tier available)",
                                "OpenAI / ChatGPT (BYOK)",
                                "Perplexity Sonar (BYOK)",
                                "Anthropic Claude (BYOK)"
                            ]
                        },
                        "default": [
                            "gemini"
                        ]
                    },
                    "geminiApiKey": {
                        "title": "Gemini API key (free tier OK)",
                        "type": "string",
                        "description": "Get a free key at https://aistudio.google.com/apikey — Google's free tier covers up to 250 queries/day. Used for Gemini engine and as the default citation parser."
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API key",
                        "type": "string",
                        "description": "Optional. Get one at https://platform.openai.com/api-keys. Used for ChatGPT engine via the gpt-4o-mini-search-preview model. ~$0.025 per query."
                    },
                    "perplexityApiKey": {
                        "title": "Perplexity API key",
                        "type": "string",
                        "description": "Optional. Get one at https://www.perplexity.ai/settings/api. Used for Perplexity engine via the 'sonar' model. ~$0.005-0.015 per query."
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API key",
                        "type": "string",
                        "description": "Optional. Get one at https://console.anthropic.com/. Used for Claude engine with the web_search tool. ~$0.01 per search + tokens."
                    },
                    "geminiModel": {
                        "title": "Gemini model override",
                        "type": "string",
                        "description": "Optional. Default: gemini-2.5-flash (free tier). Try gemini-2.5-flash-lite for higher daily quota, or gemini-2.5-pro / gemini-3-flash-preview if you have billing enabled."
                    },
                    "openaiModel": {
                        "title": "OpenAI model override",
                        "type": "string",
                        "description": "Optional. Default: gpt-4o-mini-search-preview."
                    },
                    "perplexityModel": {
                        "title": "Perplexity model override",
                        "type": "string",
                        "description": "Optional. Default: sonar. Try sonar-pro for richer citations."
                    },
                    "anthropicModel": {
                        "title": "Anthropic model override",
                        "type": "string",
                        "description": "Optional. Default: claude-haiku-4-5-20251001."
                    },
                    "language": {
                        "title": "Query language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "hu",
                            "pl",
                            "cs",
                            "sk",
                            "ro",
                            "bg",
                            "hr",
                            "tr",
                            "ja",
                            "ko",
                            "zh",
                            "ru",
                            "uk",
                            "sv",
                            "no",
                            "da",
                            "fi"
                        ],
                        "type": "string",
                        "description": "Language hint for the engines. Influences the language of answers and which sources get cited. Multilingual coverage is our differentiator vs Otterly/Profound/Semrush which are mostly US-English-only.",
                        "default": "en"
                    },
                    "samplesPerQuery": {
                        "title": "Samples per query (stability score)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times each query is run on each engine. AI answers are non-deterministic — running 3 samples gives a stability score showing how consistently a source is cited. 1 = single shot (cheapest), 3 = recommended, 5 = high-confidence.",
                        "default": 1
                    },
                    "previousRunDatasetId": {
                        "title": "Delta mode — diff vs a previous run",
                        "type": "string",
                        "description": "Optional. Provide a dataset ID from a previous run. The actor will compute citation gains/losses week-over-week and surface the diff. Perfect for daily/weekly scheduled tracking."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many engine requests to run in parallel. Lower if you hit rate limits on the free Gemini tier (10 req/min on Gemini 2.5 Flash free).",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
