# Google Maps Reviews Scraper ✅ $0.20/1k reviews (`x_guru/google-maps-reviews-scraper`) Actor

$0.20/1k reviews. Fast Google Maps reviews scraper for place URLs, review URLs, CID URLs, and Place IDs. Extract review text, ratings, dates, review URLs, reviewer profiles, owner replies, context fields, detailed ratings, and place metadata.

- **URL**: https://apify.com/x\_guru/google-maps-reviews-scraper.md
- **Developed by:** [Hundevmode Labs](https://apify.com/x_guru) (community)
- **Categories:** Lead generation, Other, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 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: Extract Google Reviews, Ratings, Review URLs & Reviewer Data

Use this Google Maps Reviews Scraper to extract reviews from exact Google Maps places. Add Google Maps place URLs, `cid` URLs, Google review URLs, or Google Place IDs, and the actor saves one dataset item per review.

It is built for reputation monitoring, local SEO, sentiment analysis, competitor research, review exports, customer feedback analysis, and Google Maps review datasets. The scraper resolves the selected Google Maps place first, then fetches reviews through the fast Google Maps reviews RPC with cursor pagination.

![Google Maps review detail page with a review, rating, structured context, and map](https://api.apify.com/v2/key-value-stores/RgWfy9bTkPpSqNzrV/records/google-maps-review-detail-joes-pizza.png)

### AI agent skill

Use the dedicated [Google Maps Reviews Scraper Apify agent skill](https://github.com/hundevmode/apify-google-maps-reviews-scraper-agent-skill) when you want AI agents to prepare place URLs or Place IDs, run this actor through Apify, control spend with `maxTotalChargeUsd`, and return review rows for reputation monitoring, local SEO, sentiment analysis, datasets, or automation workflows.

Install with skills.sh-compatible agents:

```bash
npx skills add hundevmode/apify-google-maps-reviews-scraper-agent-skill \
  --skill google-maps-reviews-scraper-apify
````

ClawHub skill slug: `google-maps-reviews-scraper-apify`.

### At a glance

| Need | Use this Google Maps review scraper for |
| --- | --- |
| Review exports | Extract review text, star rating, publish date, review ID, and direct review URL |
| Reviewer profiles | Collect public reviewer ID, name, profile URL, photo URL, Local Guide status, and public review count |
| Place context | Attach place title, address, category, coordinates, rating, reviews count, Place ID, CID, FID, and Google Maps URL to every review |
| Review filters | Keep only reviews matching a keyword or posted after a date |
| Sorting | Scrape newest, most relevant, highest rating, or lowest rating reviews |
| Price | Paid tiers from $0.20 / 1,000 saved reviews |
| Diagnostics | Get `RUN_SUMMARY` with source status, review status, saved counts, duration, and charge-budget details |

### Pricing

This actor uses Apify pay-per-event pricing. It charges for saved review records, not for empty pages or skipped sources.

| Event | Free plan | Paid plans |
| --- | ---: | ---: |
| Review scraped | $0.50 / 1,000 saved reviews | $0.20 / 1,000 saved reviews |
| Actor start | $0.00005 per run | $0.00001 per run |

If you set a maximum cost for a run, the actor calculates how many `review-scraped` events fit into the budget and reduces the review target before scraping. When the budget is exhausted, it exits cleanly and writes the reason to `RUN_SUMMARY`.

### What can this Google Maps Reviews Scraper do?

- Scrape Google reviews from direct Google Maps place URLs.
- Scrape reviews from `google.com/maps?cid=...` URLs.
- Resolve Google review detail URLs such as `google.com/maps/reviews/data=...` back to the reviewed place.
- Scrape reviews from Google Place IDs.
- Save one dataset item per review, which makes JSON, CSV, Excel, API, and database exports straightforward.
- Extract review text, rating, review ID, review URL, original language, relative publish text, and best-effort normalized date.
- Extract structured review context when Google exposes it, for example `orderType`, `mealType`, `pricePerPerson`, `food`, `service`, `atmosphere`, park tips, hotel sub-ratings, and similar guided review answers.
- Include public reviewer profile data returned by Google Maps.
- Add place metadata to each review row so every record is self-contained.
- Continue pagination with Google review cursors to collect hundreds or thousands of reviews from one place.

This actor is for exact places. It does not expand broad Google Maps search URLs into many places. Use the main Google Maps Scraper for discovery by keyword, area, category, or map viewport, then scrape reviews through its Reviews add-on or pass exact place URLs / Place IDs to this actor.

### Quick start

Scrape reviews from one Google Maps place URL:

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3"
    }
  ],
  "maxReviews": 100,
  "reviewsSort": "newest",
  "language": "en"
}
```

Scrape reviews from Place IDs:

```json
{
  "placeIds": ["ChIJ8Q2WSpJZwokRQz-bYYgEskM"],
  "maxReviews": 250,
  "reviewsSort": "mostRelevant",
  "language": "en"
}
```

### Input options

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Google Maps place URLs, `google.com/maps?cid=...` URLs, or Google review detail URLs. |
| `placeIds` | array | Google Place IDs. Values prefixed with `place_id:` and URLs containing `query_place_id` are accepted. |
| `maxReviews` | integer | Maximum number of reviews to save per place. |
| `reviewsSort` | string | `newest`, `mostRelevant`, `highestRanking`, or `lowestRanking`. |
| `reviewsStartDate` | string | Optional date filter. Choose an absolute date or a relative value such as `8 days`, `3 months`, or `1 year`. |
| `reviewsOrigin` | string | `google` or `all`. The current Google Maps reviews RPC returns Google-native reviews; `all` is accepted for compatibility. |
| `language` | string | Google Maps interface language, for example `en`, `es`, `de`, `fr`, `ja`, or `vi`. |
| `personalData` | boolean | Include public reviewer profile data when available. Default is `true`. |

### URL and ID behavior

| Input | Supported | Notes |
| --- | --- | --- |
| Direct Google Maps place URL | Yes | Best input when you already know the business or location. |
| `google.com/maps?cid=...` URL | Yes | The actor resolves the CID to a place and then fetches reviews. |
| Google review detail URL | Yes | URLs like `google.com/maps/reviews/data=...` are resolved through the review CID. |
| Google Place ID | Yes | Use `placeIds` or a URL containing `query_place_id`. |
| Broad Google Maps search URL | Not expanded | Use the main Google Maps Scraper for search/discovery workflows. |

### Date filtering examples

Get newest reviews posted after a date:

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3"
    }
  ],
  "maxReviews": 25,
  "reviewsSort": "newest",
  "reviewsStartDate": "2026-01-01",
  "language": "en"
}
```

Get reviews from the last 3 months:

```json
{
  "placeIds": ["ChIJ8Q2WSpJZwokRQz-bYYgEskM"],
  "maxReviews": 100,
  "reviewsStartDate": "3 months",
  "reviewsSort": "newest"
}
```

Google often returns dates as relative text, for example `a week ago` or `3 months ago`. Date filtering is therefore best-effort. For date-filtered runs, use `reviewsSort: "newest"` so the actor scans the newest review pages first.

When `reviewsStartDate` is active, the scraper requests full 200-review pages and keeps scanning until it saves enough matching reviews or Google exhausts pagination.

### Output

Each dataset item is one Google Maps review. Review data, reviewer data, and place data are combined into the same row so exports are easy to use in BI tools, spreadsheets, databases, and APIs.

| Group | Fields |
| --- | --- |
| Source | `searchString`, `inputStartUrl`, `inputPlaceId`, `rank`, `searchPageUrl`, `searchPageLoadedUrl` |
| Review | `reviewId`, `reviewUrl`, `text`, `publishAt`, `publishedAtDate`, `stars`, `rating`, `likesCount`, `reviewOrigin`, `originalLanguage`, `translatedLanguage` |
| Owner response | `responseFromOwnerDate`, `responseFromOwnerText` |
| Review extras | `reviewImageUrls`, `reviewContext`, `reviewDetailedRating`, `visitedIn`, `isAdvertisement` |
| Reviewer | `reviewerId`, `reviewerUrl`, `name`, `reviewerNumberOfReviews`, `isLocalGuide`, `reviewerPhotoUrl` |
| Place | `title`, `placeId`, `fid`, `cid`, `categoryName`, `categories`, `totalScore`, `reviewsCount`, `url`, `imageUrl` |
| Address | `address`, `neighborhood`, `street`, `city`, `postalCode`, `state`, `countryCode`, `location` |
| Runtime | `scrapedAt`, `language` |

Example output item:

```json
{
  "searchString": "https://www.google.com/maps/place/Joe's+Pizza/...",
  "inputStartUrl": "https://www.google.com/maps/place/Joe's+Pizza/...",
  "reviewerId": "103238366514610497903",
  "reviewerUrl": "https://www.google.com/maps/contrib/103238366514610497903?hl=en-US",
  "name": "Kelly Chan",
  "reviewerNumberOfReviews": 358,
  "isLocalGuide": true,
  "text": "Food: 4 Stars Service: 4 Stars...",
  "publishAt": "6 months ago",
  "publishedAtDate": "2025-12-01",
  "reviewId": "Ci9DQUlRQUNvZENod...",
  "reviewUrl": "https://www.google.com/maps/reviews/data=...",
  "reviewOrigin": "Google",
  "stars": 4,
  "rating": 4,
  "reviewContext": {
    "orderType": "Take out",
    "mealType": "Dinner",
    "pricePerPerson": "$1 to $10",
    "reservation": "Walk-ins only"
  },
  "reviewDetailedRating": {
    "food": 4,
    "service": 4,
    "atmosphere": 4
  },
  "title": "Joe's Pizza",
  "categoryName": "Pizza restaurant",
  "totalScore": 4.4,
  "url": "https://www.google.com/maps/place/Joe's+Pizza/...",
  "fid": "0x89c259924a960df1:0x43b20488619b3f43",
  "cid": "4877966330195296067",
  "scrapedAt": "2026-06-01T00:00:00+00:00",
  "language": "en"
}
```

Not every Google review exposes every field. Owner responses, attached review images, detailed sub-ratings, visit context, exact dates, and reviewer stats are returned when Google Maps provides them in the public payload.

### Popular use cases

- Monitor Google reviews for a brand, venue, franchise, local business, hotel, restaurant, clinic, agency, or service area business.
- Export Google Maps reviews to CSV, Excel, BigQuery, Snowflake, Airtable, or a CRM.
- Build sentiment analysis datasets from Google review text and star ratings.
- Compare competitors by rating, review volume, review freshness, and common customer complaints.
- Track owner responses and response coverage when Google exposes them.
- Collect reviewer profile URLs for manual QA or compliance-approved research.
- Enrich existing Place ID or CID lists with fresh Google review data.

### Speed and scale

The actor uses the Google Maps `listentitiesreviews` endpoint with cursor pagination. It requests up to 200 reviews per page and uses the cursor from the previous page to continue.

Measured local speed without proxy:

| Place type | Reviews | End-to-end time |
| --- | ---: | ---: |
| Restaurant place page | 1,000 | about 6.8 seconds |
| Large review-heavy place page | 1,000 | about 6.8-7.1 seconds |

Small runs still request at least 100 reviews from Google internally and then save only the requested number. This makes limits such as 5 or 10 more reliable because Google sometimes returns empty review payloads for very small page sizes.

For multiple places, the actor processes sources conservatively by default to keep review pagination stable.

### Run summary

The actor writes a `RUN_SUMMARY` record to the default key-value store. It includes:

- `target`: planned number of review items for the run.
- `saved`: number of saved review items.
- `targetReached`: whether the planned target was reached.
- `exhaustionReason`: `target_reached`, `sources_exhausted`, `charge_limit_reached`, `review_charge_budget_exhausted`, or `runtime_error_suppressed`.
- `sourceStats`: per-place detail status, reviews status, fetched count, saved count, and rating distribution.
- `failedSources`: places that could not be resolved.
- `reviewBudget`: pay-per-event charge budget diagnostics.
- `durationMs`: total run duration.

Runtime errors are suppressed by default and written to `RUN_SUMMARY`, so the run can finish with partial data and structured diagnostics instead of failing without usable output.

### API usage

Start a run through the Apify API:

```bash
curl "https://api.apify.com/v2/acts/x_guru~google-maps-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      {
        "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3"
      }
    ],
    "maxReviews": 100,
    "reviewsSort": "newest",
    "language": "en"
  }'
