# Google Maps Business Scraper (`johnatan029/google-maps-business-scraper`) Actor

Collect public Google Maps business listings for lead generation and local market research. Get names, categories, structured addresses, phones, websites, ratings, coordinates, CIDs, source queries, and ranks. Supports JSON, CSV, Excel, API, and scheduled runs.

- **URL**: https://apify.com/johnatan029/google-maps-business-scraper.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 25.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 business results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Maps Business Scraper

Collect public Google Maps business profiles for lead generation, local marketresearch, competitor comparison, and CRM preparation.

This Actor uses Python, Playwright, Chrome, and the official Apify proxyconfiguration. It does not use the Google Places API, a Google account,authenticated cookies, or an API key.

What this Actor does

For every search query or supported public Google Maps search URL, the Actor:

opens the public Google Maps search page;

handles a public consent screen when one appears;

discovers unique /maps/place/ links from the results page;

preserves the position of each business in the search results;

opens each public business detail page;

extracts evidenced public business information;

applies per-query and global limits;

removes duplicates within each search context;

records quality checks, warnings, retries, and stop reasons in STATS;

writes business records to the default dataset.

The Actor can continue when Google Maps exposes valid place links even when asemantic results feed is not present.

Use cases

Lead generation — build structured lists of local businesses.

Local market research — compare companies operating in a city or region.

Competitor research — inspect categories, ratings, websites, phones, and locations.

CRM preparation — export structured business records to JSON, CSV, Excel, or API.

Location datasets — collect coordinates, structured addresses, Maps URLs, and CIDs.

Input

Provide at least one non-empty searchQueries item or one valid searchUrlsitem.

Field

Type

Default

Rules

searchQueries

string array

[]

Blank and case-insensitive duplicate queries are removed.

searchUrls

request-list array

[]

Accepts URL strings and { "url": "..." }. Only supported public google.com/maps/search routes are accepted.

maxPlacesPerQuery

integer

20

Minimum 1, maximum 200.

maxTotalPlaces

integer

100

Minimum 1, maximum 2,000.

language

string

en

Supported values: en, pt-BR, es, de, fr, and it.

proxyCountryCode

string

US

Exactly two letters, normalized to uppercase.

includeOpeningHours

boolean

true

When false, openingHours is returned as null.

includeContactDetails

boolean

true

When false, phone and website fields are returned as null.

debug

boolean

false

Saves screenshots and HTML for successful pages. Error and block evidence may be saved independently.

Small input example

{
  "searchQueries": [
    "dentists in Albany, NY"
  ],
  "searchUrls": [],
  "maxPlacesPerQuery": 5,
  "maxTotalPlaces": 5,
  "language": "en",
  "proxyCountryCode": "US",
  "includeOpeningHours": true,
  "includeContactDetails": true,
  "debug": false
}

Queries are converted to public search URLs such as:

https://www.google.com/maps/search/?api=1&query=<QUERY_ENCODED>

Invalid input produces a controlled INPUT_ERROR and a failed run.

Invalid search URLs are counted and ignored when another valid query or URLexists. The run fails with ALL_QUERIES_FAILED when no search context completessuccessfully.

Dataset output

The Actor produces one dataset record per collected business.

Missing scalar values are returned as null. categories is always an array.openingHours is a normalized object when successfully extracted, otherwisenull.

Visible text is Unicode-normalized, leading interface glyphs are removed, andknown marketing parameters are removed from business website URLs.

Structured address components are extracted only when supported by evidencefrom the page or by a conservative address parser. The search query is neverused to invent a business address.

Real output example

The following record came from a successful controlled run fordentists in Albany, NY:

{
  "name": "Dental Wellness of Albany",
  "primaryCategory": "Dentist",
  "categories": [
    "Dentist"
  ],
  "address": "651 Delaware Ave, Albany, NY 12209",
  "neighborhood": null,
  "city": "Albany",
  "state": "NY",
  "postalCode": "12209",
  "country": "United States",
  "countryCode": "US",
  "phone": "+15184272447",
  "phoneUnformatted": "+15184272447",
  "website": "https://www.651dental.com/",
  "rating": 4.9,
  "reviewCount": null,
  "priceLevel": null,
  "businessStatus": null,
  "openingHours": null,
  "latitude": 42.6350596,
  "longitude": -73.7950078,
  "placeId": null,
  "cid": "12250295333788525579",
  "googleMapsUrl": "https://www.google.com/maps/place/Dental+Wellness+of+Albany/data=!4m7!3m6!1s0x89de0a7e2759f93f:0xaa01cab38417240b!8m2!3d42.6350596!4d-73.7950078!16s%2Fg%2F1tklrkb5!19sChIJP_lZJ34K3okRCyQXhLPKAao",
  "searchQuery": "dentists in Albany, NY",
  "searchUrl": "https://www.google.com/maps/search/?api=1&query=dentists+in+Albany%2C+NY",
  "rank": 1,
  "language": "en",
  "scrapedAt": "2026-07-25T19:36:16.370587Z"
}

