# Google Maps Reviews Scraper (`lurkapi/google-maps-reviews-scraper`) Actor

Scrape full Google Maps reviews from any business by URL, place ID, or CID. Filter by rating, date, and keyword. Skip already-collected review IDs for incremental runs.

- **URL**: https://apify.com/lurkapi/google-maps-reviews-scraper.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.22 / 1,000 review scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Reviews Scraper

Scrape every review from any Google Maps business. Drop in a URL, place ID, or CID, and pull the full review history with reviewer info, ratings, owner replies, photos, and place metadata.

### 🎯 What it does

Give it a Google Maps business and it will:
1. **Resolve the place** from a URL, place ID, or CID
2. **Fetch every review** (up to your cap), with full reviewer profile, owner replies, and attached photos
3. **Filter on the fly** by star rating, date range, keyword, or owner reply presence
4. **Skip reviews you've already collected** so monitoring runs only pay for new content

Built for reputation monitoring, competitor research, sentiment analysis, and any workflow that needs reliable, structured Google Maps review data.

### 📋 How to use it

#### Step 1: Pick your inputs
Paste any combination of:
- **Google Maps URLs**: long URLs, share links (maps.app.goo.gl), or place URLs
- **Place IDs**: the `ChIJ...` identifiers Google uses
- **CIDs**: the long numeric IDs from old-style Maps URLs
- **Search queries** (paid): text searches like `"coffee shops in Seattle"` that auto-resolve to up to N businesses each

You can mix and match. Every business is processed independently.

#### Step 2: Tune the scrape
- **Max reviews per place**: cap how many reviews to fetch (0 = unlimited)
- **Sort by**: Newest, Most Relevant, Highest Rating, or Lowest Rating
- **Reviews start date**: skip reviews older than a date (Newest sort only)
- **Language**: affects auto-translation
- **Filters**: minimum / maximum rating, keyword filter, only-with-text filter, owner-reply-only filter
- **Skip review IDs**: bulk paste IDs from a previous run; so you're only charged for new reviews
- **Since review ID**: stop when you reach a known ID (resume mode)

#### Step 3: Read your results
Click Start. Reviews stream into the Output tab as each page is fetched. Every row carries the `status` field first (Success or a descriptive error), the full review payload, and the place metadata (name, address, rating, category, ...).

The dataset is one row per review. Use the **Overview** view for a quick scan or the **Full** view for every populated field.

### 💰 Pricing

Pay only for the reviews you actually receive.

| Event | Price | When |
|---|---|---|
| Review scraped | **$0.25 per 1,000 reviews** | per review delivered |
| Keyword filter | $0.10 per 1,000 reviews | only when **Include keyword** is set |
| Owner reply filter | $0.10 per 1,000 reviews | only when **Only with owner reply** is set |
| Search place found | $5.00 per 1,000 places | per place surfaced by a search query. Cap with **Max places per query** to bound the cost. |

No charge for places that fail to resolve, reviews you skip via Skip-IDs, or reviews dropped by filters.

### 🌐 Proxy settings

By default the Actor uses Apify's datacenter proxies, which is fast and cheap and works for nearly every place.

- **Automatic (default)**: Apify picks the best proxy.
- **Datacenter**: Fastest and cheapest. Works for most places.
- **Residential**: Switch to this if you see frequent block errors or empty pages.
- **Own proxies**: Bring your own proxy URLs.
- **No proxy**: Disable proxies entirely.

### 💡 Good to know

- **Google caps reviews per place** at roughly 4,000-5,000 even on very busy listings. The Actor stops cleanly when Google says there are no more.
- **Date filter only works with Newest sort.** Google does not support date filtering on other sort modes.
- **Skip-IDs are free**: paste up to thousands of review IDs from a prior run; they're filtered out before any charge.
- **Resume mode**: set Since review ID to the most recent review ID from the previous run. The Actor stops when it hits that ID, so monitoring runs only collect what's new.
- **Output toggles** let you trim each row to just the fields you need.
- Files and datasets are stored in your Apify storage. How long they're kept depends on your Apify plan.

### ❓ FAQ

