# Google AI Overview Tracker API (`tugelbay/google-ai-overview-tracker`) Actor

Track Google AI Overview visibility for search prompts. Extract AIO availability, answer text, cited source links, source domains, brand/domain citations, competitor mentions, and clean no-AIO status.

- **URL**: https://apify.com/tugelbay/google-ai-overview-tracker.md
- **Developed by:** [Tugelbay Konabayev](https://apify.com/tugelbay) (community)
- **Categories:** AI, SEO tools, Marketing
- **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

## Google AI Overview Tracker API - AI Search Visibility Monitor

Track whether Google shows an AI Overview for your target searches, which external source links appear on the rendered SERP, and whether your brand or competitors appear in the generated answer.

This actor is intentionally narrow. It supports **Google AI Overview only**. It does not claim ChatGPT, Gemini, Perplexity, Claude, Copilot, Grok, or Meta AI coverage.

### Fast first run

Start with one prompt. Each prompt opens a rendered Google SERP, so small runs are faster and more reliable.

```json
{
  "prompts": ["best CRM software for small business"],
  "brandName": "HubSpot",
  "domain": "hubspot.com",
  "competitors": ["Zoho", "Pipedrive", "Salesforce"],
  "country": "US",
  "language": "en",
  "maxPrompts": 1,
  "timeoutSeconds": 30,
  "maxConcurrency": 1
}
````

### What it returns

For each prompt, the actor returns one dataset item with:

- `aiOverviewAvailable` - whether Google displayed an AI Overview
- `answerText` - extracted AI Overview text when available
- `sourceLinks` and `sourceDomains` - external URLs found on the rendered SERP
- `targetBrandMentioned` - whether your brand appears in the AI Overview text
- `targetDomainCited` - whether your domain appears in source links
- `competitorMentions` - which competitor names appeared
- `engineStatus` - `ok_aio`, `ok_no_aio`, `blocked`, `timeout`, or `error`

If Google does not show an AI Overview for a prompt, the run still succeeds and returns `aiOverviewAvailable=false`.

### Larger input example

```json
{
  "prompts": [
    "best CRM software for small business",
    "best email marketing platform for ecommerce",
    "best SEO tools for startups"
  ],
  "brandName": "HubSpot",
  "domain": "hubspot.com",
  "competitors": ["Zoho", "Pipedrive", "Salesforce"],
  "country": "US",
  "language": "en",
  "maxPrompts": 3,
  "timeoutSeconds": 30,
  "maxConcurrency": 1
}
```

For first-run testing, keep `maxPrompts` at `1`. Increase only after the sample output looks useful.

### Output example

```json
{
  "prompt": "best CRM software for small business",
  "engine": "google_ai_overview",
  "country": "US",
  "language": "en",
  "aiOverviewAvailable": true,
  "answerText": "AI Overview ...",
  "sourceDomains": ["hubspot.com", "pcmag.com", "reddit.com"],
  "targetBrand": "HubSpot",
  "targetDomain": "hubspot.com",
  "targetBrandMentioned": true,
  "targetDomainCited": true,
  "competitorMentions": ["Zoho", "Pipedrive"],
  "engineStatus": "ok_aio",
  "runtimeSeconds": 3.2
}
```

### Output field reference

Each dataset item is one prompt check. The schema is intentionally flat enough for CSV, Google Sheets, webhooks, and BI dashboards, while still keeping source links and competitors as arrays for automation.

| Field | Type | Description |
| --- | --- | --- |
| `prompt` | string | The search prompt/query that was checked. |
| `engine` | string | Always `google_ai_overview` for this actor. |
| `queryUrl` | string | Rendered Google Search URL with country/language parameters. |
| `answerUrl` | string | Final browser URL after redirects or consent flows. |
| `country` | string | Google country code used for the check, for example `US`. |
| `language` | string | Google interface language, for example `en`. |
| `aiOverviewAvailable` | boolean | Whether an AI Overview block was detected. |
| `answerText` | string | Extracted AI Overview text when present; empty when no AIO was shown. |
| `sourceLinks` | array | External links found on the rendered SERP after Google/link wrappers are filtered. |
| `sourceDomains` | array | Deduplicated domains from `sourceLinks`. |
| `targetBrand` | string | Brand name supplied in input. |
| `targetDomain` | string | Normalized target domain supplied in input. |
| `targetBrandMentioned` | boolean | Whether the brand name appears in the extracted AI Overview text. |
| `targetDomainCited` | boolean | Whether the target domain appears among extracted source domains. |
| `competitorMentions` | array | Competitor names found in the AI Overview text or fallback SERP text window. |
| `engineStatus` | string | `ok_aio`, `ok_no_aio`, `blocked`, `timeout`, or `error`. |
| `error` | string | Short error message when rendering or parsing fails. |
| `blockMarkers` | array | Detected block/CAPTCHA phrases when Google blocks the session. |
| `checkedAt` | string | UTC timestamp for the check. |
| `runtimeSeconds` | number | Runtime for that prompt attempt. |

### Use cases

- GEO / AEO monitoring for target prompts
- AI Overview source tracking
- Brand visibility checks
- Competitor visibility checks
- SEO source-gap research
- Weekly prompt monitoring for marketing teams

### Who should use it

This actor is useful when the question is not "what rank do I have in classic organic search?" but "does Google's AI answer show up, which brands are mentioned, and which external domains appear around that AI answer?"

Typical users:

- SEO teams tracking AI Overview exposure for commercial prompts
- content teams checking whether their domain appears near answer-style SERPs
- agencies monitoring client and competitor visibility across prompt lists
- SaaS teams watching category prompts such as "best CRM for small business"
- affiliate teams checking which publisher domains are surfaced for buyer-intent queries
- internal growth teams building weekly AEO/GEO dashboards

### Suggested monitoring workflow

1. Start with 5-20 high-intent prompts from Search Console, paid-search terms, sales calls, or competitor pages.
2. Run the actor with `maxConcurrency=1` and `timeoutSeconds=30`.
3. Export the dataset to Google Sheets, BigQuery, or a webhook.
4. Track these weekly fields: `aiOverviewAvailable`, `targetBrandMentioned`, `targetDomainCited`, `sourceDomains`, and `competitorMentions`.
5. Split prompts into buckets:
   - AIO exists and your brand/domain appears: maintain and monitor.
   - AIO exists but competitors appear: improve topical coverage and citation-worthy pages.
   - AIO exists but only publishers/tools appear: identify source-gap opportunities.
   - No AIO: monitor less often or test related prompt variants.

### Prompt list examples

For SaaS:

```json
{
  "prompts": [
    "best CRM software for startups",
    "best email marketing software for ecommerce",
    "best customer support software for SaaS"
  ],
  "brandName": "HubSpot",
  "domain": "hubspot.com",
  "competitors": ["Salesforce", "Zoho", "Pipedrive"],
  "country": "US",
  "language": "en",
  "maxPrompts": 3,
  "timeoutSeconds": 30,
  "maxConcurrency": 1
}
```

For local services:

```json
{
  "prompts": [
    "best emergency plumber in Austin",
    "best HVAC repair company in Austin",
    "how much does water heater repair cost in Austin"
  ],
  "brandName": "Example Plumbing",
  "domain": "exampleplumbing.com",
  "competitors": ["Roto-Rooter", "Mr. Rooter"],
  "country": "US",
  "language": "en",
  "maxPrompts": 3
}
```

For affiliate/content sites:

```json
{
  "prompts": [
    "best standing desk for home office",
    "best ergonomic chair for back pain",
    "best monitor light bar"
  ],
  "brandName": "Example Reviews",
  "domain": "examplereviews.com",
  "competitors": ["Wirecutter", "Tom's Guide", "PCMag"],
  "country": "US",
  "language": "en"
}
```

### Comparison with classic SERP rank tracking

| Need | Classic rank tracker | Google AI Overview Tracker |
| --- | --- | --- |
| Track organic position | Yes | No |
| Detect whether AI Overview appears | No | Yes |
| Extract answer text | No | Yes, when AIO is present |
| Track brand mention in AI answer | No | Yes |
| Track domains surfaced near AI answer | Limited | Yes |
| Monitor competitor mentions in generated answer | No | Yes |
| Best cadence | Daily/weekly rankings | Weekly prompt visibility checks |

Use both when you need a complete search view: rank tracker for organic positions, this actor for AI Overview visibility.

### API usage

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("tugelbay/google-ai-overview-tracker").call(run_input={
    "prompts": ["best CRM software for small business"],
    "brandName": "HubSpot",
    "domain": "hubspot.com",
    "competitors": ["Zoho", "Pipedrive", "Salesforce"],
    "country": "US",
    "language": "en",
    "maxPrompts": 1,
    "timeoutSeconds": 30,
    "maxConcurrency": 1,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["prompt"], item["aiOverviewAvailable"], item["sourceDomains"])
```

#### JavaScript

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });

const run = await client.actor("tugelbay/google-ai-overview-tracker").call({
  prompts: ["best CRM software for small business"],
  brandName: "HubSpot",
  domain: "hubspot.com",
  competitors: ["Zoho", "Pipedrive", "Salesforce"],
  country: "US",
  language: "en",
  maxPrompts: 1,
  timeoutSeconds: 30,
  maxConcurrency: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Webhook / scheduled monitoring

Create an Apify Task with your prompt list, then schedule it weekly. Use a webhook on run success to send the dataset to:

- Google Sheets
- BigQuery
- Slack
- Make/Zapier
- your internal dashboard

### Validation

Validation snapshot from 2026-04-25. This actor was built only after a 20-prompt stability probe:

- 20/20 clean headless Google SERP checks
- 19/20 prompts showed an AI Overview
- 1/20 prompts cleanly returned no AI Overview
- Median local probe runtime: 3.0 seconds. Apify runtime varies with proxy/session state.

Related validation file:

`docs/research/google-ai-overview-tracker-validation-results.md`

### Limitations

- Google decides whether AI Overview appears. Some queries, countries, or sessions may return no AI Overview.
- Google SERP layouts change. The actor returns `engineStatus` and `error` fields so monitoring jobs can detect layout or block changes.
- Browser rendering is required; this is not a raw HTTP-only scraper.
- Keep concurrency low. The default is `1`, maximum is `3`.
- The default input checks one prompt to keep the Try-for-Free run short. Larger prompt lists cost more and can be more affected by Google blocking.

### Pricing

Pay per event:

- `prompt-check` - one event per prompt checked

Base price: `$0.01 / prompt-check`.

### Cost examples

| Run size | Input | Prompt-check events | Approx. prompt cost |
| --- | --- | ---: | ---: |
| First test | 1 prompt | 1 | ~$0.01 |
| Small category monitor | 10 prompts | 10 | ~$0.10 |
| Weekly SaaS prompt set | 50 prompts | 50 | ~$0.50 |
| Four weekly 50-prompt checks | 200 prompts/month | 200 | ~$2.00/month |

Actual platform cost also depends on Apify compute/runtime and your account plan. Keep prompt batches small until you know how often AIO appears for your niche.

### Troubleshooting

| Issue | Likely cause | What to do |
| --- | --- | --- |
| `aiOverviewAvailable=false` | Google did not show an AI Overview for that query/session/country | This is a valid result. Try related prompts or another country/language. |
| `engineStatus=blocked` | Google showed CAPTCHA, unusual-traffic, or block text | Keep `maxConcurrency=1`, use residential proxy, retry later, or reduce batch size. |
| `engineStatus=timeout` | SERP or AIO did not finish rendering within timeout | Increase `timeoutSeconds` to 45-60 for harder prompts. |
| Empty `answerText` with source links | Classic SERP links were available but no AIO text was detected | Treat as no-AIO or inspect the rendered SERP manually. |
| Competitor not detected | Name spelling differs from input | Add short brand variants to `competitors`, for example `Salesforce` and `Salesforce CRM`. |
| Target domain not cited | Domain does not appear in extracted external source links | Use `sourceDomains` to identify which domains are currently surfaced. |

### FAQ

#### Does this track ChatGPT, Gemini, Perplexity, Claude, Copilot, Grok, or Meta AI?

No. This actor intentionally supports Google AI Overview only. Other engines require separate validation because login, browser mode, rendering behavior, and source extraction differ.

#### Is `sourceLinks` exactly the same as AI Overview citations?

No. The actor returns external source links found on the rendered SERP after Google wrapper links are cleaned and Google-owned domains are filtered. This is useful for source-domain monitoring, but it should not be treated as a guaranteed one-to-one list of AIO citation cards.

#### Why does the same prompt sometimes return different results?

Google personalizes and experiments with SERP layouts. Country, language, time, browser session, proxy, and Google's own AIO rollout can change whether an AI Overview appears.

#### Should I run this daily?

For most teams, weekly is enough. AI Overview visibility can move, but daily checks may add noise and cost before you have a stable prompt set.

#### Can I use this for client reporting?

Yes, if you explain the metric correctly: it tracks AI Overview availability, answer text, brand/domain visibility, and extracted external source domains for specific prompts at a specific time.

#### What is a good first prompt set?

Start with 10-20 prompts that already matter to the business: high-impression Search Console queries, paid search terms, "best X" category searches, sales objections, and competitor-comparison prompts.

### Data quality notes

- No-AIO is a valid output, not a failed run.
- `engineStatus` should be monitored; filter out `blocked`, `timeout`, and `error` before calculating visibility rates.
- Use exact brand names and common short variants in `competitors`.
- Keep prompt wording stable over time if you want trend charts.
- Store raw datasets for repeatable historical reporting.

### Reporting template

For a weekly report, group the dataset by prompt and track these columns:

| Metric | How to calculate |
| --- | --- |
| AIO coverage | Count rows where `aiOverviewAvailable=true` divided by total valid rows. |
| Brand visibility | Count rows where `targetBrandMentioned=true` divided by rows with AIO. |
| Domain visibility | Count rows where `targetDomainCited=true` divided by rows with source domains. |
| Competitor pressure | Count prompts where `competitorMentions` is not empty. |
| Source diversity | Count unique `sourceDomains` across the prompt set. |
| Block/error rate | Count `blocked`, `timeout`, and `error` statuses divided by total rows. |

Keep the report honest by separating visibility changes from collection quality. A week with many `blocked` or `timeout` rows should be marked as a data-quality issue, not as a real visibility drop.

### Good prompt hygiene

- Use searcher language, not internal product jargon.
- Avoid changing prompt wording every week if you need trend lines.
- Include buying-intent prompts, comparison prompts, and problem-aware prompts.
- Keep country/language stable for each tracked prompt set.
- Do not mix unrelated markets in one dashboard; separate SaaS, local, ecommerce, and affiliate prompts.
- Add competitor aliases when brand names have common abbreviations.
- Review no-AIO prompts monthly and replace prompts that never trigger useful AI Overview data.

### Operational guardrails

Large prompt lists are supported, but small batches are easier to debug. A practical operating pattern is:

1. validate 1 prompt;
2. run 10 prompts;
3. inspect `engineStatus` distribution;
4. expand to 25-50 prompts;
5. schedule weekly;
6. alert only on valid rows, not on blocked/error rows.

If you need hundreds of prompts, split them into multiple Tasks by category, country, or client. That keeps datasets easier to inspect and reduces the chance that one transient block affects the whole report.

### Changelog

- **0.1.10** (2026-04-26) - expanded README, clarified source-link semantics, and kept one-prompt first-run path.
- **0.1** (2026-04-26) - initial Google AI Overview-only MVP.

# Actor input Schema

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

Search prompts to check in Google. Each prompt opens one rendered Google SERP and returns one dataset item. Start with one prompt.

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

Brand to check for in the AI Overview text.

## `domain` (type: `string`):

Domain to check for in cited source links.

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

Competitor names to detect in the AI Overview text.

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

Two-letter Google country code used as the gl parameter.

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

Google interface language used as the hl parameter.

## `maxPrompts` (type: `integer`):

Maximum prompts to process from the list. Start small; each prompt opens a rendered Google SERP.

## `timeoutSeconds` (type: `integer`):

Maximum seconds to wait for AI Overview or a clean no-AIO SERP.

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

Number of Google SERP pages to render in parallel. Keep low to reduce blocks.

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

Apify residential proxy is recommended for Google SERP browser rendering. The GOOGLE\_SERP group is HTTP-only and not compatible with Playwright HTTPS navigation.

## Actor input object example

```json
{
  "prompts": [
    "best CRM software for small business"
  ],
  "brandName": "HubSpot",
  "domain": "hubspot.com",
  "competitors": [
    "Zoho",
    "Pipedrive",
    "Salesforce"
  ],
  "country": "US",
  "language": "en",
  "maxPrompts": 1,
  "timeoutSeconds": 30,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "prompts": [
        "best CRM software for small business"
    ],
    "brandName": "HubSpot",
    "domain": "hubspot.com",
    "competitors": [
        "Zoho",
        "Pipedrive",
        "Salesforce"
    ],
    "country": "US",
    "language": "en",
    "maxPrompts": 1,
    "timeoutSeconds": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tugelbay/google-ai-overview-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 = {
    "prompts": ["best CRM software for small business"],
    "brandName": "HubSpot",
    "domain": "hubspot.com",
    "competitors": [
        "Zoho",
        "Pipedrive",
        "Salesforce",
    ],
    "country": "US",
    "language": "en",
    "maxPrompts": 1,
    "timeoutSeconds": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tugelbay/google-ai-overview-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 '{
  "prompts": [
    "best CRM software for small business"
  ],
  "brandName": "HubSpot",
  "domain": "hubspot.com",
  "competitors": [
    "Zoho",
    "Pipedrive",
    "Salesforce"
  ],
  "country": "US",
  "language": "en",
  "maxPrompts": 1,
  "timeoutSeconds": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call tugelbay/google-ai-overview-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google AI Overview Tracker API",
        "description": "Track Google AI Overview visibility for search prompts. Extract AIO availability, answer text, cited source links, source domains, brand/domain citations, competitor mentions, and clean no-AIO status.",
        "version": "0.1",
        "x-build-id": "QOsYfhm6W7Yd1S9OB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tugelbay~google-ai-overview-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tugelbay-google-ai-overview-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/tugelbay~google-ai-overview-tracker/runs": {
            "post": {
                "operationId": "runs-sync-tugelbay-google-ai-overview-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/tugelbay~google-ai-overview-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-tugelbay-google-ai-overview-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": [
                    "prompts"
                ],
                "properties": {
                    "prompts": {
                        "title": "Prompts / search queries",
                        "type": "array",
                        "description": "Search prompts to check in Google. Each prompt opens one rendered Google SERP and returns one dataset item. Start with one prompt.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandName": {
                        "title": "Target brand",
                        "type": "string",
                        "description": "Brand to check for in the AI Overview text."
                    },
                    "domain": {
                        "title": "Target domain",
                        "type": "string",
                        "description": "Domain to check for in cited source links."
                    },
                    "competitors": {
                        "title": "Competitors",
                        "type": "array",
                        "description": "Competitor names to detect in the AI Overview text.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Google country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "IN"
                        ],
                        "type": "string",
                        "description": "Two-letter Google country code used as the gl parameter.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Google language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es"
                        ],
                        "type": "string",
                        "description": "Google interface language used as the hl parameter.",
                        "default": "en"
                    },
                    "maxPrompts": {
                        "title": "Max prompts",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum prompts to process from the list. Start small; each prompt opens a rendered Google SERP.",
                        "default": 1
                    },
                    "timeoutSeconds": {
                        "title": "Timeout per prompt",
                        "minimum": 10,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Maximum seconds to wait for AI Overview or a clean no-AIO SERP.",
                        "default": 30
                    },
                    "maxConcurrency": {
                        "title": "Browser concurrency",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Number of Google SERP pages to render in parallel. Keep low to reduce blocks.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify residential proxy is recommended for Google SERP browser rendering. The GOOGLE_SERP group is HTTP-only and not compatible with Playwright HTTPS navigation.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
