# Ai Search Visibility Tracker (`coregent/ai-search-visibility-tracker`) Actor

Monitor how AI answer engines mention your brand across prompts and countries. Detect target/competitor mentions, extract cited domains/URLs, and export clean datasets for weekly tracking and reporting on Apify.

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

## Pricing

from $8.00 / 1,000 query results

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

> **Track AI answer visibility for your brand across 500 prompts, weekly, by country — including which sources get cited and where you're missing.**

![AI Search Visibility Tracker](https://raw.githubusercontent.com/coregentdevspace/ai-search-visibility-tracker-assets/main/thumbnail--ai-search-visibility-tracker.jpeg "AI Search Visibility Tracker")

- ✅ Target present/absent per query
- ✅ Competitors detected
- ✅ Cited domains + URLs extracted

### What This Actor Does

- **Monitors brand mentions in AI answers** — Checks Perplexity, Google AI Overview, and more to see if your brand appears when people ask AI search engines the questions that matter to your business.
- **Extracts cited sources** — Captures every URL and domain the AI engine cites, so you know which sites are getting the visibility you want.
- **Detects competitors** — See which competitors show up in the same AI answers, and how often.
- **Delivers structured, analysis-ready data** — Every result is a clean JSON row with classification, match type, sources, and metadata — ready for spreadsheets, dashboards, or API workflows.

### Why Not Just Ask ChatGPT?

Manually asking an AI engine one question at a time doesn't scale. This Actor solves three problems:

1. **Scale** — Test hundreds of prompts across multiple engines and markets in a single run.
2. **Repeatability** — Schedule weekly or daily runs and track how your visibility changes over time.
3. **Structured outputs** — Get machine-readable rows with classification, competitor detection, and source extraction — not just a chat transcript.

### Key Features

- **Batch prompts** — Run 1 to 500+ queries per run
- **Query templates** — Auto-generate prompts from seed keywords using preset packs (agency, SaaS, ecommerce, local)
- **Country & language targeting** — 30 countries and 19 languages supported via dropdown selects
- **Competitor detection** — Track which rivals appear alongside or instead of you
- **Citation extraction** — Full source URLs, domains, and positions
- **Query groups** — Label queries by group for agency-friendly reporting
- **Scheduling-ready** — Connect to Apify Schedules for automated recurring monitoring

### Templates

Choose a template to auto-generate queries from your seed keywords, or use `custom` to provide your own.

| Template | Best For | Generated Patterns |
|----------|----------|-------------------|
| `custom` | Full control | No generation — uses your queries as-is |
| `agency` | Broad funnel monitoring | "best {k}", "top {k} tools", "{k} vs {competitor}", "alternatives to {competitor}", "how to {k}", "best {k} for small business", "best {k} in {country}" |
| `saas` | Competitive SaaS visibility | "best {k} software", "{brand} alternatives", "{competitor} alternatives", "{brand} vs {competitor}", "best {k} for startups", "best {k} for agencies", "pricing comparison for {k} tools" |
| `ecommerce` | Product/category prompts | "best {k}", "top {k} brands", "best {k} for your needs", "{k} reviews", "where to buy {k}" |
| `local` | City-specific services | "best {k} in {city}", "top-rated {k} near me in {city}", "{k} cost in {city}", "emergency {k} {city}", "{k} reviews {city}" |

#### Placeholders

| Placeholder | Resolves To |
|-------------|------------|
| `{k}` | Each seed keyword |
| `{brand}` | Your `targetName` |
| `{competitor}` | Each competitor (patterns skipped if none provided) |
| `{country}` | The `country` input value |
| `{city}` | Each location (local template only) |

### Input

![AI Search Visibility Tracker — Input UI](https://raw.githubusercontent.com/coregentdevspace/ai-search-visibility-tracker-assets/main/ai-search-visibility-tracker-input-ui.png "AI Search Visibility Tracker — Input UI")

### Quick Start Examples

#### 1. SaaS Template with Query Groups

Use a template with grouped queries for organized reporting. When `queryGroups` is provided, it takes priority over `queries` and template generation.

```json
{
  "template": "saas",
  "seedKeywords": ["YouTube video"],
  "queryGroups": [
    {
      "groupName": "Video",
      "queries": ["Best video making tools"]
    }
  ],
  "targetName": "YouTube",
  "competitors": ["canva"],
  "engines": ["perplexity"],
  "country": "AU",
  "language": "en",
  "includeAnswerText": true,
  "includeSources": true,
  "includeCompetitors": false,
  "deduplicateSources": true
}
````

#### 2. SaaS Template with Multiple Query Groups

Scale up with multiple query groups across different topics.

```json
{
  "template": "saas",
  "seedKeywords": ["YouTube video"],
  "queryGroups": [
    {
      "groupName": "Video",
      "queries": [
        "Best video making tools",
        "YouTube Transcript",
        "AI Search"
      ]
    }
  ],
  "targetName": "YouTube",
  "competitors": ["canva"],
  "engines": ["perplexity"],
  "country": "AU",
  "language": "en",
  "includeAnswerText": true,
  "includeSources": true,
  "includeCompetitors": false,
  "deduplicateSources": true
}
```

#### 3. Custom — Manual Queries

Provide your own queries for full control.

```json
{
  "queries": [
    "best youtube transcript tools",
    "best tools to analyze youtube comments"
  ],
  "targetName": "Gitoken",
  "competitors": ["TubeBuddy", "VidIQ"],
  "engines": ["perplexity"],
  "includeCompetitors": true
}
```

#### 4. Local Template — City-Specific Services

Monitor AI visibility for local services across multiple cities.

```json
{
  "template": "local",
  "seedKeywords": ["plumber", "emergency plumber"],
  "locations": ["Sydney", "Melbourne", "Brisbane"],
  "targetName": "PipeFixPro",
  "engines": ["perplexity"],
  "country": "AU"
}
```

### Input Parameters

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `template` | string | No | `"custom"` | Preset prompt pack: `custom`, `agency`, `saas`, `ecommerce`, `local` |
| `seedKeywords` | array | When using template | `[]` | Keywords to expand into queries via template patterns |
| `locations` | array | For `local` template | `[]` | Cities/areas for local query generation |
| `queries` | array | When `custom` | — | Prompts/questions to test against AI engines |
| `queryGroups` | array | No | `[]` | Grouped queries for agency reporting: `[{ groupName, queries[] }]` |
| `targetName` | string | **Yes** | — | Brand, product, or topic to track |
| `targetAliases` | array | No | `[]` | Alternate names, spelling variants |
| `competitors` | array | No | `[]` | Competitor names/domains to detect |
| `engines` | array | No | `["perplexity"]` | AI engines to query |
| `country` | string | No | `"US"` | Country (30 countries supported) |
| `language` | string | No | `"en"` | Language (19 languages supported) |
| `includeAnswerText` | boolean | No | `true` | Include full AI answer text |
| `includeSources` | boolean | No | `true` | Include cited sources |
| `includeCompetitors` | boolean | No | `false` | Enable competitor detection |
| `deduplicateSources` | boolean | No | `true` | Remove duplicate source URLs |
| `saveScreenshot` | boolean | No | `false` | Save page screenshots to KVS |
| `saveHtml` | boolean | No | `false` | Save page HTML to KVS |
| `maxConcurrency` | integer | No | `1` | Max concurrent browser pages (1–5) |
| `navigationTimeoutSecs` | integer | No | `60` | Page load timeout in seconds |
| `maxRetries` | integer | No | `2` | Retries for failed pages |
| `proxyConfiguration` | object | No | — | Optional proxy settings |
| `debugMode` | boolean | No | `false` | Verbose logging + debug info in output |

#### Query Resolution Precedence

The Actor resolves queries in this order:

1. **`queryGroups`** provided → uses grouped queries, ignores `queries` and template generation
2. **`queries`** provided → uses them as-is, `template` only affects metadata labeling
3. **Neither** → generates queries from `template` + `seedKeywords` (+ `locations` for local)

### Output

#### Table View

![AI Search Visibility Tracker — Output Table View](https://raw.githubusercontent.com/coregentdevspace/ai-search-visibility-tracker-assets/main/ai-search-visibility-tracker-output-table-view.png "AI Search Visibility Tracker — Output Table View")

#### JSON Output

Each result row contains structured data like this real output from a production run:

```json
[
  {
    "query": "Best video making tools",
    "queryGroup": "Video",
    "template": "saas",
    "engine": "perplexity",
    "country": "AU",
    "language": "en",
    "classification": "target_present",
    "targetName": "YouTube",
    "targetPresent": true,
    "targetMatchType": "exact",
    "sourceCount": 2,
    "answerLength": 1625,
    "timestamp": "2026-03-02T05:15:45.347Z"
  }
]
```

![AI Search Visibility Tracker — Output JSON View](https://raw.githubusercontent.com/coregentdevspace/ai-search-visibility-tracker-assets/main/ai-search-visibility-tracker-output-json-view.json "AI Search Visibility Tracker — Output JSON View")

#### Full Result Row Fields

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | The prompt that was tested |
| `engine` | string | Engine used (e.g., `perplexity`) |
| `country` | string | Country code |
| `language` | string | Language code |
| `timestamp` | string | ISO 8601 timestamp |
| `aiAnswerFound` | boolean | Whether an AI answer block was detected |
| `answerText` | string | Full extracted AI answer text |
| `answerLength` | number | Character count of answer |
| `targetName` | string | Brand being tracked |
| `targetPresent` | boolean | Whether target was found |
| `targetMatchType` | string | How target was matched: `exact`, `normalized`, `alias`, `domain` |
| `targetMentions` | array | Specific strings that matched |
| `competitorsChecked` | array | Competitors that were checked |
| `competitorsPresent` | array | Competitors found in answer |
| `classification` | string | Result classification (see below) |
| `sources` | array | Cited source objects with `domain`, `url`, `title`, `position` |
| `sourceDomains` | array | Unique domains from sources |
| `sourceCount` | number | Number of sources found |
| `template` | string | Template used for this run |
| `templateVersion` | string | Template version (e.g., `"1.0"`) |
| `queryGroup` | string | Group label if using queryGroups |
| `notes` | string | Warnings or error messages |
| `debug` | object | Debug info (when `debugMode: true`) |

#### Classification Values

| Value | Meaning |
|-------|---------|
| `target_present` | AI answer found, target brand detected |
| `target_absent` | AI answer found, target brand NOT detected |
| `no_ai_answer_found` | Page loaded but no AI answer block found |
| `partial_extraction` | Extraction completed with warnings |
| `error` | Request failed entirely |

#### Run Summary

Each run saves a `RUN_SUMMARY` to the Key-Value Store with aggregated metrics:

- `visibilityRate` — Fraction of successful AI answers where the target was present
- `topCompetitors` — Competitor mention counts (sorted)
- `topSourceDomains` — Most frequently cited domains (top 20)
- `template`, `templateVersion`, `queryGroupCount` — Template metadata
- Result counts: present, absent, no AI answer, errors

### Interpreting Results

- **Visibility rate** — `targetPresentCount / (results - errors - noAiAnswer)`. A rate of 0.40 means your brand appears in 40% of AI answers where an answer was found.
- **Top cited domains** — The `topSourceDomains` in the run summary shows which sites AI engines reference most. If your domain isn't there, consider improving content authority.
- **Missing prompts** — Filter for `classification = "target_absent"` to find the queries where your brand is NOT being recommended. These are your content gaps.
- **Query groups** — When using `queryGroups`, filter by `queryGroup` to compare visibility across different topic categories (e.g., "Brand awareness" vs "Competitor comparison").

### Pricing

This Actor uses **pay-per-event** pricing: **1 event per query-engine pair** processed (event name: `query-result`).

| Scenario | Events |
|----------|--------|
| 10 queries × 1 engine | 10 |
| 10 queries × 2 engines | 20 |
| SaaS template, 3 keywords, 2 competitors, 1 engine | ~21 |

**Cost tips:**

- Start with 1 engine (Perplexity) to validate prompts before adding more
- Use fewer seed keywords during testing
- Set `includeAnswerText: false` if you only need presence/absence classification (reduces storage)

### Limitations

- **Engine availability may vary** — AI search engines can change their page structure or add bot detection at any time. The Actor includes retry logic, but some requests may still fail.
- **Experimental engines** — Engines labeled "experimental" (e.g., Google AI) have lower extraction reliability due to inconsistent AI Overview availability and aggressive bot detection.
- **No LLM-based extraction** — Answers are extracted via DOM selectors, not by calling an LLM API. This keeps costs predictable but means extraction depends on page structure.

### Engine Support

| Engine | Key | Status | Notes |
|--------|-----|--------|-------|
| Perplexity | `perplexity` | Stable | Primary engine, reliable extraction |
| Google AI Overview | `google_ai` | Experimental | Inconsistent availability, aggressive bot detection |

### Proxy

The Actor does not bundle proxies. If you need proxy support:

- Provide your own proxy configuration via the `proxyConfiguration` input
- Residential proxies recommended for Google AI to reduce blocking

# Actor input Schema

## `template` (type: `string`):

Choose a preset prompt pack. 'custom' requires your own queries. Other templates auto-generate queries from seed keywords.

## `seedKeywords` (type: `array`):

Keywords/topics used to generate prompts when using a non-custom template (e.g., 'youtube analytics', 'plumber').

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

Cities or areas for local query generation (required for local template when queries are empty).

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

Prompts or search questions to test against AI engines. Optional when using a non-custom template with seed keywords.

## `queryGroups` (type: `array`):

Group queries by label for agency-friendly reporting. If provided, overrides the queries field. Each group: { "groupName": "...", "queries": \[...] }.

## `targetName` (type: `string`):

Brand, product, person, domain, or topic to track visibility for.

## `targetAliases` (type: `array`):

Alternate brand names, spelling variants, or abbreviations (e.g., 'Gitoken.app', 'Gitoken AI').

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

Competitor names or domains to detect in AI answers.

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

AI search engines to query. Perplexity is stable; Google AI is experimental.

## `country` (type: `string`):

Country code for market-specific results.

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

Language code for results.

## `includeAnswerText` (type: `boolean`):

Include the full extracted AI answer text in output.

## `includeSources` (type: `boolean`):

Include cited source URLs and domains in output.

## `includeCompetitors` (type: `boolean`):

Check for competitor mentions in answers and sources.

## `deduplicateSources` (type: `boolean`):

Remove duplicate source URLs within each result.

## `saveScreenshot` (type: `boolean`):

Save a screenshot of each AI answer page to Key-Value Store.

## `saveHtml` (type: `boolean`):

Save raw HTML of each AI answer page to Key-Value Store.

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

Maximum number of browser pages open at once.

## `navigationTimeoutSecs` (type: `integer`):

Maximum time to wait for a page to load.

## `maxRetries` (type: `integer`):

Maximum retries for failed page loads.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Provide your own proxy configuration if needed.

## `debugMode` (type: `boolean`):

Enable verbose logging and include debug info in output.

## Actor input object example

```json
{
  "template": "custom",
  "seedKeywords": [],
  "locations": [],
  "queries": [
    "best tools for youtube analytics"
  ],
  "queryGroups": [],
  "targetName": "Gitoken",
  "targetAliases": [],
  "competitors": [],
  "engines": [
    "perplexity"
  ],
  "country": "US",
  "language": "en",
  "includeAnswerText": true,
  "includeSources": true,
  "includeCompetitors": false,
  "deduplicateSources": true,
  "saveScreenshot": false,
  "saveHtml": false,
  "maxConcurrency": 1,
  "navigationTimeoutSecs": 60,
  "maxRetries": 2,
  "debugMode": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 tools for youtube analytics"
    ],
    "targetName": "Gitoken"
};

// Run the Actor and wait for it to finish
const run = await client.actor("coregent/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 tools for youtube analytics"],
    "targetName": "Gitoken",
}

