# SEO Service Area Visibility Checker (`solutionssmart/seo-service-area-visibility`) Actor

Checks how visible a business is in Google across multiple service areas and generates an SEO visibility report.

- **URL**: https://apify.com/solutionssmart/seo-service-area-visibility.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** SEO tools, Lead generation, Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## SEO Service Area Visibility Checker

### What does SEO Service Area Visibility Checker do?

SEO Service Area Visibility Checker helps you measure how visible your business is in [Google Search](https://www.google.com) across multiple cities and service areas. You can track keyword rankings, spot visibility gaps, and see which competitors dominate local search results.

The Actor can extract:

- Keyword rankings for your domain across multiple cities
- Competitor websites appearing in search results
- Service area visibility gaps and missing rankings
- Detailed SERP data with position tracking
- Diagnostic reports when anti-bot or consent pages are encountered

### Why check SEO visibility across service areas?

Businesses that operate in multiple cities or service areas need to understand how visible they are in local search results. Geographic SEO performance directly impacts customer acquisition, as users often search with local intent, for example `plumber in Hannover`.

Here are some ways you could use this visibility data:

- Monitor your local SEO performance across all service areas
- Identify which cities or keywords need SEO improvement
- Track competitor presence in your target markets
- Optimize content strategy based on visibility gaps
- Prove SEO results to clients with structured reports
- Make data-driven decisions about geographic expansion

### Best for

- Local SEO agencies
- Plumbers, HVAC companies, electricians, roofers, and other local service businesses
- Businesses expanding into nearby cities
- Teams reporting local SEO performance to clients

### How to check SEO visibility

It is easy to check SEO visibility across service areas with SEO Service Area Visibility Checker:

1. Click on **Try for free**.
2. Enter your target domain, for example `example.de`, together with the keywords and cities or service areas you want to analyze.
3. Optionally configure country, language, maximum number of results, retries, retry backoff, sticky proxy behavior, proxy rotation, homepage warmup, and debug artifact storage.
4. Click **Run**.
5. When the Actor finishes, review the final report in the **Dataset** tab or open the HTML report from the key-value store output.

### Input parameters

```json
{
    "targetDomain": "example.de",
    "keywords": ["Sanitaer", "Heizung", "Installateur"],
    "cities": ["Hameln", "Bad Muender", "Hannover", "Hildesheim"],
    "country": "DE",
    "language": "de",
    "maxResults": 10,
    "maxQueryRetries": 2,
    "retryBackoffMs": 4000,
    "stickyProxySession": true,
    "rotateProxySession": true,
    "warmupGoogleHome": false,
    "warmupOnRetries": false,
    "disableWarmupAfterBlock": true,
    "saveDebugArtifacts": true,
    "saveDebugArtifactsOnRetries": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
````

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `targetDomain` | string | Yes | Bare domain to track, for example `example.de` |
| `keywords` | array | Yes | Service keywords to check in each city |
| `cities` | array | Yes | Cities or service areas to analyze |
| `country` | string | No | Google country code, default `DE` |
| `language` | string | No | Google interface language code, default `de` |
| `maxResults` | integer | No | Maximum number of organic results to inspect per query, default `10` |
| `maxQueryRetries` | integer | No | Number of retries after anti-bot pages or transient failures |
| `retryBackoffMs` | integer | No | Base delay in milliseconds before each retry. Stronger blockers such as anti-bot pages, CAPTCHAs, and HTTP `429` responses use a longer cooldown automatically |
| `stickyProxySession` | boolean | No | Keep one proxy session for a full query and rotate after stronger failure signals such as HTTP `429`, anti-bot pages, CAPTCHAs, or navigation timeouts |
| `rotateProxySession` | boolean | No | Use a fresh proxy session for retries when rotation is needed |
| `warmupGoogleHome` | boolean | No | Open the country-specific Google homepage before the SERP request to create a more natural session. Default `false` because some proxy profiles are blocked before search navigation begins |
| `warmupOnRetries` | boolean | No | Repeat homepage warmup on retry attempts. Default `false` to reduce extra requests on already blocked sessions |
| `disableWarmupAfterBlock` | boolean | No | Turn off homepage warmup for the rest of the run after the first anti-bot or CAPTCHA signal |
| `saveDebugArtifacts` | boolean | No | Save screenshots and HTML diagnostics for blocked or unexpected pages |
| `saveDebugArtifactsOnRetries` | boolean | No | Continue saving screenshots and HTML diagnostics on retry attempts. Default `false` to reduce storage noise |
| `proxyConfiguration` | object | No | Optional Apify proxy settings for reducing Google anti-bot blocking |

### Output

The Actor produces a visibility report containing:

- **summary**: Overall visibility metrics and run statistics, including `visibilityScore`, data quality, failure breakdowns, and sample URLs for troubleshooting
- **visibilityByCity**: Ranking visibility broken down by city
- **missingCities**: Service areas where your domain was not found
- **competitors**: Domains appearing frequently in organic results
- **pricing**: Metered visibility checks, pricing model details, and spending-limit status
- **recommendations**: Suggested next steps for SEO improvement or technical troubleshooting
- **detailedResults**: Complete keyword-by-keyword SERP data, attempt history, and diagnostics

Output is stored in:

- The default dataset as a final report item
- The default key-value store under the `OUTPUT` key
- A styled HTML dashboard report under the `OUTPUT.html` key
- Persistent run history under the `REPORT_HISTORY` key
- Debug screenshots and diagnostics when anti-bot or consent pages are encountered

### HTML report example

You can preview a live example of the generated HTML dashboard here:

[Open the HTML report example](https://api.apify.com/v2/key-value-stores/qz4OIyhLb6uGnoVtg/records/OUTPUT.html#summary)

Snapshot of the HTML report:

![HTML report example](https://api.apify.com/v2/key-value-stores/4Ndd3s4IJ5eemDx1r/records/output-html-snapshot.png)

### Results example

In this example, the domain ranks in some cities and is missing in others, highlighting a service-area gap.

```json
{
    "summary": {
        "targetDomain": "example.de",
        "totalCities": 4,
        "visibleCities": 2,
        "notVisibleCities": 2,
        "visibilityScore": 50,
        "totalKeywordCityCombinations": 12,
        "checkedCombinations": 12,
        "dataQuality": {
            "successfulQueries": 12,
            "failedQueries": 0,
            "successRate": 100
        }
    },
    "visibilityByCity": [
        {
            "city": "Hameln",
            "visible": true,
            "bestRank": 3,
            "keywordsFound": ["Sanitaer", "Heizung"],
            "queriesProcessed": 3,
            "queriesFailed": 0
        },
        {
            "city": "Bad Muender",
            "visible": false,
            "bestRank": null,
            "keywordsFound": [],
            "queriesProcessed": 3,
            "queriesFailed": 0
        }
    ],
    "missingCities": ["Bad Muender", "Hildesheim"],
    "competitors": [
        { "domain": "competitor1.de", "count": 6 },
        { "domain": "competitor2.de", "count": 4 }
    ],
    "pricing": {
        "pricingModel": "PAY_PER_EVENT",
        "isPayPerEvent": true,
        "totalPlannedChecks": 12,
        "completedChecks": 12,
        "meteredChecks": 12,
        "spendingLimitReached": false
    },
    "status": "success",
    "message": "Successfully analyzed 12 out of 12 queries."
}
```

### How much will it cost?

This Actor uses Apify pay-per-event monetization with one `visibility-check` event for each keyword-plus-city analysis that returns parseable SERP data.

That means a run with 3 keywords across 4 cities plans 12 billable visibility checks. The exact event price is configured in Apify Console, and the Actor respects the maximum spend allowed for the run.

Apify gives you $5 in monthly credits on the [Apify Free plan](https://apify.com/pricing), which can be enough to test the Actor or run smaller checks.

For ongoing monitoring across larger keyword and city sets, the [Starter plan](https://apify.com/pricing) or [Scale plan](https://apify.com/pricing) may be a better fit depending on your usage.

### Tips for checking SEO visibility

- Run checks regularly, for example weekly or monthly, to track ranking changes over time
- Start with your most important keywords and service areas
- Use competitor data to analyze what is working in your market
- Check both branded and service-based keywords for a fuller visibility picture
- Review the recommendations section for actionable next steps
- If diagnostic reports appear, use them to understand whether drops are caused by ranking changes or technical blocking

### Recommended Google settings

For Google SERP checks, this is the recommended starting configuration:

```json
{
    "maxQueryRetries": 2,
    "retryBackoffMs": 4000,
    "stickyProxySession": true,
    "rotateProxySession": true,
    "warmupGoogleHome": false,
    "warmupOnRetries": false,
    "disableWarmupAfterBlock": true,
    "saveDebugArtifacts": true,
    "saveDebugArtifactsOnRetries": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

This avoids spending the first attempt on a homepage session that may already be blocked, reduces extra request noise on retries, and avoids filling storage with near-duplicate retry diagnostics.

### Technical notes

- The Actor uses Playwright because Google SERPs often require browser automation
- Google anti-bot measures can vary, so some runs may return partial data
- When extraction fails because of consent pages or CAPTCHAs, detailed diagnostics are saved to help troubleshoot
- Results use Google UULE location targeting for city-specific search simulation
- For better reliability against blocking, you can enable `proxyConfiguration`
- Sticky proxy sessions help keep one residential identity for a full query, while stronger failure signals can still trigger a fresh session on retry
- Retries can relaunch the browser with a fresh proxy session when blocking is detected
- Repeated anti-bot or CAPTCHA pages use a longer exponential cooldown before retrying
- The Actor attempts to accept Google consent dialogs before classifying a run as failed
- Each run refreshes an HTML dashboard and stores recent report history for comparison
- Each query that returns parseable SERP data can be metered through Apify pay-per-event pricing

### Is it legal to check SEO visibility?

Checking search visibility for websites is a standard SEO activity. If you combine these results with personal data in your own workflows, make sure you comply with applicable privacy laws. For more information, see Apify's blog post on [web scraping and the law](https://blog.apify.com/is-web-scraping-legal/).

### Feedback and rating

If SEO Service Area Visibility Checker helps you, please consider leaving a rating on Apify and sharing a short review about your experience.

If you have ideas for improvements, want additional features, or run into issues, your feedback is very welcome. User feedback helps improve the Actor and prioritize the next updates.

# Actor input Schema

## `targetDomain` (type: `string`):

The bare domain to check for in Google results, for example example.de.

## `keywords` (type: `array`):

Service keywords to search in each city.

## `cities` (type: `array`):

Cities or service areas where visibility should be checked.

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

Choose the Google country code used in the search query.

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

Choose the Google interface language code used for the search results page.

## `maxResults` (type: `integer`):

Maximum number of organic results to inspect per query.

## `maxQueryRetries` (type: `integer`):

How many times to retry a query after anti-bot pages or transient failures.

## `retryBackoffMs` (type: `integer`):

Base delay in milliseconds before retrying blocked or failed queries.

## `stickyProxySession` (type: `boolean`):

Keep the same proxy session for a full query and rotate only after harder blocks such as HTTP 429 responses.

## `rotateProxySession` (type: `boolean`):

When enabled, retries can use a fresh proxy session instead of reusing the original one.

## `warmupGoogleHome` (type: `boolean`):

Open the Google homepage before the search request to establish a more natural browser session.

## `warmupOnRetries` (type: `boolean`):

Repeat the Google homepage warmup on retry attempts. Disable to reduce extra requests and proxy noise.

## `disableWarmupAfterBlock` (type: `boolean`):

After the first anti-bot or CAPTCHA page in a run, stop using Google homepage warmup for later attempts.

## `saveDebugArtifacts` (type: `boolean`):

Store screenshots and HTML diagnostics for blocked or unexpected pages.

## `saveDebugArtifactsOnRetries` (type: `boolean`):

Keep saving screenshots and HTML diagnostics on retry attempts after the first blocked page.

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

Optional proxy settings for reducing Google anti-bot blocking.

## Actor input object example

```json
{
  "targetDomain": "example.de",
  "keywords": [
    "Sanitär",
    "Heizung",
    "Installateur"
  ],
  "cities": [
    "Hameln",
    "Bad Münder",
    "Hannover",
    "Hildesheim"
  ],
  "country": "DE",
  "language": "de",
  "maxResults": 10,
  "maxQueryRetries": 2,
  "retryBackoffMs": 4000,
  "stickyProxySession": true,
  "rotateProxySession": true,
  "warmupGoogleHome": false,
  "warmupOnRetries": false,
  "disableWarmupAfterBlock": true,
  "saveDebugArtifacts": true,
  "saveDebugArtifactsOnRetries": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `report` (type: `string`):

No description

## `htmlReport` (type: `string`):

No description

## `reportHistory` (type: `string`):

No description

## `keyValueStore` (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 = {
    "keywords": [
        "Sanitär",
        "Heizung",
        "Installateur"
    ],
    "cities": [
        "Hameln",
        "Bad Münder",
        "Hannover",
        "Hildesheim"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/seo-service-area-visibility").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 = {
    "keywords": [
        "Sanitär",
        "Heizung",
        "Installateur",
    ],
    "cities": [
        "Hameln",
        "Bad Münder",
        "Hannover",
        "Hildesheim",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/seo-service-area-visibility").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 '{
  "keywords": [
    "Sanitär",
    "Heizung",
    "Installateur"
  ],
  "cities": [
    "Hameln",
    "Bad Münder",
    "Hannover",
    "Hildesheim"
  ]
}' |
apify call solutionssmart/seo-service-area-visibility --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solutionssmart/seo-service-area-visibility",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEO Service Area Visibility Checker",
        "description": "Checks how visible a business is in Google across multiple service areas and generates an SEO visibility report.",
        "version": "0.1",
        "x-build-id": "qjSkVhopRiEZNqM7H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~seo-service-area-visibility/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-seo-service-area-visibility",
                "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/solutionssmart~seo-service-area-visibility/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-seo-service-area-visibility",
                "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/solutionssmart~seo-service-area-visibility/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-seo-service-area-visibility",
                "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": [
                    "targetDomain",
                    "keywords",
                    "cities"
                ],
                "properties": {
                    "targetDomain": {
                        "title": "Target Domain",
                        "pattern": "^(?!https?://)(?!www\\.$)[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$",
                        "type": "string",
                        "description": "The bare domain to check for in Google results, for example example.de."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Service keywords to search in each city.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "Sanitär",
                            "Heizung",
                            "Installateur"
                        ]
                    },
                    "cities": {
                        "title": "Cities",
                        "minItems": 1,
                        "type": "array",
                        "description": "Cities or service areas where visibility should be checked.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "Hameln",
                            "Bad Münder",
                            "Hannover",
                            "Hildesheim"
                        ]
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "DE",
                            "US",
                            "GB",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "PL",
                            "AT",
                            "CH"
                        ],
                        "type": "string",
                        "description": "Choose the Google country code used in the search query.",
                        "default": "DE"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "de",
                            "en",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "pl"
                        ],
                        "type": "string",
                        "description": "Choose the Google interface language code used for the search results page.",
                        "default": "de"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of organic results to inspect per query.",
                        "default": 10
                    },
                    "maxQueryRetries": {
                        "title": "Max Query Retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry a query after anti-bot pages or transient failures.",
                        "default": 2
                    },
                    "retryBackoffMs": {
                        "title": "Retry Backoff (ms)",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Base delay in milliseconds before retrying blocked or failed queries.",
                        "default": 4000
                    },
                    "stickyProxySession": {
                        "title": "Sticky Proxy Session",
                        "type": "boolean",
                        "description": "Keep the same proxy session for a full query and rotate only after harder blocks such as HTTP 429 responses.",
                        "default": true
                    },
                    "rotateProxySession": {
                        "title": "Rotate Proxy Session",
                        "type": "boolean",
                        "description": "When enabled, retries can use a fresh proxy session instead of reusing the original one.",
                        "default": true
                    },
                    "warmupGoogleHome": {
                        "title": "Warm Up Google Home",
                        "type": "boolean",
                        "description": "Open the Google homepage before the search request to establish a more natural browser session.",
                        "default": false
                    },
                    "warmupOnRetries": {
                        "title": "Warm Up On Retries",
                        "type": "boolean",
                        "description": "Repeat the Google homepage warmup on retry attempts. Disable to reduce extra requests and proxy noise.",
                        "default": false
                    },
                    "disableWarmupAfterBlock": {
                        "title": "Disable Warmup After Block",
                        "type": "boolean",
                        "description": "After the first anti-bot or CAPTCHA page in a run, stop using Google homepage warmup for later attempts.",
                        "default": true
                    },
                    "saveDebugArtifacts": {
                        "title": "Save Debug Artifacts",
                        "type": "boolean",
                        "description": "Store screenshots and HTML diagnostics for blocked or unexpected pages.",
                        "default": true
                    },
                    "saveDebugArtifactsOnRetries": {
                        "title": "Save Debug Artifacts On Retries",
                        "type": "boolean",
                        "description": "Keep saving screenshots and HTML diagnostics on retry attempts after the first blocked page.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings for reducing Google anti-bot blocking.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