```

After the run finishes, export the default dataset as JSON, CSV, Excel, XML, RSS, or HTML from Apify Storage.

### Local speed probe

The repository includes a local probe script for quick experiments:

```bash
python3 scripts/local_reviews_speed_probe.py --max-reviews 100 --source-concurrency 1 --output local-reviews-speed-c1.json
python3 scripts/local_reviews_speed_probe.py --max-reviews 1000 --source-concurrency 3 --output local-reviews-speed-c3.json
```

For production-like numbers, run the probe on Apify. Direct local IP behavior can differ from cloud runs.

### Privacy and compliance

Google Maps reviews can include public reviewer profile data such as reviewer name, profile URL, reviewer ID, Local Guide status, and profile photo. Use the exported data only when your use case and local laws allow collecting and processing this information.

If you only need review text and ratings, turn `personalData` off. Review IDs, review URLs, review text, rating, and place fields remain available.

### Troubleshooting

| Symptom | What to check |
| --- | --- |
| No sources | Provide at least one `startUrls` item or one `placeIds` value. |
| `place_not_resolved` | Use a direct place URL, CID URL, review data URL, or Place ID. Broad search URLs are not expanded by this actor. |
| `blocked_or_empty` | Run on Apify cloud. Direct local IPs may get empty review payloads. |
| Fewer reviews than requested | The place may have fewer reviews, filters may remove reviews, Google may exhaust pagination, or the run budget may limit saved events. |
| Date filter seems loose | Google often returns relative dates; the actor infers dates best-effort. Use `reviewsSort: "newest"` for date-filtered runs. |
| Missing owner response, images, or detailed ratings | Google Maps does not expose those fields for every review in the reviews RPC. |

# Actor input Schema

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

Google Maps URLs to scrape reviews from. Best inputs are direct place URLs, google.com/maps?cid=... URLs, or Google review data URLs. Broad Google Maps search URLs are not expanded into multiple places by this reviews-only actor; use the main Google Maps Scraper when you need discovery.

## `placeIds` (type: `array`):

Google Place IDs to scrape. You can paste raw Place IDs, values prefixed with place\_id:, or Google Maps URLs containing query\_place\_id.

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

Maximum number of reviews to save for each place. If a run has a maximum cost limit, the actor reduces the total target before scraping so it does not exceed the available review events.

## `reviewsSort` (type: `string`):

Google Maps review order used by the reviews RPC.

## `reviewsStartDate` (type: `string`):

Optional date filter. Choose an absolute date or a relative value such as 8 days, 3 months, or 1 year. Google returns many dates as relative text, so date filtering is best-effort.

## `reviewsOrigin` (type: `string`):

Review source selector. Google reviews uses native Google Maps reviews. All available reviews is accepted for compatibility and returns Google reviews when the Google reviews RPC does not expose third-party sources.

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

Google Maps interface language used for returned labels, relative dates, review URLs, and reviewer profile URLs.

## `personalData` (type: `boolean`):

Include public reviewer profile data such as reviewer name, profile URL, reviewer ID, profile photo, Local Guide status, and reviewer review count when Google exposes it.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3"
    }
  ],
  "maxReviews": 100,
  "reviewsSort": "newest",
  "reviewsOrigin": "google",
  "language": "en",
  "personalData": true
}
```