Output fields

Field

Description

name

Business name.

primaryCategory

Main category shown for the business.

categories

Available business categories.

address

Visible full address after text cleanup.

neighborhood

Neighborhood when evidenced, otherwise null.

city

City when evidenced or conservatively parsed.

state

State or region when evidenced or conservatively parsed.

postalCode

Postal or ZIP code when evidenced or conservatively parsed.

country

Country name when evidenced.

countryCode

Two-letter country code when evidenced.

phone

Normalized phone number when available.

phoneUnformatted

Phone representation retained by the extractor.

website

Business website with known tracking parameters removed.

rating

Rating shown by Google Maps.

reviewCount

Review or rating count when reliably identified; otherwise null.

priceLevel

Price level when present, otherwise null.

businessStatus

Public business status when present, otherwise null.

openingHours

Structured opening hours when reliably available, otherwise null.

latitude

Latitude parsed from public Maps data.

longitude

Longitude parsed from public Maps data.

placeId

Google place identifier when explicitly evidenced, otherwise null.

cid

Decimal Google CID extracted from a supported public Maps URL pattern.

googleMapsUrl

Public Google Maps business URL.

searchQuery

Original search query, when query input was used.

searchUrl

Search URL used for the record.

rank

Position discovered within the search context.

language

Requested interface language.

scrapedAt

UTC timestamp of extraction.

Dataset views

The dataset includes three views:

Leads — business, category, contact, rating, source, and rank.

Map data — structured address, coordinates, identifiers, and Maps URL.

Full details — every documented public output field.

Deduplication and limits

Deduplication is scoped to one search context.

The same business may be retained in different searches because its searchcontext and rank can be useful.

Identity evidence is checked in this order:

placeId;

cid;

canonical Google Maps URL;

normalized name + address.

maxPlacesPerQuery limits the results returned for each query.

maxTotalPlaces is a hard run-wide dataset limit.

Search collection can also stop when:

the requested per-query limit is reached;

the global limit is reached;

the results stop changing;

an end marker appears;

the scroll safety limit is reached.

Stop reasons are recorded in STATS.capReasons.

Reliability and block handling

Google Maps is a dynamic web application and its public interface can change.

The Actor uses:

bounded navigation and extraction timeouts;

fresh browser contexts and proxy sessions for retries;

block and captcha detection;

controlled retry limits;

bounded screenshot and HTML evidence;

progress logs for search and detail stages;

partial and final STATS records.

Known blocking or suspicious signals include:

captcha or reCAPTCHA pages;

unusual-traffic messages;

Google /sorry/ routes;

account or login redirects;

a search page with no feed, no place links, and no legitimate no-results marker;

a detail page where no business identity can be established.

Normal pages are not saved unless debug is enabled.

The Actor never fabricates missing values.

A run that ends with zero collected places fails explicitly with
EMPTY_RESULTS unless every search context reported a legitimate public
no-results page. The Actor never reports success with a silently empty
dataset.

STATS

The final STATS key-value record includes run totals, missing-field counters,quality alerts, stop reasons, and a summary for each search context.

Real STATS example

This example came from the same successful five-result run:

{
  "inputQueries": 1,
  "validSearchUrls": 0,
  "invalidSearchUrls": 0,
  "queriesSucceeded": 1,
  "queriesFailed": 0,
  "placesDiscovered": 5,
  "placesCollected": 5,
  "duplicatesSkipped": 0,
  "detailPagesOpened": 5,
  "blockedPages": 0,
  "consentPages": 0,
  "retries": 0,
  "missingNameCount": 0,
  "missingAddressCount": 0,
  "missingPhoneCount": 0,
  "missingWebsiteCount": 0,
  "missingCoordinatesCount": 0,
  "missingReviewCountCount": 5,
  "missingStructuredAddressCount": 0,
  "missingCityCount": 0,
  "missingStateCount": 0,
  "missingPostalCodeCount": 0,
  "missingCountryCount": 0,
  "missingCidCount": 0,
  "qualityAlert": true,
  "warnings": [
    "Review count quality alert: more than 20% of records have a rating but no reviewCount."
  ],
  "capReasons": [
    "per_query_limit"
  ],
  "querySummary": [
    {
      "key": "query-1",
      "searchQuery": "dentists in Albany, NY",
      "searchUrl": "https://www.google.com/maps/search/?api=1&query=dentists+in+Albany%2C+NY",
      "status": "succeeded",
      "placesDiscovered": 5,
      "placesCollected": 5,
      "reason": "per_query_limit",
      "attempt": null,
      "stage": "complete",
      "elapsedSeconds": 34.494,
      "lastError": null
    }
  ]
}

Quality alerts are raised when:

more than 5% of records lack name or googleMapsUrl;

more than 30% have an address but insufficient structured components;

more than 20% have a rating but no reviewCount;

more than 20% contain a detectable CID pattern but no extracted cid.

A quality alert does not automatically mean the run failed. It indicates thatthe returned dataset should be reviewed for the fields named in warnings.

Known limitations

Review count is best-effort. Google Maps can expose ratings without areliably identifiable review count. In that case, reviewCount is null andthe condition is reported in STATS.

Opening hours are optional. They may be unavailable or not reliablyexposed in a supported structure.

Place ID is optional. cid may be available even when placeId is not.

Localized interfaces vary. Labels and number formats can differ bylanguage and country.

Some businesses omit fields. Phone, website, address components,business status, price level, and coordinates are not guaranteed.

Google Maps changes over time. Public page structure, ARIA labels, andembedded data can change.

Websites

Known marketing parameters are removed from collected website URLs:

utm_source
utm_medium
utm_campaign
utm_term
utm_content
gclid
fbclid
gbraid
wbraid

Unknown query parameters are preserved because they may be required for thewebsite to function.

Data intentionally not collected

The Actor does not collect:

email addresses;

review text;

reviewer profiles;

authenticated or private data;

data from logged-in Google accounts.

It does not use the Google Places API and does not bypass account accesscontrols.

Cost and scheduling

Runtime cost depends on:

number of searches;

requested result limits;

detail pages opened;

proxy usage;

retries;

browser duration.

A controlled run collecting five businesses completed in approximately63 seconds and incurred an infrastructure cost of approximately USD 0.062 forthe Actor owner. Actual cost can vary.

For repeated monitoring, use Apify Schedules and keep explicit result and costlimits.

Development validation

The project was validated with offline unit tests, synthetic fixtures, Pythoncompilation checks, JSON validation, Apify schema validation, remote builds,and controlled live runs.

The production package does not include internal tests, fixtures, prompts, orvalidation reports.

PT-BR — Resumo

Este Actor coleta perfis públicos de empresas no Google Maps para prospecção,pesquisa de mercado local, análise de concorrentes e preparação de CRM.

Ele recebe consultas ou URLs públicas de busca, encontra empresas, abre aspáginas públicas de detalhes e retorna dados estruturados como:

nome;

categoria;

endereço;

cidade, estado, CEP e país;

telefone;

website;

avaliação;

coordenadas;

CID;

URL do Google Maps;

consulta de origem;

posição no resultado.

O Actor usa Python, Playwright, Chrome e proxy oficial da Apify. Ele não usa aAPI do Google Places, conta Google, cookies autenticados ou chave de API.

Campos ausentes ficam null. reviewCount, horários, placeId, nível de preçoe status da empresa são best-effort e podem não estar disponíveis.

Os limites por consulta e por run são rígidos. Métricas, avisos de qualidade,bloqueios, retentativas e motivos de parada ficam armazenados em STATS.

Em um teste controlado real, o Actor coletou cinco empresas em aproximadamente63 segundos, com custo de infraestrutura de aproximadamente USD 0.062 para oproprietário do Actor.

Changelog

1.0.8

Prefilled example input so the automated Store health test runs with a valid search.

Empty-dataset health check: a run that collects zero places without an explicit public no-results state now fails with EMPTY_RESULTS instead of succeeding silently.

Dead-selector detection: a rendered results page with zero place links now fails the search context explicitly.

1.0

Initial Python and Playwright implementation.

Search query and supported request-list URL inputs.

Public Google Maps search and detail extraction.

Per-query and global limits.

Contextual deduplication.

