# Google Maps Scraper | 💰$2.5 per 1,000 results (`solidcode/google-maps-scraper-2-5-per-1-000-results`) Actor

Scrape Google Maps search results at scale. Extract business names, addresses, phone numbers, websites, ratings, reviews count, opening hours, photos, popular times, and 30+ data points for any search query and location worldwide.

- **URL**: https://apify.com/solidcode/google-maps-scraper-2-5-per-1-000-results.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 2 monthly users, 66.7% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.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

## Google Maps Scraper

Extract complete business data from Google Maps at scale. Get names, addresses, phone numbers, websites, ratings, reviews, opening hours, photos, popular times, and **30+ data fields** for any search query and location worldwide - with advanced geographic targeting, smart filtering, and the lowest pricing on Apify.

### Why This Scraper?

- **Up to 15,000+ results per run** - Systematically scan entire cities or regions with grid-based area coverage
- **Advanced geographic targeting** - Search by location name, coordinates with radius, bounding box, or custom GeoJSON polygon boundaries
- **30+ data fields** - Business details, contact info, ratings, reviews, opening hours, photos, popular times, service options, accessibility, reservation/menu/order URLs, and more
- **Distance calculation** - Get distance in miles from your search center for every result
- **Lowest price on Apify** - $2.50 per 1,000 results with no hidden fees
- **Resume support** - Interrupted runs pick up exactly where they left off
- **Reliable at scale** - Built-in proxy rotation, automatic retries, and rate-limit detection

### Use Cases

**Market Research & Competitive Intelligence**
- Map competitor locations and density across regions
- Identify underserved areas and market opportunities
- Analyze business distribution by category, rating, or price level

**Lead Generation & Sales**
- Build targeted prospect lists by location and category
- Find businesses with or without websites for outreach campaigns
- Target established businesses by sorting on rating and review count in your dataset

**Real Estate & Site Selection**
- Analyze business density around potential locations
- Map all businesses within a radius of a target address
- Compare neighborhoods using polygon area scanning

**App Development & Data Enrichment**
- Populate location databases with fresh Google Maps data
- Enrich existing business records with phone, website, hours, and ratings
- Build local search features powered by comprehensive POI data

### Getting Started

#### Simple Search

Enter one or more search terms - the simplest way to get started:

```json
{
    "searchQueries": ["restaurants in Amsterdam", "hotels in Paris"],
    "maxResults": 100
}
````

#### Search with Location

Separate your search term from the location for cleaner results:

```json
{
    "searchQueries": ["dentist", "pharmacy"],
    "locationName": "Berlin",
    "maxResults": 200
}
```

#### Google Maps URL

Paste any Google Maps search URL directly:

```json
{
    "searchUrls": [
        { "url": "https://www.google.com/maps/search/coffee+shops/@52.3676,4.9041,14z" }
    ]
}
```

#### Coordinate + Radius Search

Search within a precise radius around any point:

```json
{
    "searchQueries": ["pizza restaurants"],
    "lat": 40.7128,
    "lon": -74.006,
    "radius": 5,
    "maxResults": 500
}
```

Every result includes a `distanceMiles` field showing how far it is from your center point.

#### Bounding Box Grid Scan

For systematic coverage of a rectangular area:

```json
{
    "searchQueries": ["coffee shops"],
    "boundingBox": {
        "south": 52.29,
        "west": 4.73,
        "north": 52.43,
        "east": 5.02
    },
    "maxResults": 1000
}
```

#### Polygon Area Scan

Define custom geographic boundaries using GeoJSON coordinates for complex area coverage. Use [geojson.io](https://geojson.io) or the [Keene Polyline Tool](https://www.keene.edu/campus/maps/tool/) to draw your polygon and copy the coordinates.

```json
{
    "searchQueries": ["restaurants"],
    "polygon": {
        "type": "Polygon",
        "coordinates": [[
            [-74.041885, 40.570396],
            [-73.855682, 40.570396],
            [-73.855682, 40.739234],
            [-74.041885, 40.739234],
            [-74.041885, 40.570396]
        ]]
    },
    "maxResults": 2000
}
```

Note: GeoJSON uses `[longitude, latitude]` coordinate order.

### Input Reference

#### Search Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `[]` | Search queries (e.g. "restaurants in London") |
| `searchUrls` | URL\[] | `[]` | Google Maps search URLs to scrape directly |
| `locationName` | string | | Location name appended to queries (e.g. "New York") |

#### Geographic Targeting

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `lat` / `lon` | number | | Center coordinates for area search |
| `radius` | number | | Search radius in miles (1-100). Requires lat/lon |
| `boundingBox` | object | | `{south, west, north, east}` for rectangular grid scanning |
| `polygon` | object | | GeoJSON polygon for custom area boundaries |

#### Result & Language Settings

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Max places to return (0 = unlimited) |
| `language` | string | `"en"` | Result language (en, nl, de, fr, es, ja...) |
| `countryCode` | string | Auto-detect | Country code (US, NL, DE, GB, FR...). Auto-detected from coordinates when not set |

#### Search Mode

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchMode` | string | `"default"` | `"fast"` = quicker but may miss results, `"default"` = good balance, `"thorough"` = street-level scan |