# Actor output Schema

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

One dataset item per Google Maps review, including review data, optional reviewer profile data, and place metadata.

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

Run-level diagnostics, including target, saved count, skipped places, per-source review statuses, duration, and pay-per-event budget details.

# 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": [
        {
            "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3"
        }
    ],
    "maxReviews": 100,
    "reviewsSort": "newest",
    "reviewsStartDate": "",
    "reviewsOrigin": "google",
    "language": "en",
    "personalData": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("x_guru/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": [{ "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3" }],
    "maxReviews": 100,
    "reviewsSort": "newest",
    "reviewsStartDate": "",
    "reviewsOrigin": "google",
    "language": "en",
    "personalData": True,
}

# Run the Actor and wait for it to finish
run = client.actor("x_guru/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": [
    {
      "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3"
    }
  ],
  "maxReviews": 100,
  "reviewsSort": "newest",
  "reviewsStartDate": "",
  "reviewsOrigin": "google",
  "language": "en",
  "personalData": true
}' |
apify call x_guru/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper ✅ $0.20/1k reviews",
        "description": "$0.20/1k reviews. Fast Google Maps reviews scraper for place URLs, review URLs, CID URLs, and Place IDs. Extract review text, ratings, dates, review URLs, reviewer profiles, owner replies, context fields, detailed ratings, and place metadata.",
        "version": "0.1",
        "x-build-id": "U6d79CBpt7k6yIUSG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/x_guru~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-x_guru-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/x_guru~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-x_guru-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/x_guru~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-x_guru-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 place URLs",
                        "type": "array",
                        "description": "Google Maps URLs to scrape reviews from. Best inputs are direct place URLs, google.com/maps?cid=... URLs, or Google review data URLs. Broad Google Maps search URLs are not expanded into multiple places by this reviews-only actor; use the main Google Maps Scraper when you need discovery.",
                        "default": [
                            {
                                "url": "https://www.google.com/maps/place/Joe%27s+Pizza/@40.7306597,-74.0021707,17z/data=!3m1!4b1!4m6!3m5!1s0x89c259924a960df1:0x43b20488619b3f43!8m2!3d40.7306597!4d-74.0021707!16s%2Fg%2F1tyyy0n3"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "placeIds": {
                        "title": "Place IDs",
                        "type": "array",
                        "description": "Google Place IDs to scrape. You can paste raw Place IDs, values prefixed with place_id:, or Google Maps URLs containing query_place_id.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Number of reviews per place",
                        "minimum": 1,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each place. If a run has a maximum cost limit, the actor reduces the total target before scraping so it does not exceed the available review events.",
                        "default": 100
                    },
                    "reviewsSort": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "mostRelevant",
                            "highestRanking",
                            "lowestRanking"
                        ],
                        "type": "string",
                        "description": "Google Maps review order used by the reviews RPC.",
                        "default": "newest"
                    },
                    "reviewsStartDate": {
                        "title": "Only reviews newer than date",
                        "pattern": "^$|^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional date filter. Choose an absolute date or a relative value such as 8 days, 3 months, or 1 year. Google returns many dates as relative text, so date filtering is best-effort."
                    },
                    "reviewsOrigin": {
                        "title": "Reviews origin",
                        "enum": [
                            "google",
                            "all"
                        ],
                        "type": "string",
                        "description": "Review source selector. Google reviews uses native Google Maps reviews. All available reviews is accepted for compatibility and returns Google reviews when the Google reviews RPC does not expose third-party sources.",
                        "default": "google"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "af",
                            "sq",
                            "am",
                            "ar",
                            "hy",
                            "az",
                            "eu",
                            "be",
                            "bn",
                            "bs",
                            "bg",
                            "ca",
                            "zh-CN",
                            "zh-TW",
                            "hr",
                            "cs",
                            "da",
                            "nl",
                            "en",
                            "et",
                            "fi",
                            "fr",
                            "ka",
                            "de",
                            "el",
                            "he",
                            "hi",
                            "hu",
                            "id",
                            "it",
                            "ja",
                            "ko",
                            "lt",
                            "ms",
                            "no",
                            "pl",
                            "pt",
                            "ro",
                            "ru",
                            "sk",
                            "sl",
                            "es",
                            "sv",
                            "th",
                            "tr",
                            "uk",
                            "vi"
                        ],
                        "type": "string",
                        "description": "Google Maps interface language used for returned labels, relative dates, review URLs, and reviewer profile URLs.",
                        "default": "en"
                    },
                    "personalData": {
                        "title": "Personal data",
                        "type": "boolean",
                        "description": "Include public reviewer profile data such as reviewer name, profile URL, reviewer ID, profile photo, Local Guide status, and reviewer review count when Google exposes it.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