**Why are some review fields null?**
Google does not always populate every field. Reviews without text, without owner replies, or without attached photos return null for those fields. That's expected; it's how the data is on Google's side.

**Why didn't I get all reviews?**
Google has a hard cap of about 4,000-5,000 reviews per place even when the listing reports more. Switching sort modes (Most Relevant vs Newest) sometimes surfaces a different set of reviews because Google partitions them.

**Which proxy should I use?**
Start with the default. If you see lots of failed places or empty pages, switch to Residential.

**Can I scrape from search queries (like 'restaurants in Miami')?**
Yes. Paste them in the Search queries field. Each query resolves to up to Max places per query businesses (default 10, max 120). Charged at $5 per 1,000 places surfaced by the search.

**How do I run incremental monitoring?**
Save the most recent review ID from each run. On the next run, paste it into Since review ID. The Actor stops when it reaches that ID, so only new reviews are scraped and charged.

### 🔗 Other tools you might like

- [Google Maps Business Leads Scraper](https://apify.com/lurkapi/google-maps-business-leads-scraper) - Scrape places, contacts, emails, phones, and socials from Google Maps.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with Google's Terms of Service and applicable laws in your jurisdiction. The developer is not liable for misuse. Data availability depends on Google Maps at run time.

**Keywords:** google maps, reviews, scraper, business reviews, reputation monitoring, sentiment analysis, places api alternative

# Actor input Schema

## `startUrls` (type: `array`):

Paste Google Maps URLs to the businesses you want to scrape reviews for. Long URLs (google.com/maps/place/...), share links (maps.app.goo.gl/...), and place URLs all work.
## `placeIds` (type: `array`):

Google place IDs (e.g. ChIJD7fiBh9u5kcRYJSMaMOCCwQ). Faster than parsing URLs.
## `cids` (type: `array`):

Numeric Google CIDs (the long number after cid= in old-style URLs). Each one resolves to a single business.
## `searchQueries` (type: `array`):

Google Maps text search queries (e.g. 'coffee shops in Seattle'). Each query is resolved to up to Max places per query businesses, and reviews are scraped for each. Adds $5.00 per 1,000 places found.
## `maxPlacesPerQuery` (type: `integer`):

How many businesses to scrape per search query. Google caps results at ~120 per query.
## `maxReviewsPerPlace` (type: `integer`):

Cap how many reviews are returned per business. Use 0 to fetch all available reviews. Google itself caps at roughly 4,000 to 5,000 reviews per place even for very busy listings.
## `sortBy` (type: `string`):

How Google should order the reviews. Newest is required if you set a Reviews start date below.
## `reviewsStartDate` (type: `string`):

Skip reviews older than this date. Only works when Sort by is set to Newest first (Google does not support server-side date filtering for other sorts).
## `language` (type: `string`):

Google interface language (two-letter code, e.g. en, fr, es). Affects auto-translation of review text.
## `country` (type: `string`):

Google region (two-letter country code, e.g. US, FR, ES).
## `minRating` (type: `integer`):

Drop reviews below this star rating.
## `maxRating` (type: `integer`):

Drop reviews above this star rating.
## `includeKeyword` (type: `string`):

Only reviews whose text matches this keyword are returned. Adds $0.10 per 1,000 reviews returned.
## `onlyWithText` (type: `boolean`):

Drop star-only reviews that have no written comment.
## `onlyWithOwnerReply` (type: `boolean`):

Drop reviews that have no owner reply. Adds $0.10 per 1,000 reviews returned.
## `excludeReviewIds` (type: `array`):

Bulk-paste review IDs you've already collected (one per line). They're skipped without charge. Useful for incremental monitoring runs.
## `sinceReviewId` (type: `string`):

Stop scraping when this review ID is reached. Use the most recent review ID from a previous run to fetch only what's new.
## `outputReviewId` (type: `boolean`):

Google's unique identifier for each review.
## `outputReviewUrl` (type: `boolean`):

Direct link to the review on Google Maps.
## `outputStars` (type: `boolean`):

Number of stars the reviewer gave.
## `outputText` (type: `boolean`):

The review text in its original language.
## `outputTextTranslated` (type: `boolean`):

Google's auto-translation of the review text into your interface language, when available.
## `outputOriginalLanguage` (type: `boolean`):

Detected language of the review text (BCP-47 code).
## `outputTranslatedLanguage` (type: `boolean`):

Language Google translated the review into, when applicable.
## `outputPublishedAt` (type: `boolean`):

Human-readable relative date (such as '3 weeks ago').
## `outputPublishedAtIso` (type: `boolean`):

Exact publish date in ISO 8601 format.
## `outputLastEditedAtIso` (type: `boolean`):

Last edit date in ISO 8601 format. Equals the publish date when the review was never edited.
## `outputReviewerId` (type: `boolean`):

Google's obfuscated user ID for the reviewer.
## `outputReviewerName` (type: `boolean`):

Display name of the reviewer.
## `outputReviewerUrl` (type: `boolean`):

Link to the reviewer's contributor page.
## `outputReviewerPhotoUrl` (type: `boolean`):

Reviewer's profile picture URL.
## `outputIsLocalGuide` (type: `boolean`):

True if the reviewer is a Google Local Guide.
## `outputReviewerTotalReviews` (type: `boolean`):

Total number of reviews this reviewer has posted across Google Maps.
## `outputReviewerTotalPhotos` (type: `boolean`):

Total number of photos this reviewer has uploaded across Google Maps.
## `outputOwnerReplyText` (type: `boolean`):

Business owner's reply to the review, when present.
## `outputOwnerReplyPublishedAtIso` (type: `boolean`):

Date the owner reply was published.
## `outputReviewImageUrls` (type: `boolean`):

Photos the reviewer attached to the review.
## `outputReviewDetailedRating` (type: `boolean`):

Per-aspect ratings the reviewer set, when applicable (Food / Service / Atmosphere / etc.).
## `outputPlaceId` (type: `boolean`):

Google place identifier for the business this review belongs to.
## `outputCid` (type: `boolean`):

Numeric Google CID for the business.
## `outputFid` (type: `boolean`):

Hex feature ID Google uses internally (e.g. 0x...:0x...).
## `outputPlaceName` (type: `boolean`):

Display name of the business.
## `outputPlaceUrl` (type: `boolean`):

Direct link to the business listing on Google Maps.
## `outputPlaceAddress` (type: `boolean`):

Full street address of the business.
## `outputPlaceRating` (type: `boolean`):

Average review rating of the business (1 to 5).
## `outputPlaceCategory` (type: `boolean`):

First category Google assigns to the business.
## `outputPlaceCategories` (type: `boolean`):

All categories Google assigns to the business.
## `outputPlaceLatitude` (type: `boolean`):

Latitude in decimal degrees.
## `outputPlaceLongitude` (type: `boolean`):

Longitude in decimal degrees.
## `outputPlaceWebsite` (type: `boolean`):

Business website URL listed on Google Maps.
## `outputPlacePhone` (type: `boolean`):

Business phone number listed on Google Maps.
## `outputInputUrl` (type: `boolean`):

The URL, place ID, or CID from your input that produced this row.
## `outputSearchQuery` (type: `boolean`):

Search query that surfaced this place. Empty for places provided directly via URL / place ID / CID.
## `outputScrapedAt` (type: `boolean`):

Timestamp this row was scraped.
## `proxyConfig` (type: `object`):

Proxy used for Google Maps requests. Datacenter is the default for cost efficiency. Switch to Residential if you see frequent blocks.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.google.com/maps/place/data=!4m2!3m1!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0"
  ],
  "maxPlacesPerQuery": 10,
  "maxReviewsPerPlace": 1000,
  "sortBy": "newest",
  "language": "en",
  "country": "US",
  "onlyWithText": false,
  "onlyWithOwnerReply": false,
  "outputReviewId": true,
  "outputReviewUrl": true,
  "outputStars": true,
  "outputText": true,
  "outputTextTranslated": true,
  "outputOriginalLanguage": true,
  "outputTranslatedLanguage": true,
  "outputPublishedAt": true,
  "outputPublishedAtIso": true,
  "outputLastEditedAtIso": true,
  "outputReviewerId": true,
  "outputReviewerName": true,
  "outputReviewerUrl": true,
  "outputReviewerPhotoUrl": true,
  "outputIsLocalGuide": true,
  "outputReviewerTotalReviews": true,
  "outputReviewerTotalPhotos": true,
  "outputOwnerReplyText": true,
  "outputOwnerReplyPublishedAtIso": true,
  "outputReviewImageUrls": true,
  "outputReviewDetailedRating": true,
  "outputPlaceId": true,
  "outputCid": true,
  "outputFid": true,
  "outputPlaceName": true,
  "outputPlaceUrl": true,
  "outputPlaceAddress": true,
  "outputPlaceRating": true,
  "outputPlaceCategory": true,
  "outputPlaceCategories": true,
  "outputPlaceLatitude": true,
  "outputPlaceLongitude": true,
  "outputPlaceWebsite": true,
  "outputPlacePhone": true,
  "outputInputUrl": true,
  "outputSearchQuery": true,
  "outputScrapedAt": true,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