### Output

Each result contains up to 30+ structured fields. Here's an example in **clean** format:

```json
{
    "name": "Carmine's - Times Square",
    "placeId": "ChIJifIePKtZwokRVZ-UdRGkZzs",
    "url": "https://www.google.com/maps/place/?q=place_id:ChIJifIePKtZwokRVZ-UdRGkZzs",
    "categoryName": "Italian restaurant",
    "categories": ["Italian restaurant", "Caterer", "Family restaurant", "Restaurant"],
    "address": "200 W 44th St, New York, NY 10036",
    "neighborhood": "Manhattan",
    "street": "200 W 44th St",
    "city": "New York",
    "state": "New York",
    "postalCode": "10036",
    "countryCode": "US",
    "latitude": 40.757498,
    "longitude": -73.986654,
    "distanceMiles": 2.3,
    "phone": "(212) 221-3800",
    "phoneInternational": "+12122213800",
    "website": "https://carminesnyc.com",
    "totalScore": 4.5,
    "reviewsCount": 17231,
    "priceLevel": "$$",
    "openingHours": [
        {"day": "Saturday", "hours": "11:30 AM-12 AM"}
    ],
    "isOpen": true,
    "description": "Relaxed, family-friendly restaurant serving homestyle Southern Italian meals.",
    "imageUrls": ["https://lh3.googleusercontent.com/..."],
    "imageCount": 1,
    "serviceOptions": {"dine_in": true, "takeout": true, "delivery": true},
    "accessibility": {"wheelchair_accessible_entrance": true},
    "reservationUrl": "https://carminesnyc.com/bookings",
    "menuUrl": "https://carminesnyc.com/menu"
}
```

#### All Available Fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name |
| `placeId` | string | Google Place ID |
| `cid` | string | Google CID identifier |
| `url` | string | Google Maps place URL |
| `googleUrl` | string | Google internal URL |
| `categoryName` | string | Primary business category |
| `categories` | string\[] | All categories |
| `categoryTypes` | string\[] | Category type labels |
| `subtypes` | string\[] | Specific business subtypes |
| `address` | string | Full formatted address |
| `neighborhood` | string | Neighborhood name |
| `street` | string | Street address |
| `city` | string | City |
| `state` | string | State / province |
| `postalCode` | string | Postal / ZIP code |
| `countryCode` | string | Country code |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |
| `distanceMiles` | number | Distance from search center (when lat/lon provided) |
| `phone` | string | Phone number |
| `phoneInternational` | string | International phone format |
| `website` | string | Business website URL |
| `totalScore` | number | Star rating (1.0-5.0) |
| `reviewsCount` | number | Total review count |
| `priceLevel` | string | Price indicator ($-$$$$) |
| `openingHours` | object\[] | Opening hours |
| `isOpen` | boolean | Currently open |
| `permanentlyClosed` | boolean | Permanently closed |
| `temporarilyClosed` | boolean | Temporarily closed |
| `description` | string | Business description |
| `editorialSummary` | string | Google editorial summary |
| `imageUrls` | string\[] | Photo URLs |
| `imageCount` | number | Number of photos |
| `thumbnailUrl` | string | Main thumbnail URL |
| `popularTimes` | object\[] | Weekly busyness data |
| `currentPopularity` | number | Current busyness level |
| `serviceOptions` | object | Dine-in, takeout, delivery, etc. |
| `accessibility` | object | Wheelchair access, etc. |
| `reservationUrl` | string | Reservation booking URL |
| `menuUrl` | string | Menu URL |
| `orderUrl` | string | Online ordering URL |

