# AI Brand Visibility Monitor — ChatGPT, Claude, Gemini (GEO) (`bikram07/ai-brand-visibility-monitor`) Actor

Track your brand's visibility across ChatGPT, Claude, Gemini & Perplexity (GEO/AEO). Ask the AIs your buyers' questions, get a visibility score, mention position, competitor share & Perplexity citations. Uses official APIs with your own keys. $20 per 1,000 checks; failed calls never charged.

- **URL**: https://apify.com/bikram07/ai-brand-visibility-monitor.md
- **Developed by:** [Bikram](https://apify.com/bikram07) (community)
- **Categories:** AI, SEO tools, Marketing
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 visibility checks

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

Learn more: https://docs.apify.com/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 Brand Visibility Tracker for ChatGPT, Claude, Gemini & Perplexity (GEO / AEO)

Track how often **ChatGPT, Claude, Gemini, and Perplexity** mention your brand when your customers ask them for recommendations — and whether they recommend a competitor instead. This Actor sends your buyers' real questions to the **official OpenAI, Anthropic, Google, and Perplexity APIs**, then analyzes every answer locally for **brand mentions, mention position, competitor share, and Perplexity citations**, and gives you a **visibility score per AI assistant** you can track over time.

It runs on **your own API keys** (bring-your-own-keys): every check is a normal, paid-by-you API call to an official endpoint. No scraping of ChatGPT/Gemini web apps, no fragile browser automation, no terms-of-service gray zone — and your keys are encrypted at rest and never logged.

### What it does

- Asks each selected AI the prompts your buyers would actually type (e.g. *"best web scraping tools 2026"*).
- Detects whether your brand is mentioned (whole-word, case-insensitive — "Acme" never matches "Acmeify").
- Measures **where** the mention appears in the answer: first, middle, or late.
- Tracks whether your brand appears **before** every competitor you list ("brand-first").
- Records which **competitors** the AIs name instead, and their share of mentions.
- For **Perplexity**, extracts the source domains it cites and checks whether **your domain** is one of them.
- Aggregates everything into a per-provider **visibility score** plus an overall score in a final summary item.

#### What it does NOT do (limitations)

- It calls the provider **APIs**, not the consumer ChatGPT/Gemini/Perplexity websites. The API view is the stable, comparable signal GEO tools track, but the public apps add their own system prompts and (sometimes) web search, so wording can differ.
- Only **Perplexity** returns web citations (`citedDomains` / `brandDomainCited`). OpenAI, Anthropic, and Gemini default models answer from training knowledge, so those checks have no citation data.
- It reports **mentions, position, and citations** — not sentiment or tone analysis.
- LLM answers are non-deterministic; a single run is a snapshot. Use `runsPerPrompt` 2–3 and weekly schedules for a reliable trend.

### How it works

1. You enter your brand name, the prompts your customers ask, optional competitors and domain, and an API key for each provider you select.
2. For every **prompt × provider × run**, the Actor calls that provider's official API with your key (3 concurrent requests, with retry/backoff).
3. Each answer is analyzed **locally** (no extra LLM call) for brand mention, position, brand-first ordering, competitors, and — for Perplexity — cited domains.
4. One dataset item is written per successful check, and you are charged one `visibility-check` event. Failed calls are logged and **never charged**.
5. A final summary item aggregates visibility scores, brand-first rate, citation rate, and competitor share per provider.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `brandName` | string | — (required) | Brand to detect. Case-insensitive, word-boundary matching. |
| `prompts` | array | — (required) | 1–50 questions to ask each AI. |
| `brandDomain` | string | none | Your domain, for Perplexity citation checking (scheme/`www.` ignored). |
| `competitors` | array | `[]` | Up to 5 competitor names to track for share + brand-first. |
| `providers` | array | `["openai"]` | Any of `openai`, `anthropic`, `gemini`, `perplexity`. |
| `openaiApiKey` … `perplexityApiKey` | secret string | — | Your key per selected provider (encrypted, never logged). |
| `openaiModel` … `perplexityModel` | string | cheap defaults | Per-provider model override (defaults: `gpt-5-mini`, `claude-haiku-4-5`, `gemini-3.5-flash`, `sonar`). |
| `temperature` | number | `0.7` | Sampling temperature (auto-omitted for GPT-5 family, clamped to 0–1 for Claude). |
| `runsPerPrompt` | integer | `1` | 1–3 runs per prompt per provider for a stabler signal. |

```json
{
    "brandName": "Acme",
    "brandDomain": "acme.com",
    "competitors": ["Globex", "Initech"],
    "prompts": [
        "best web scraping tools 2026",
        "which web scraping platform should a startup use?"
    ],
    "providers": ["openai", "perplexity"],
    "openaiApiKey": "sk-...",
    "perplexityApiKey": "pplx-...",
    "runsPerPrompt": 2
}
````

### Output fields

One **check** item per successful (prompt × provider × run):

| Field | Type | Description |
|---|---|---|
| `type` | string | Always `"check"` for per-check items. |
| `prompt` | string | The question that was asked. |
| `provider` | string | `openai`, `anthropic`, `gemini`, or `perplexity`. |
| `model` | string | The model ID used for this check. |
| `runIndex` | integer | Which run this is (1…`runsPerPrompt`). |
| `brandName` | string | The brand that was searched for. |
| `brandMentioned` | boolean | Whether the brand appears in the answer. |
| `mentionPosition` | string | `first`, `middle`, `late`, or `none`. |
| `brandFirst` | boolean | Brand appears before every mentioned competitor. |
| `competitorsMentioned` | array | Competitors found, in order of first appearance. |
| `citedDomains` | array | Source domains cited (Perplexity only; `[]` otherwise). |
| `brandDomainCited` | boolean / null | Brand domain among the citations; `null` if no domain given. |
| `answerText` | string | The AI answer, truncated to 2,000 chars (analysis uses the full text). |
| `checkedAt` | string | ISO-8601 UTC timestamp. |

Plus one final **summary** item (`"type": "summary"`, never charged):

| Field | Description |
|---|---|
| `brandName`, `brandDomain` | Echoed input. |
| `prompts`, `runsPerPrompt` | Run configuration. |
| `checksSucceeded`, `checksFailed` | Counts across all providers. |
| `overallVisibilityScore` | % of all successful checks that mentioned the brand. |
| `providers` | Per-provider object: `model`, `checksSucceeded`, `checksFailed`, `visibilityScore`, `brandFirstRate`, `brandDomainCitedRate` (Perplexity + domain only). |
| `competitorShare` | % of successful checks mentioning each competitor. |
| `checkedAt` | ISO-8601 UTC timestamp. |

```json
{
    "type": "summary",
    "brandName": "Acme",
    "checksSucceeded": 20,
    "checksFailed": 0,
    "overallVisibilityScore": 65.0,
    "providers": {
        "openai": { "model": "gpt-5-mini", "visibilityScore": 70.0, "brandFirstRate": 40.0 },
        "perplexity": { "model": "sonar", "visibilityScore": 60.0, "brandDomainCitedRate": 30.0 }
    },
    "competitorShare": { "Globex": 45.0, "Initech": 10.0 }
}
```

### Use cases

- **SEO / GEO specialists** — turn "are we visible in AI search?" into a weekly visibility score per assistant, with before/after evidence for content and digital-PR work.
- **Brand & marketing managers** — see how ChatGPT, Claude, Gemini, and Perplexity describe your brand and which competitors they recommend instead.
- **Founders & indie hackers** — cheaply check whether the AIs name your product when buyers ask "best tool for X," without buying a $99+/mo monitoring SaaS.
- **Agencies** — run the same prompt set across multiple client brands and competitors on a schedule, and deliver an AI-share-of-voice report.
- **AI / automation engineers** — call it as an MCP tool so an agent (Claude, Cursor) can check brand visibility on demand and reason over the results.

### Why monitor AI search visibility (GEO / AEO)?

AI answers now sit in front of buying decisions, so brand visibility inside them has become a tracked marketing KPI. The [2026 AI Search Benchmark Report](https://opollo.com/blog/the-2026-ai-search-benchmark-report/) (312 IT/technology service firms, Jan 2025–Jan 2026) found AI-referred visitors converted at **14.2% versus 2.8%** for Google organic — while AI referral share of traffic grew from under 1% to 6.4% in a year. Conductor's [2026 AEO/GEO Benchmarks Report](https://www.conductor.com/academy/aeo-geo-benchmarks-report/) documents the same shift. You can't optimize what you don't measure — this Actor is the measurement loop.

### Pricing

This Actor is **pay-per-event** — there is **no subscription** and no monthly fee. You pay only for checks that run.

| Cost | Who you pay | Amount |
|---|---|---|
| Actor fee | Apify (pay-per-event) | **$20 per 1,000 visibility checks** (i.e. $0.02 per successful `visibility-check` event) |
| LLM API usage | The provider, via your own key | Typically **well under $0.01 per check** with the default cheap models (`gpt-5-mini`, `claude-haiku-4-5`, `gemini-3.5-flash`, `sonar`). Perplexity adds a small per-search fee. |

A "check" is one (prompt × provider × run) call. Example: 10 prompts × 2 providers × 1 run = 20 checks = **$0.40** Actor fee, plus a few cents of your own API usage. **Failed checks are never charged** — a bad key, a rate limit after 3 retries, or a timeout produces a logged warning, not a billed event. If a key is rejected (401/403), all remaining checks for that provider are skipped immediately. You can also cap the maximum total cost per run in Apify Console.

#### Privacy: keys are encrypted and never logged

API-key fields are marked `isSecret` in the input schema, so Apify encrypts them at rest and decrypts them only inside your run. The Actor uses keys exclusively in request headers (never in URLs or query strings), never logs them, and never writes them to the dataset.

### Track your AI visibility weekly (recommended)

GEO is a trend metric, not a one-off audit. In Apify Console, open the Actor → **Schedules** → create a weekly schedule with your saved input. Each run appends to a named dataset, so after a month you have a week-by-week series of visibility scores per provider. Pair it with a Slack, email, or webhook integration to get the summary delivered automatically.

### Use from Claude, Cursor & other AI agents (MCP)

This Actor works as a tool over the [Model Context Protocol](https://mcp.apify.com). Add Apify's MCP server to your client and your agent can run visibility checks on demand:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/sse?actors=bikram07/ai-brand-visibility-monitor",
            "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
        }
    }
}
```

Or call it from code via the [Apify API](https://docs.apify.com/api/v2):

```bash
curl -X POST "https://api.apify.com/v2/acts/bikram07~ai-brand-visibility-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"brandName": "Acme", "prompts": ["best web scraping tools 2026"], "providers": ["openai"], "openaiApiKey": "sk-..."}'
```

### FAQ

**How do I check if ChatGPT mentions my brand?**
Add your brand name, the questions your customers ask (e.g. "best CRM for small business"), select the `openai` provider, paste your OpenAI API key, and run. Each answer is analyzed for whole-word brand mentions, position, and competitor ordering — you get a per-prompt breakdown plus a final visibility score.

**Is this a subscription?**
No. It's pay-per-event: **$20 per 1,000 successful checks** ($0.02 each), with no monthly fee. You pay only for the checks you run, and you can set a max-cost cap per run.

**How does pricing / refunds work, and what counts as a paid check?**
A "check" is one (prompt × provider × run) call. You're charged only when a check **succeeds**; failed calls (bad key, rate limit, timeout) are never billed, so there's nothing to refund for failures. Your separate LLM API spend is billed directly by each provider on your own key.

**Does it use official APIs or scrape the websites?**
Official APIs only — OpenAI, Anthropic, Google Gemini, and Perplexity. There is no scraping of the ChatGPT/Gemini/Perplexity web apps, which means no terms-of-service risk and no breakage when those UIs change.

**Why do I need my own API keys?**
Honesty (no markup on LLM calls — you pay providers their real price), reliability (official APIs don't break like scraped UIs), and compliance (no ToS-violating scraping). Keys are encrypted by Apify's secret-input feature and never logged or stored in the dataset.

**Why do results differ between runs?**
LLM sampling is non-deterministic — the same prompt can return different answers. That's why `runsPerPrompt` exists: set it to 2–3 and read the aggregate visibility score rather than a single answer. Trends across weekly runs matter more than any individual check.

***

This Actor is independent and is not affiliated with or endorsed by OpenAI, Anthropic, Google, or Perplexity. You are responsible for your own API usage under each provider's terms.

# Actor input Schema

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

The brand to look for in AI answers. Matching is case-insensitive with word boundaries, so <b>Acme</b> matches "acme" but not "Acmeify".

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

Your website domain, e.g. <b>example.com</b>. Used to check whether Perplexity cites your site as a source. Scheme and www. are ignored.

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

Competitor brand names to track alongside your brand. Used for the "brand first" signal and competitor share in the summary.

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

The questions your customers would ask an AI assistant, e.g. "best web scraping tools 2026". Each prompt is sent to every selected provider.

## `providers` (type: `array`):

Which AI assistants to query. You must supply an API key below for every selected provider.

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

Your OpenAI API key (platform.openai.com). Stored encrypted by Apify, decrypted only inside the run, never logged, never stored in the dataset.

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

Your Anthropic API key (platform.claude.com). Encrypted at rest, never logged.

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

Your Gemini API key (aistudio.google.com). Encrypted at rest, never logged.

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

Your Perplexity API key (perplexity.ai/settings/api). Encrypted at rest, never logged.

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

OpenAI model ID. Default <b>gpt-5-mini</b> is cheap and current. Note: GPT-5 family models ignore the temperature setting (only the default is supported); the Actor handles this automatically.

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

Anthropic model ID. Default <b>claude-haiku-4-5</b> is the cheapest current Claude model.

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

Gemini model ID. Default <b>gemini-3.5-flash</b> is the current fast/cheap Gemini model.

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

Perplexity model ID. Default <b>sonar</b> is the cheapest search-grounded model and returns citations.

## `temperature` (type: `number`):

Sampling temperature passed to each provider (clamped to 0–1 for Anthropic). GPT-5 family models only support their default temperature; for those the Actor automatically omits it.

## `runsPerPrompt` (type: `integer`):

How many times to ask each provider the same prompt. AI answers vary between runs — 2–3 runs give a more reliable visibility signal. Each run is one charged check.

## Actor input object example

```json
{
  "brandName": "Apify",
  "prompts": [
    "best web scraping platforms 2026"
  ],
  "providers": [
    "openai"
  ],
  "openaiModel": "gpt-5-mini",
  "anthropicModel": "claude-haiku-4-5",
  "geminiModel": "gemini-3.5-flash",
  "perplexityModel": "sonar",
  "temperature": 0.7,
  "runsPerPrompt": 1
}
```

# 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 = {
    "brandName": "Apify",
    "prompts": [
        "best web scraping platforms 2026"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bikram07/ai-brand-visibility-monitor").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 = {
    "brandName": "Apify",
    "prompts": ["best web scraping platforms 2026"],
}

# Run the Actor and wait for it to finish
run = client.actor("bikram07/ai-brand-visibility-monitor").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 '{
  "brandName": "Apify",
  "prompts": [
    "best web scraping platforms 2026"
  ]
}' |
apify call bikram07/ai-brand-visibility-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Brand Visibility Monitor — ChatGPT, Claude, Gemini (GEO)",
        "description": "Track your brand's visibility across ChatGPT, Claude, Gemini & Perplexity (GEO/AEO). Ask the AIs your buyers' questions, get a visibility score, mention position, competitor share & Perplexity citations. Uses official APIs with your own keys. $20 per 1,000 checks; failed calls never charged.",
        "version": "0.1",
        "x-build-id": "E9c7mouUBvjvP1TPI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bikram07~ai-brand-visibility-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bikram07-ai-brand-visibility-monitor",
                "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/bikram07~ai-brand-visibility-monitor/runs": {
            "post": {
                "operationId": "runs-sync-bikram07-ai-brand-visibility-monitor",
                "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/bikram07~ai-brand-visibility-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-bikram07-ai-brand-visibility-monitor",
                "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": [
                    "brandName",
                    "prompts"
                ],
                "properties": {
                    "brandName": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "The brand to look for in AI answers. Matching is case-insensitive with word boundaries, so <b>Acme</b> matches \"acme\" but not \"Acmeify\"."
                    },
                    "brandDomain": {
                        "title": "Brand domain (optional)",
                        "type": "string",
                        "description": "Your website domain, e.g. <b>example.com</b>. Used to check whether Perplexity cites your site as a source. Scheme and www. are ignored."
                    },
                    "competitors": {
                        "title": "Competitors (optional, max 5)",
                        "maxItems": 5,
                        "type": "array",
                        "description": "Competitor brand names to track alongside your brand. Used for the \"brand first\" signal and competitor share in the summary.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "prompts": {
                        "title": "Prompts to ask each AI",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "The questions your customers would ask an AI assistant, e.g. \"best web scraping tools 2026\". Each prompt is sent to every selected provider.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "providers": {
                        "title": "AI providers to check",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which AI assistants to query. You must supply an API key below for every selected provider.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "openai",
                                "anthropic",
                                "gemini",
                                "perplexity"
                            ],
                            "enumTitles": [
                                "OpenAI (ChatGPT models)",
                                "Anthropic (Claude)",
                                "Google Gemini",
                                "Perplexity (Sonar, with citations)"
                            ]
                        },
                        "default": [
                            "openai"
                        ]
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API key",
                        "type": "string",
                        "description": "Your OpenAI API key (platform.openai.com). Stored encrypted by Apify, decrypted only inside the run, never logged, never stored in the dataset."
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API key",
                        "type": "string",
                        "description": "Your Anthropic API key (platform.claude.com). Encrypted at rest, never logged."
                    },
                    "geminiApiKey": {
                        "title": "Google Gemini API key",
                        "type": "string",
                        "description": "Your Gemini API key (aistudio.google.com). Encrypted at rest, never logged."
                    },
                    "perplexityApiKey": {
                        "title": "Perplexity API key",
                        "type": "string",
                        "description": "Your Perplexity API key (perplexity.ai/settings/api). Encrypted at rest, never logged."
                    },
                    "openaiModel": {
                        "title": "OpenAI model",
                        "type": "string",
                        "description": "OpenAI model ID. Default <b>gpt-5-mini</b> is cheap and current. Note: GPT-5 family models ignore the temperature setting (only the default is supported); the Actor handles this automatically.",
                        "default": "gpt-5-mini"
                    },
                    "anthropicModel": {
                        "title": "Anthropic model",
                        "type": "string",
                        "description": "Anthropic model ID. Default <b>claude-haiku-4-5</b> is the cheapest current Claude model.",
                        "default": "claude-haiku-4-5"
                    },
                    "geminiModel": {
                        "title": "Gemini model",
                        "type": "string",
                        "description": "Gemini model ID. Default <b>gemini-3.5-flash</b> is the current fast/cheap Gemini model.",
                        "default": "gemini-3.5-flash"
                    },
                    "perplexityModel": {
                        "title": "Perplexity model",
                        "type": "string",
                        "description": "Perplexity model ID. Default <b>sonar</b> is the cheapest search-grounded model and returns citations.",
                        "default": "sonar"
                    },
                    "temperature": {
                        "title": "Temperature",
                        "minimum": 0,
                        "maximum": 2,
                        "type": "number",
                        "description": "Sampling temperature passed to each provider (clamped to 0–1 for Anthropic). GPT-5 family models only support their default temperature; for those the Actor automatically omits it.",
                        "default": 0.7
                    },
                    "runsPerPrompt": {
                        "title": "Runs per prompt",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "How many times to ask each provider the same prompt. AI answers vary between runs — 2–3 runs give a more reliable visibility signal. Each run is one charged check.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```