````

# Actor output Schema

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

No description

## `full` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.google.com/maps/place/data=!4m2!3m1!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0"
    ],
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/google-maps-reviews-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 = {
    "startUrls": ["https://www.google.com/maps/place/data=!4m2!3m1!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0"],
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/google-maps-reviews-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 '{
  "startUrls": [
    "https://www.google.com/maps/place/data=!4m2!3m1!1s0x47e66e2964e34e2d:0x8ddca9ee380ef7e0"
  ],
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lurkapi/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper",
        "description": "Scrape full Google Maps reviews from any business by URL, place ID, or CID. Filter by rating, date, and keyword. Skip already-collected review IDs for incremental runs.",
        "version": "0.0",
        "x-build-id": "8kUtebYqjdiv08PoF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-google-maps-reviews-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/lurkapi~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-google-maps-reviews-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/lurkapi~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-google-maps-reviews-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": {
                    "startUrls": {
                        "title": "Google Maps URLs",
                        "type": "array",
                        "description": "Paste Google Maps URLs to the businesses you want to scrape reviews for. Long URLs (google.com/maps/place/...), share links (maps.app.goo.gl/...), and place URLs all work.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "Place IDs",
                        "type": "array",
                        "description": "Google place IDs (e.g. ChIJD7fiBh9u5kcRYJSMaMOCCwQ). Faster than parsing URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cids": {
                        "title": "CIDs",
                        "type": "array",
                        "description": "Numeric Google CIDs (the long number after cid= in old-style URLs). Each one resolves to a single business.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries ($)",
                        "type": "array",
                        "description": "Google Maps text search queries (e.g. 'coffee shops in Seattle'). Each query is resolved to up to Max places per query businesses, and reviews are scraped for each. Adds $5.00 per 1,000 places found.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPlacesPerQuery": {
                        "title": "Max places per query",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How many businesses to scrape per search query. Google caps results at ~120 per query.",
                        "default": 10
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap how many reviews are returned per business. Use 0 to fetch all available reviews. Google itself caps at roughly 4,000 to 5,000 reviews per place even for very busy listings.",
                        "default": 1000
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "mostRelevant",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "How Google should order the reviews. Newest is required if you set a Reviews start date below.",
                        "default": "newest"
                    },
                    "reviewsStartDate": {
                        "title": "Reviews start date (only newer than)",
                        "type": "string",
                        "description": "Skip reviews older than this date. Only works when Sort by is set to Newest first (Google does not support server-side date filtering for other sorts)."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google interface language (two-letter code, e.g. en, fr, es). Affects auto-translation of review text.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Google region (two-letter country code, e.g. US, FR, ES).",
                        "default": "US"
                    },
                    "minRating": {
                        "title": "Minimum rating (1-5)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop reviews below this star rating."
                    },
                    "maxRating": {
                        "title": "Maximum rating (1-5)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop reviews above this star rating."
                    },
                    "includeKeyword": {
                        "title": "Include keyword ($)",
                        "type": "string",
                        "description": "Only reviews whose text matches this keyword are returned. Adds $0.10 per 1,000 reviews returned."
                    },
                    "onlyWithText": {
                        "title": "Only reviews with text",
                        "type": "boolean",
                        "description": "Drop star-only reviews that have no written comment.",
                        "default": false
                    },
                    "onlyWithOwnerReply": {
                        "title": "Only reviews with an owner reply ($)",
                        "type": "boolean",
                        "description": "Drop reviews that have no owner reply. Adds $0.10 per 1,000 reviews returned.",
                        "default": false
                    },
                    "excludeReviewIds": {
                        "title": "Skip review IDs",
                        "type": "array",
                        "description": "Bulk-paste review IDs you've already collected (one per line). They're skipped without charge. Useful for incremental monitoring runs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sinceReviewId": {
                        "title": "Since review ID (resume mode)",
                        "type": "string",
                        "description": "Stop scraping when this review ID is reached. Use the most recent review ID from a previous run to fetch only what's new."
                    },
                    "outputReviewId": {
                        "title": "Review ID",
                        "type": "boolean",
                        "description": "Google's unique identifier for each review.",
                        "default": true
                    },
                    "outputReviewUrl": {
                        "title": "Review URL",
                        "type": "boolean",
                        "description": "Direct link to the review on Google Maps.",
                        "default": true
                    },
                    "outputStars": {
                        "title": "Star rating (1-5)",
                        "type": "boolean",
                        "description": "Number of stars the reviewer gave.",
                        "default": true
                    },
                    "outputText": {
                        "title": "Review text",
                        "type": "boolean",
                        "description": "The review text in its original language.",
                        "default": true
                    },
                    "outputTextTranslated": {
                        "title": "Review text (translated)",
                        "type": "boolean",
                        "description": "Google's auto-translation of the review text into your interface language, when available.",
                        "default": true
                    },
                    "outputOriginalLanguage": {
                        "title": "Original language",
                        "type": "boolean",
                        "description": "Detected language of the review text (BCP-47 code).",
                        "default": true
                    },
                    "outputTranslatedLanguage": {
                        "title": "Translated language",
                        "type": "boolean",
                        "description": "Language Google translated the review into, when applicable.",
                        "default": true
                    },
                    "outputPublishedAt": {
                        "title": "Published at (relative)",
                        "type": "boolean",
                        "description": "Human-readable relative date (such as '3 weeks ago').",
                        "default": true
                    },
                    "outputPublishedAtIso": {
                        "title": "Published at (ISO 8601)",
                        "type": "boolean",
                        "description": "Exact publish date in ISO 8601 format.",
                        "default": true
                    },
                    "outputLastEditedAtIso": {
                        "title": "Last edited at (ISO 8601)",
                        "type": "boolean",
                        "description": "Last edit date in ISO 8601 format. Equals the publish date when the review was never edited.",
                        "default": true
                    },
                    "outputReviewerId": {
                        "title": "Reviewer ID",
                        "type": "boolean",
                        "description": "Google's obfuscated user ID for the reviewer.",
                        "default": true
                    },
                    "outputReviewerName": {
                        "title": "Reviewer name",
                        "type": "boolean",
                        "description": "Display name of the reviewer.",
                        "default": true
                    },
                    "outputReviewerUrl": {
                        "title": "Reviewer profile URL",
                        "type": "boolean",
                        "description": "Link to the reviewer's contributor page.",
                        "default": true
                    },
                    "outputReviewerPhotoUrl": {
                        "title": "Reviewer photo URL",
                        "type": "boolean",
                        "description": "Reviewer's profile picture URL.",
                        "default": true
                    },
                    "outputIsLocalGuide": {
                        "title": "Is Local Guide",
                        "type": "boolean",
                        "description": "True if the reviewer is a Google Local Guide.",
                        "default": true
                    },
                    "outputReviewerTotalReviews": {
                        "title": "Reviewer total reviews",
                        "type": "boolean",
                        "description": "Total number of reviews this reviewer has posted across Google Maps.",
                        "default": true
                    },
                    "outputReviewerTotalPhotos": {
                        "title": "Reviewer total photos",
                        "type": "boolean",
                        "description": "Total number of photos this reviewer has uploaded across Google Maps.",
                        "default": true
                    },
                    "outputOwnerReplyText": {
                        "title": "Owner reply text",
                        "type": "boolean",
                        "description": "Business owner's reply to the review, when present.",
                        "default": true
                    },
                    "outputOwnerReplyPublishedAtIso": {
                        "title": "Owner reply published at (ISO 8601)",
                        "type": "boolean",
                        "description": "Date the owner reply was published.",
                        "default": true
                    },
                    "outputReviewImageUrls": {
                        "title": "Review image URLs",
                        "type": "boolean",
                        "description": "Photos the reviewer attached to the review.",
                        "default": true
                    },
                    "outputReviewDetailedRating": {
                        "title": "Detailed rating (per aspect)",
                        "type": "boolean",
                        "description": "Per-aspect ratings the reviewer set, when applicable (Food / Service / Atmosphere / etc.).",
                        "default": true
                    },
                    "outputPlaceId": {
                        "title": "Place ID",
                        "type": "boolean",
                        "description": "Google place identifier for the business this review belongs to.",
                        "default": true
                    },
                    "outputCid": {
                        "title": "CID",
                        "type": "boolean",
                        "description": "Numeric Google CID for the business.",
                        "default": true
                    },
                    "outputFid": {
                        "title": "Feature ID (FID)",
                        "type": "boolean",
                        "description": "Hex feature ID Google uses internally (e.g. 0x...:0x...).",
                        "default": true
                    },
                    "outputPlaceName": {
                        "title": "Place name",
                        "type": "boolean",
                        "description": "Display name of the business.",
                        "default": true
                    },
                    "outputPlaceUrl": {
                        "title": "Place URL",
                        "type": "boolean",
                        "description": "Direct link to the business listing on Google Maps.",
                        "default": true
                    },
                    "outputPlaceAddress": {
                        "title": "Place address",
                        "type": "boolean",
                        "description": "Full street address of the business.",
                        "default": true
                    },
                    "outputPlaceRating": {
                        "title": "Place average rating",
                        "type": "boolean",
                        "description": "Average review rating of the business (1 to 5).",
                        "default": true
                    },
                    "outputPlaceCategory": {
                        "title": "Place primary category",
                        "type": "boolean",
                        "description": "First category Google assigns to the business.",
                        "default": true
                    },
                    "outputPlaceCategories": {
                        "title": "Place categories (all)",
                        "type": "boolean",
                        "description": "All categories Google assigns to the business.",
                        "default": true
                    },
                    "outputPlaceLatitude": {
                        "title": "Place latitude",
                        "type": "boolean",
                        "description": "Latitude in decimal degrees.",
                        "default": true
                    },
                    "outputPlaceLongitude": {
                        "title": "Place longitude",
                        "type": "boolean",
                        "description": "Longitude in decimal degrees.",
                        "default": true
                    },
                    "outputPlaceWebsite": {
                        "title": "Place website",
                        "type": "boolean",
                        "description": "Business website URL listed on Google Maps.",
                        "default": true
                    },
                    "outputPlacePhone": {
                        "title": "Place phone",
                        "type": "boolean",
                        "description": "Business phone number listed on Google Maps.",
                        "default": true
                    },
                    "outputInputUrl": {
                        "title": "Source input",
                        "type": "boolean",
                        "description": "The URL, place ID, or CID from your input that produced this row.",
                        "default": true
                    },
                    "outputSearchQuery": {
                        "title": "Source search query",
                        "type": "boolean",
                        "description": "Search query that surfaced this place. Empty for places provided directly via URL / place ID / CID.",
                        "default": true
                    },
                    "outputScrapedAt": {
                        "title": "Scraped at (ISO 8601)",
                        "type": "boolean",
                        "description": "Timestamp this row was scraped.",
                        "default": true
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy used for Google Maps requests. Datacenter is the default for cost efficiency. Switch to Residential if you see frequent blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