### Tips for Best Results

#### Search Mode Guide

- **Fast**: Uses wider tiles for quicker scans — good for sparse areas or quick estimates
- **Default**: Balanced tile size — recommended for most searches
- **Thorough**: Street-level scanning — catches small businesses, best for dense urban areas

#### Maximizing Coverage

- Use **bounding box** or **polygon** mode for systematic area coverage
- Use **thorough** search mode for dense urban areas where businesses are close together
- Use **residential proxies** for best success rates on large scrapes

#### Large-Scale Scraping

- **Concurrent scanning** processes multiple tiles in parallel for faster results
- **Automatic refresh** keeps sessions healthy during long runs
- **Proxy rotation** distributes requests for reliable large scans
- **Resume support** means you can stop and restart without losing progress
- **Streaming output** pushes results to your dataset as they're found

#### Creating Polygon Boundaries

Use these free tools to draw custom search areas:

- [geojson.io](https://geojson.io) - Draw polygons on an interactive map and copy GeoJSON
- [Keene Polyline Tool](https://www.keene.edu/campus/maps/tool/) - Simple polygon drawing tool

Copy the coordinates array from either tool directly into the `polygon` input field.

### Pricing

**$2.50 per 1,000 results** - among the lowest prices on Apify for Google Maps data.

| Results | Cost |
|---------|------|
| 100 | $0.25 |
| 1,000 | $2.50 |
| 10,000 | $25.00 |
| 100,000 | $250.00 |

Platform fees (compute, proxy, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** - Workflow automation
- **Google Sheets** - Direct spreadsheet export
- **Slack** / **Email** - Notifications on new results
- **Webhooks** - Custom API integrations
- **Apify API** - Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate business intelligence, market research, and lead generation. Users are responsible for complying with applicable laws and Google's Terms of Service. Do not use scraped data for spam, harassment, or any illegal purpose.

# Actor input Schema

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

What to search for on Google Maps (e.g. 'restaurants', 'plumber', 'hotels'). You can also paste Google Maps URLs here.

## `locationName` (type: `string`):

Where to search (e.g. 'New York, USA', 'Amsterdam, Netherlands', 'Tokyo, Japan'). Leave empty if your search queries already include a location.

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

Language for search results.

## `countryCode` (type: `string`):

Helps Google return results from the right country. Usually auto-detected from your location or coordinates.

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

Maximum number of places to return. Set to 0 for unlimited.

## `lat` (type: `number`):

Center latitude for coordinate-based search.

## `lon` (type: `number`):

Center longitude for coordinate-based search.

## `radius` (type: `number`):

Search within this radius around the center coordinates (1-100 miles). Requires latitude and longitude.

## `polygon` (type: `object`):

Custom search boundary from geojson.io. Paste the full GeoJSON output — supports Polygon, Feature, and FeatureCollection formats.

## `boundingBox` (type: `object`):

Rectangular area to scan: {"south": lat, "west": lon, "north": lat, "east": lon}.

## `searchMode` (type: `string`):

Fast: quicker but may miss results. Default: good balance. Thorough: street-level scan, catches everything.

## `searchUrls` (type: `array`):

Paste Google Maps search URLs directly. The actor extracts query, location, and zoom from each URL.

## Actor input object example

```json
{
  "searchQueries": [
    "restaurants"
  ],
  "locationName": "New York, USA",
  "language": "en",
  "maxResults": 100,
  "searchMode": "default",
  "searchUrls": []
}
```

# Actor output Schema

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

Table of scraped places with key fields.

## `contact` (type: `string`):

Table of contact information for scraped places.

# 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": [
        "restaurants"
    ],
    "locationName": "New York, USA",
    "maxResults": 100,
    "searchUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/google-maps-scraper-2-5-per-1-000-results").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": ["restaurants"],
    "locationName": "New York, USA",
    "maxResults": 100,
    "searchUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/google-maps-scraper-2-5-per-1-000-results").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": [
    "restaurants"
  ],
  "locationName": "New York, USA",
  "maxResults": 100,
  "searchUrls": []
}' |
apify call solidcode/google-maps-scraper-2-5-per-1-000-results --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/google-maps-scraper-2-5-per-1-000-results",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper | 💰$2.5 per 1,000 results",
        "description": "Scrape Google Maps search results at scale. Extract business names, addresses, phone numbers, websites, ratings, reviews count, opening hours, photos, popular times, and 30+ data points for any search query and location worldwide.",
        "version": "1.0",
        "x-build-id": "P3o8Ls9JYKHdzUEU2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~google-maps-scraper-2-5-per-1-000-results/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-google-maps-scraper-2-5-per-1-000-results",
                "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/solidcode~google-maps-scraper-2-5-per-1-000-results/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-google-maps-scraper-2-5-per-1-000-results",
                "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/solidcode~google-maps-scraper-2-5-per-1-000-results/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-google-maps-scraper-2-5-per-1-000-results",
                "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": "What to search for on Google Maps (e.g. 'restaurants', 'plumber', 'hotels'). You can also paste Google Maps URLs here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationName": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search (e.g. 'New York, USA', 'Amsterdam, Netherlands', 'Tokyo, Japan'). Leave empty if your search queries already include a location."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "nl",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "pl",
                            "cs",
                            "da",
                            "sv",
                            "no",
                            "fi",
                            "el",
                            "tr",
                            "ar",
                            "he",
                            "ja",
                            "ko",
                            "zh-CN",
                            "zh-TW",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "hi",
                            "ru",
                            "uk",
                            "ro",
                            "hu",
                            "hr",
                            "bg",
                            "sk"
                        ],
                        "type": "string",
                        "description": "Language for search results.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "NL",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "PT",
                            "BE",
                            "LU",
                            "AT",
                            "CH",
                            "PL",
                            "CZ",
                            "SK",
                            "HU",
                            "RO",
                            "BG",
                            "HR",
                            "GR",
                            "DK",
                            "SE",
                            "NO",
                            "FI",
                            "IE",
                            "TR",
                            "IL",
                            "AE",
                            "SA",
                            "JP",
                            "KR",
                            "CN",
                            "IN",
                            "TH",
                            "SG",
                            "MY",
                            "ID",
                            "PH",
                            "VN",
                            "BR",
                            "MX",
                            "AR",
                            "CO",
                            "CL",
                            "PE",
                            "ZA",
                            "NG",
                            "EG",
                            "KE",
                            "MA",
                            "RU",
                            "UA"
                        ],
                        "type": "string",
                        "description": "Helps Google return results from the right country. Usually auto-detected from your location or coordinates."
                    },
                    "maxResults": {
                        "title": "Total Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of places to return. Set to 0 for unlimited.",
                        "default": 100
                    },
                    "lat": {
                        "title": "Center Latitude",
                        "type": "number",
                        "description": "Center latitude for coordinate-based search."
                    },
                    "lon": {
                        "title": "Center Longitude",
                        "type": "number",
                        "description": "Center longitude for coordinate-based search."
                    },
                    "radius": {
                        "title": "Search Radius (miles)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "number",
                        "description": "Search within this radius around the center coordinates (1-100 miles). Requires latitude and longitude."
                    },
                    "polygon": {
                        "title": "Polygon Area (GeoJSON)",
                        "type": "object",
                        "description": "Custom search boundary from geojson.io. Paste the full GeoJSON output — supports Polygon, Feature, and FeatureCollection formats."
                    },
                    "boundingBox": {
                        "title": "Bounding Box",
                        "type": "object",
                        "description": "Rectangular area to scan: {\"south\": lat, \"west\": lon, \"north\": lat, \"east\": lon}."
                    },
                    "searchMode": {
                        "title": "Search Mode",
                        "enum": [
                            "fast",
                            "default",
                            "thorough"
                        ],
                        "type": "string",
                        "description": "Fast: quicker but may miss results. Default: good balance. Thorough: street-level scan, catches everything.",
                        "default": "default"
                    },
                    "searchUrls": {
                        "title": "Google Maps URLs",
                        "type": "array",
                        "description": "Paste Google Maps search URLs directly. The actor extracts query, location, and zoom from each URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
