# Fast Google Maps Scraper (`solutionssmart/fast-google-map-scraper`) Actor

HTTP-first Google Maps scraper for search listings, place details, reviews, lead scoring, and optional website enrichment.

- **URL**: https://apify.com/solutionssmart/fast-google-map-scraper.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** Lead generation, Automation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Fast Google Maps Scraper

A lightweight Google Maps lead scraper built for low-cost prospecting. It uses a fast HTTP-first pipeline, optional deep details, and built-in opportunity scoring so you do not spend browser compute on every lead.

It is based on the public Python scraper structure from `jinef-john/google-maps-scraper` and keeps the original concept: direct Google Maps HTTP endpoints, configurable language and country parameters, optional proxies, request delays, max places, max reviews, and SQLite-style deduplication/checkpointing as an internal option.

### What it does

- `list` mode searches Google Maps and saves lightweight listing rows only. This is the cheapest mode.
- `place` mode scrapes one known Google Maps `placeId`.
- `search` mode searches, fetches full place details, and optionally fetches reviews.
- `outputMode` controls whether the Dataset contains all records, only places and reviews, or places only.
- Supports concurrent place detail and review scraping in `search` mode.
- Pushes every result immediately to the Apify Dataset.
- Saves a run summary to Key-Value Store record `OUTPUT`.
- Supports Apify Proxy and a manual proxy URL fallback.
- Adds lead scoring for every full place record.
- Optionally enriches business websites with title, description, emails, and social links.
- Supports pay-per-event monetization with charged Dataset writes for `place-listed`, `place-detail`, and `review`.

### Input

The Actor uses `.actor/input_schema.json`, so configuration is available as a typed Apify Console form.

Important fields:

- `mode`: `list`, `place`, or `search`.
- `outputMode`: `allRecords`, `placesAndReviews`, or `placesOnly`.
- `query`: business/category query required for `list` and `search`, for example `coffee shops`.
- `searchLocation`: free-form location, for example `Berlin, Germany`.
- `geolocationParameters`: grouped country, state/region, county, city, and postal code fields used when `searchLocation` is empty.
- `customGeolocation`: grouped geometry type, coordinates, radius, latitude, longitude, and coordinates JSON fields for anchoring the map area.
- `leadFilters`: optional minimum rating, minimum review count, website, phone, and category filters.
- `websiteEnrichmentDepth`: `homepageOnly` or `contactPages`.
- `websiteTimeoutSeconds`: separate short timeout for website enrichment requests.
- `skipSocialWebsites`: skips enrichment of social profile URLs by default to reduce slow tails and 429 responses.
- `placeId`: required for `place`.
- `maxPlaces`: maximum places to list or scrape.
- `maxReviews`: reviews per place. Use `0` to skip reviews.
- `maxTotalReviews`: global review cap across the run. Use `0` for no global cap.
- `maxConcurrency`: number of places to scrape in parallel in `search` mode.
- `language`: Google `hl` parameter.
- `gl`: Google country parameter.
- `proxyConfiguration`: Apify Proxy settings.
- `delaySeconds`: randomized delay between requests.
- `enableSqliteCheckpoint`: optional internal SQLite copy for deduplication/checkpointing.
- `enrichWebsites`: optional website enrichment.
- `enableBillingEvents`: legacy testing flag. Production monetization is detected from Apify pay-per-event pricing.

### Output

Dataset records are streamed as they are found:

- `recordType: "listing"` for search results.
- `recordType: "place"` for full place detail records with lead scoring.
- `recordType: "review"` for individual reviews.

Output modes:

- `allRecords`: saves listings, places, and reviews.
- `placesAndReviews`: saves full places and reviews, but skips listing rows.
- `placesOnly`: saves only full place records and skips review fetching.

The `OUTPUT` key-value store record contains:

- mode and query
- start and finish timestamps
- places listed
- places scraped
- reviews scraped
- duplicates skipped
- failed places
- website enrichments
- skipped website enrichments

### Lead scoring

Each full place record includes:

```json
{
  "leadScore": {
    "score": 80,
    "tier": "hot",
    "reasons": ["Has phone", "Has website", "High rating"]
  }
}
````

Signals include phone, website presence or absence, rating, review volume, opening hours, photos, booking links, and commercial local categories.

### Example input

```json
{
  "mode": "search",
  "outputMode": "placesAndReviews",
  "query": "dentists",
  "searchLocation": "Austin, United States",
  "customGeolocation": {
    "latitude": 30.2672,
    "longitude": -97.7431
  },
  "maxPlaces": 25,
  "maxReviews": 20,
  "maxTotalReviews": 200,
  "maxConcurrency": 3,
  "language": "en",
  "gl": "us",
  "delaySeconds": 1.5,
  "enrichWebsites": true,
  "websiteEnrichmentDepth": "contactPages",
  "websiteTimeoutSeconds": 8,
  "skipSocialWebsites": true,
  "leadFilters": {
    "minRating": 4.0,
    "mustHaveWebsite": true
  },
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

### Cost notes

Use `list` mode when you only need names, ratings, categories, addresses, coordinates, and place IDs. It avoids detail and review endpoints.

Use `search` mode when you need complete lead records. Set `maxReviews` to `0` if reviews are not needed.

Use `placesOnly` when you want a lead list without review rows. It skips review fetching even if `maxReviews` is greater than `0`.

`maxReviews` is a per-place limit. For example, `maxPlaces: 20` and `maxReviews: 50` can produce up to 1,000 reviews. Use `maxTotalReviews` when you want a global cap.

Increase `maxConcurrency` to process multiple places in parallel. Start with `2` or `3` when using proxies. Higher values can reduce runtime, but they also increase request pressure and blocking risk.

Website enrichment adds extra HTTP requests and should be enabled only when you need emails, social links, or website metadata.

`websiteEnrichmentDepth: "homepageOnly"` fetches only the listed website homepage. `contactPages` also follows likely contact, about, Kontakt, and Impressum links found on the homepage. This can find more emails, but it costs extra requests and some sites may rate-limit.

`websiteTimeoutSeconds` is independent from the main Google Maps request timeout. Keep it low, such as `6` to `8`, when you want predictable cost. `skipSocialWebsites` is enabled by default because social profile URLs rarely expose emails and often return 429 or slow responses through proxies.

Lead filters are applied after full place details are fetched:

```json
{
  "leadFilters": {
    "minRating": 4.2,
    "minReviewCount": 25,
    "mustHaveWebsite": true,
    "mustHavePhone": false,
    "categoryIncludes": "cafe"
  }
}
```

Filtered places are counted in the `OUTPUT.filteredPlaces` summary and skipped from Dataset output and review fetching.

### Location targeting

You can target by city and country:

```json
{
  "query": "coffee shops",
  "searchLocation": "Berlin, Germany",
  "gl": "de"
}
```

Or use structured geolocation fields:

```json
{
  "query": "coffee shops",
  "geoCountry": "Germany",
  "geolocationParameters": {
    "country": "Germany",
    "city": "Berlin",
    "postalCode": "10117"
  },
  "gl": "de"
}
```

You can also add custom latitude and longitude to anchor the map area:

```json
{
  "query": "coffee shops",
  "searchLocation": "Berlin, Germany",
  "customGeolocation": {
    "latitude": 52.520008,
    "longitude": 13.404954
  },
  "zoom": 13,
  "gl": "de"
}
```

For coordinate-heavy workflows, use `customCoordinates` as simple text:

```json
{
  "query": "coffee shops",
  "searchLocation": "Berlin, Germany",
  "customGeolocation": {
    "coordinates": "52.520008, 13.404954",
    "radiusKm": 5
  }
}
```

Or use `coordinatesJson` with a GeoJSON point:

```json
{
  "query": "coffee shops",
  "searchLocation": "Berlin, Germany",
  "customGeolocation": {
    "coordinatesJson": "{\"type\":\"Point\",\"coordinates\":[13.404954,52.520008]}"
  }
}
```

# Actor input Schema

## `mode` (type: `string`):

list searches only and is cheapest; place scrapes one known place ID; search lists places, fetches details, and optionally reviews.

## `outputMode` (type: `string`):

Choose which records are saved to the Dataset. list mode always returns listing records.

## `query` (type: `string`):

Business/category query, for example 'dentists' or 'coffee shops'. Required for list and search mode.

## `searchLocation` (type: `string`):

Free-form location such as Berlin, Germany. Used together with the search query.

## `geolocationParameters` (type: `object`):

Optional structured location fields. These are used when the free-form location is empty.

## `customGeolocation` (type: `object`):

Optional geometry and coordinate fields for anchoring the Google Maps search area.

## `placeId` (type: `string`):

Known Google Maps place ID. Required for place mode.

## `maxPlaces` (type: `integer`):

Maximum number of search results to list or fully scrape.

## `maxReviews` (type: `integer`):

Maximum reviews to fetch for each place. Set to 0 to skip reviews.

## `maxTotalReviews` (type: `integer`):

Global review cap across the whole run. Set to 0 for no global cap.

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

Number of places to scrape in parallel in search mode. Higher values are faster but can increase blocking risk.

## `zoom` (type: `integer`):

Google Maps zoom level. Higher values narrow the search area.

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

Google hl language parameter.

## `gl` (type: `string`):

Google gl country parameter.

## `delaySeconds` (type: `number`):

Minimum delay between HTTP requests. Actual delay is randomized up to 2x this value.

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

HTTP request timeout in seconds.

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

Use Apify Proxy or custom proxies.

## `proxyUrl` (type: `string`):

Optional direct proxy URL used when Apify Proxy is disabled.

## `enrichWebsites` (type: `boolean`):

Fetch listed websites to extract title, description, emails, and social links.

## `websiteEnrichmentDepth` (type: `string`):

Homepage only is fastest. Contact pages also checks contact/about/impressum pages for emails and social links.

## `websiteTimeoutSeconds` (type: `integer`):

Timeout for each website enrichment request. Keep this lower than the Google Maps timeout to avoid slow websites increasing run cost.

## `skipSocialWebsites` (type: `boolean`):

Skip website enrichment when Google Maps lists a social profile such as Instagram, Facebook, LinkedIn, X, or Twitter. This is faster and avoids many 429 responses.

## `leadFilters` (type: `object`):

Optional filters applied after full place details are fetched. Filtered places are skipped from Dataset output and reviews.

## `enableSqliteCheckpoint` (type: `boolean`):

Keep an internal SQLite copy for deduplication/checkpointing. Dataset remains the primary output.

## `sqlitePath` (type: `string`):

Internal SQLite path when checkpointing is enabled.

## `enableBillingEvents` (type: `boolean`):

Legacy testing flag. Production monetization is enabled automatically when pay-per-event pricing is configured in Apify Console. For local tests, use ACTOR\_TEST\_PAY\_PER\_EVENT=true.

## Actor input object example

```json
{
  "mode": "search",
  "outputMode": "allRecords",
  "query": "coffee shops",
  "searchLocation": "Berlin, Germany",
  "maxPlaces": 20,
  "maxReviews": 50,
  "maxTotalReviews": 0,
  "maxConcurrency": 1,
  "zoom": 13,
  "language": "en",
  "gl": "us",
  "delaySeconds": 1.5,
  "timeoutSeconds": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "enrichWebsites": false,
  "websiteEnrichmentDepth": "homepageOnly",
  "websiteTimeoutSeconds": 8,
  "skipSocialWebsites": true,
  "enableSqliteCheckpoint": false,
  "sqlitePath": "storage/key_value_stores/default/gmaps.db",
  "enableBillingEvents": false
}
```

# Actor output Schema

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

Dataset items generated by the Actor. Depending on outputMode, this can include listing, place, and review records.

## `summary` (type: `string`):

Key-value store OUTPUT record with counters, timing, effective query, location, filters, and run status.

# 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 = {
    "query": "coffee shops",
    "searchLocation": "Berlin, Germany"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/fast-google-map-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 = {
    "query": "coffee shops",
    "searchLocation": "Berlin, Germany",
}

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/fast-google-map-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 '{
  "query": "coffee shops",
  "searchLocation": "Berlin, Germany"
}' |
apify call solutionssmart/fast-google-map-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fast Google Maps Scraper",
        "description": "HTTP-first Google Maps scraper for search listings, place details, reviews, lead scoring, and optional website enrichment.",
        "version": "0.1",
        "x-build-id": "VHWt4PhaY7MAfO5XH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~fast-google-map-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-fast-google-map-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/solutionssmart~fast-google-map-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-fast-google-map-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/solutionssmart~fast-google-map-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-fast-google-map-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "list",
                            "place",
                            "search"
                        ],
                        "type": "string",
                        "description": "list searches only and is cheapest; place scrapes one known place ID; search lists places, fetches details, and optionally reviews.",
                        "default": "search"
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "allRecords",
                            "placesAndReviews",
                            "placesOnly"
                        ],
                        "type": "string",
                        "description": "Choose which records are saved to the Dataset. list mode always returns listing records.",
                        "default": "allRecords"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Business/category query, for example 'dentists' or 'coffee shops'. Required for list and search mode."
                    },
                    "searchLocation": {
                        "title": "📍 Where should we search?",
                        "type": "string",
                        "description": "Free-form location such as Berlin, Germany. Used together with the search query."
                    },
                    "geolocationParameters": {
                        "title": "🧭 Geolocation parameters",
                        "type": "object",
                        "description": "Optional structured location fields. These are used when the free-form location is empty.",
                        "properties": {
                            "country": {
                                "title": "🌎 Country",
                                "type": "string",
                                "description": "Country or region, for example Germany.",
                                "editor": "textfield"
                            },
                            "stateRegion": {
                                "title": "🧭 State or region",
                                "type": "string",
                                "description": "State, region, province, or administrative area.",
                                "editor": "textfield"
                            },
                            "county": {
                                "title": "📌 County",
                                "type": "string",
                                "description": "County, district, borough, or local administrative area.",
                                "editor": "textfield"
                            },
                            "city": {
                                "title": "🏙️ City",
                                "type": "string",
                                "description": "City or locality, for example Berlin.",
                                "editor": "textfield"
                            },
                            "postalCode": {
                                "title": "🏷️ Postal code",
                                "type": "string",
                                "description": "Postal code or ZIP code.",
                                "editor": "textfield"
                            }
                        },
                        "additionalProperties": false
                    },
                    "customGeolocation": {
                        "title": "📐 Custom geolocation",
                        "type": "object",
                        "description": "Optional geometry and coordinate fields for anchoring the Google Maps search area.",
                        "properties": {
                            "geometryType": {
                                "title": "🔷 Geometry type",
                                "type": "string",
                                "description": "Optional geometry hint for custom coordinates.",
                                "editor": "select",
                                "enum": [
                                    "point",
                                    "circle",
                                    "polygon",
                                    "bbox"
                                ],
                                "enumTitles": [
                                    "Point",
                                    "Circle",
                                    "Polygon",
                                    "Bounding box"
                                ]
                            },
                            "coordinates": {
                                "title": "📍 Coordinates",
                                "type": "string",
                                "description": "Optional coordinates as text, for example '52.520008, 13.404954'.",
                                "editor": "textarea"
                            },
                            "radiusKm": {
                                "title": "📏 Radius in km",
                                "type": "number",
                                "description": "Optional search radius. When provided, it is converted to an approximate map zoom.",
                                "minimum": 0
                            },
                            "latitude": {
                                "title": "↕️ Latitude",
                                "type": "number",
                                "description": "Optional map center latitude."
                            },
                            "longitude": {
                                "title": "↔️ Longitude",
                                "type": "number",
                                "description": "Optional map center longitude."
                            },
                            "coordinatesJson": {
                                "title": "🧾 Coordinates JSON",
                                "type": "string",
                                "description": "Optional GeoJSON Point, Feature, or coordinate array. Example: {\"type\":\"Point\",\"coordinates\":[13.404954,52.520008]}",
                                "editor": "textarea"
                            }
                        },
                        "additionalProperties": false
                    },
                    "placeId": {
                        "title": "Place ID",
                        "type": "string",
                        "description": "Known Google Maps place ID. Required for place mode."
                    },
                    "maxPlaces": {
                        "title": "Max places",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of search results to list or fully scrape.",
                        "default": 20
                    },
                    "maxReviews": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum reviews to fetch for each place. Set to 0 to skip reviews.",
                        "default": 50
                    },
                    "maxTotalReviews": {
                        "title": "Max total reviews",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Global review cap across the whole run. Set to 0 for no global cap.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of places to scrape in parallel in search mode. Higher values are faster but can increase blocking risk.",
                        "default": 1
                    },
                    "zoom": {
                        "title": "Map zoom",
                        "minimum": 1,
                        "maximum": 21,
                        "type": "integer",
                        "description": "Google Maps zoom level. Higher values narrow the search area.",
                        "default": 13
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google hl language parameter.",
                        "default": "en"
                    },
                    "gl": {
                        "title": "Google country",
                        "type": "string",
                        "description": "Google gl country parameter.",
                        "default": "us"
                    },
                    "delaySeconds": {
                        "title": "Delay between requests",
                        "minimum": 0,
                        "maximum": 60,
                        "type": "number",
                        "description": "Minimum delay between HTTP requests. Actual delay is randomized up to 2x this value.",
                        "default": 1.5
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout in seconds.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Apify Proxy",
                        "type": "object",
                        "description": "Use Apify Proxy or custom proxies.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "proxyUrl": {
                        "title": "Manual proxy URL",
                        "type": "string",
                        "description": "Optional direct proxy URL used when Apify Proxy is disabled."
                    },
                    "enrichWebsites": {
                        "title": "Enrich websites",
                        "type": "boolean",
                        "description": "Fetch listed websites to extract title, description, emails, and social links.",
                        "default": false
                    },
                    "websiteEnrichmentDepth": {
                        "title": "Website enrichment depth",
                        "enum": [
                            "homepageOnly",
                            "contactPages"
                        ],
                        "type": "string",
                        "description": "Homepage only is fastest. Contact pages also checks contact/about/impressum pages for emails and social links.",
                        "default": "homepageOnly"
                    },
                    "websiteTimeoutSeconds": {
                        "title": "Website timeout",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Timeout for each website enrichment request. Keep this lower than the Google Maps timeout to avoid slow websites increasing run cost.",
                        "default": 8
                    },
                    "skipSocialWebsites": {
                        "title": "Skip social profile websites",
                        "type": "boolean",
                        "description": "Skip website enrichment when Google Maps lists a social profile such as Instagram, Facebook, LinkedIn, X, or Twitter. This is faster and avoids many 429 responses.",
                        "default": true
                    },
                    "leadFilters": {
                        "title": "Lead filters",
                        "type": "object",
                        "description": "Optional filters applied after full place details are fetched. Filtered places are skipped from Dataset output and reviews.",
                        "properties": {
                            "minRating": {
                                "title": "Minimum rating",
                                "type": "number",
                                "description": "Skip places below this rating.",
                                "minimum": 0,
                                "maximum": 5
                            },
                            "minReviewCount": {
                                "title": "Minimum review count",
                                "type": "integer",
                                "description": "Skip places below this review count.",
                                "minimum": 0
                            },
                            "mustHaveWebsite": {
                                "title": "Must have website",
                                "type": "boolean",
                                "description": "Only keep places with a website.",
                                "default": false
                            },
                            "mustHavePhone": {
                                "title": "Must have phone",
                                "type": "boolean",
                                "description": "Only keep places with a phone number.",
                                "default": false
                            },
                            "categoryIncludes": {
                                "title": "Category includes",
                                "type": "string",
                                "description": "Only keep places whose categories include this text, for example cafe.",
                                "editor": "textfield"
                            }
                        },
                        "additionalProperties": false
                    },
                    "enableSqliteCheckpoint": {
                        "title": "Enable SQLite checkpoint",
                        "type": "boolean",
                        "description": "Keep an internal SQLite copy for deduplication/checkpointing. Dataset remains the primary output.",
                        "default": false
                    },
                    "sqlitePath": {
                        "title": "SQLite path",
                        "type": "string",
                        "description": "Internal SQLite path when checkpointing is enabled.",
                        "default": "storage/key_value_stores/default/gmaps.db"
                    },
                    "enableBillingEvents": {
                        "title": "Enable billing events (legacy)",
                        "type": "boolean",
                        "description": "Legacy testing flag. Production monetization is enabled automatically when pay-per-event pricing is configured in Apify Console. For local tests, use ACTOR_TEST_PAY_PER_EVENT=true.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```