# Run the Actor and wait for it to finish
run = client.actor("coregent/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 tools for youtube analytics"
  ],
  "targetName": "Gitoken"
}' |
apify call coregent/ai-search-visibility-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ai Search Visibility Tracker",
        "description": "Monitor how AI answer engines mention your brand across prompts and countries. Detect target/competitor mentions, extract cited domains/URLs, and export clean datasets for weekly tracking and reporting on Apify.",
        "version": "0.1",
        "x-build-id": "X6iKarFCCC06BQgpI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coregent~ai-search-visibility-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coregent-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/coregent~ai-search-visibility-tracker/runs": {
            "post": {
                "operationId": "runs-sync-coregent-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/coregent~ai-search-visibility-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-coregent-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": [
                    "targetName"
                ],
                "properties": {
                    "template": {
                        "title": "Template",
                        "enum": [
                            "custom",
                            "agency",
                            "saas",
                            "ecommerce",
                            "local"
                        ],
                        "type": "string",
                        "description": "Choose a preset prompt pack. 'custom' requires your own queries. Other templates auto-generate queries from seed keywords.",
                        "default": "custom"
                    },
                    "seedKeywords": {
                        "title": "Seed Keywords",
                        "type": "array",
                        "description": "Keywords/topics used to generate prompts when using a non-custom template (e.g., 'youtube analytics', 'plumber').",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "locations": {
                        "title": "Locations (for local template)",
                        "type": "array",
                        "description": "Cities or areas for local query generation (required for local template when queries are empty).",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "queries": {
                        "title": "Queries",
                        "type": "array",
                        "description": "Prompts or search questions to test against AI engines. Optional when using a non-custom template with seed keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queryGroups": {
                        "title": "Query Groups",
                        "type": "array",
                        "description": "Group queries by label for agency-friendly reporting. If provided, overrides the queries field. Each group: { \"groupName\": \"...\", \"queries\": [...] }.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "groupName": {
                                    "title": "Group Name",
                                    "type": "string",
                                    "description": "Label for this query group (e.g., 'Brand awareness')."
                                },
                                "queries": {
                                    "title": "Queries",
                                    "type": "array",
                                    "description": "List of queries in this group.",
                                    "items": {
                                        "type": "string"
                                    }
                                }
                            },
                            "required": [
                                "groupName",
                                "queries"
                            ]
                        },
                        "default": []
                    },
                    "targetName": {
                        "title": "Target Name",
                        "type": "string",
                        "description": "Brand, product, person, domain, or topic to track visibility for."
                    },
                    "targetAliases": {
                        "title": "Target Aliases",
                        "type": "array",
                        "description": "Alternate brand names, spelling variants, or abbreviations (e.g., 'Gitoken.app', 'Gitoken AI').",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "competitors": {
                        "title": "Competitors",
                        "type": "array",
                        "description": "Competitor names or domains to detect in AI answers.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "engines": {
                        "title": "Engines",
                        "type": "array",
                        "description": "AI search engines to query. Perplexity is stable; Google AI is experimental.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "perplexity",
                                "google_ai"
                            ],
                            "enumTitles": [
                                "Perplexity (stable)",
                                "Google AI Overview (experimental)"
                            ]
                        },
                        "default": [
                            "perplexity"
                        ]
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "AU",
                            "CA",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "BR",
                            "MX",
                            "IN",
                            "JP",
                            "KR",
                            "SG",
                            "NZ",
                            "IE",
                            "AT",
                            "CH",
                            "BE",
                            "PT",
                            "PL",
                            "CZ",
                            "ZA",
                            "AE",
                            "IL"
                        ],
                        "type": "string",
                        "description": "Country code for market-specific results.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "pl",
                            "cs",
                            "ja",
                            "ko",
                            "zh",
                            "ar",
                            "hi",
                            "he"
                        ],
                        "type": "string",
                        "description": "Language code for results.",
                        "default": "en"
                    },
                    "includeAnswerText": {
                        "title": "Include Answer Text",
                        "type": "boolean",
                        "description": "Include the full extracted AI answer text in output.",
                        "default": true
                    },
                    "includeSources": {
                        "title": "Include Sources",
                        "type": "boolean",
                        "description": "Include cited source URLs and domains in output.",
                        "default": true
                    },
                    "includeCompetitors": {
                        "title": "Include Competitor Detection",
                        "type": "boolean",
                        "description": "Check for competitor mentions in answers and sources.",
                        "default": false
                    },
                    "deduplicateSources": {
                        "title": "Deduplicate Sources",
                        "type": "boolean",
                        "description": "Remove duplicate source URLs within each result.",
                        "default": true
                    },
                    "saveScreenshot": {
                        "title": "Save Screenshot",
                        "type": "boolean",
                        "description": "Save a screenshot of each AI answer page to Key-Value Store.",
                        "default": false
                    },
                    "saveHtml": {
                        "title": "Save HTML",
                        "type": "boolean",
                        "description": "Save raw HTML of each AI answer page to Key-Value Store.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum number of browser pages open at once.",
                        "default": 1
                    },
                    "navigationTimeoutSecs": {
                        "title": "Navigation Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time to wait for a page to load.",
                        "default": 60
                    },
                    "maxRetries": {
                        "title": "Max Retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum retries for failed page loads.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Provide your own proxy configuration if needed."
                    },
                    "debugMode": {
                        "title": "Debug Mode",
                        "type": "boolean",
                        "description": "Enable verbose logging and include debug info in output.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