Retry, timeout, block-detection, and evidence controls.

Dataset views for Leads, Map data, and Full details.

Structured address extraction.

Unicode and interface-glyph cleanup.

Website tracking-parameter cleanup.

Decimal CID extraction from supported public Maps URL patterns.

Localized review-count parsing with best-effort output.

Expanded STATS quality metrics and warnings.

# Actor input Schema

## `searchQueries` (type: `array`):

Business search terms such as a category plus city. Duplicate and blank queries are removed.
## `searchUrls` (type: `array`):

Public Google Maps search URLs. API callers may also provide URL strings.
## `maxPlacesPerQuery` (type: `integer`):

Maximum number of dataset items produced for each query context.
## `maxTotalPlaces` (type: `integer`):

Hard global dataset item limit for the entire run.
## `language` (type: `string`):

Browser locale and output language context.
## `proxyCountryCode` (type: `string`):

Two-letter country code used by the official Apify proxy configuration.
## `includeOpeningHours` (type: `boolean`):

Extract normalized opening hours when publicly available.
## `includeContactDetails` (type: `boolean`):

Extract public phone and website fields.
## `debug` (type: `boolean`):

Save page screenshots and HTML for troubleshooting. Error and block evidence is saved regardless.

## Actor input object example

```json
{
  "searchQueries": [
    "dentists in Albany, NY"
  ],
  "searchUrls": [],
  "maxPlacesPerQuery": 5,
  "maxTotalPlaces": 5,
  "language": "en",
  "proxyCountryCode": "US",
  "includeOpeningHours": true,
  "includeContactDetails": true,
  "debug": false
}
````

# Actor output Schema

## `results` (type: `string`):

Business records stored in the default dataset.

## `stats` (type: `string`):

Quality, limits, failures, retries, and query summaries.

# 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 = {
    "searchQueries": [
        "dentists in Albany, NY"
    ],
    "maxPlacesPerQuery": 5,
    "maxTotalPlaces": 5,
    "language": "en",
    "proxyCountryCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/google-maps-business-scraper").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 = {
    "searchQueries": ["dentists in Albany, NY"],
    "maxPlacesPerQuery": 5,
    "maxTotalPlaces": 5,
    "language": "en",
    "proxyCountryCode": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/google-maps-business-scraper").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 '{
  "searchQueries": [
    "dentists in Albany, NY"
  ],
  "maxPlacesPerQuery": 5,
  "maxTotalPlaces": 5,
  "language": "en",
  "proxyCountryCode": "US"
}' |
apify call johnatan029/google-maps-business-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnatan029/google-maps-business-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Business Scraper",
        "description": "Collect public Google Maps business listings for lead generation and local market research. Get names, categories, structured addresses, phones, websites, ratings, coordinates, CIDs, source queries, and ranks. Supports JSON, CSV, Excel, API, and scheduled runs.",
        "version": "1.0",
        "x-build-id": "5qbFsRStVwTsMTZkY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnatan029~google-maps-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnatan029-google-maps-business-scraper",
                "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/johnatan029~google-maps-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-johnatan029-google-maps-business-scraper",
                "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/johnatan029~google-maps-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-johnatan029-google-maps-business-scraper",
                "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",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Business search terms such as a category plus city. Duplicate and blank queries are removed.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "searchUrls": {
                        "title": "Google Maps search URLs",
                        "type": "array",
                        "description": "Public Google Maps search URLs. API callers may also provide URL strings.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPlacesPerQuery": {
                        "title": "Maximum places per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of dataset items produced for each query context.",
                        "default": 20
                    },
                    "maxTotalPlaces": {
                        "title": "Maximum total places",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard global dataset item limit for the entire run.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "pt-BR",
                            "es",
                            "de",
                            "fr",
                            "it"
                        ],
                        "type": "string",
                        "description": "Browser locale and output language context.",
                        "default": "en"
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "pattern": "^[A-Za-z]{2}$",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter country code used by the official Apify proxy configuration.",
                        "default": "US"
                    },
                    "includeOpeningHours": {
                        "title": "Include opening hours",
                        "type": "boolean",
                        "description": "Extract normalized opening hours when publicly available.",
                        "default": true
                    },
                    "includeContactDetails": {
                        "title": "Include contact details",
                        "type": "boolean",
                        "description": "Extract public phone and website fields.",
                        "default": true
                    },
                    "debug": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Save page screenshots and HTML for troubleshooting. Error and block evidence is saved regardless.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
