# Google Maps Place Reviews Scraper (`automation-lab/google-maps-place-reviews-scraper`) Actor

Export Google Maps reviews for any place: review text, stars, exact dates, reviewer, owner responses, photos, aspect ratings and place rating. Use place URLs, IDs or name + city. Fast HTTP, no login.

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

## Pricing

from $0.18 / 1,000 review extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Maps Place Reviews Scraper

Export **Google Maps reviews** for any place you choose — restaurants, hotels, shops, clinics, attractions or your own business locations. Give it Google Maps place URLs, place IDs or a business name with a city, and get one clean row per review: **review text, star rating, reviewer, exact date, owner response, review photos, per-aspect ratings (Food, Service, Atmosphere…)**, plus place context such as rating, total review count, address, category and coordinates.

It is a lightweight HTTP scraper: no browser, no Google login, no API key. A typical run exports 300 reviews per place in a few seconds.

### What does Google Maps Place Reviews Scraper do?

For every place you give it, the Actor:

1. Resolves the place (full Maps URL, short `maps.app.goo.gl` link, `?cid=` link, `place_id:` link, place ID, or "business name + city" search).
2. Reads the place header: name, address, average rating, total number of reviews, categories, website, phone and coordinates.
3. Pages through the place's public Google reviews in the order you choose (Newest, Most relevant, Highest rating, Lowest rating).
4. Applies your optional filters (start date, star ratings, keyword) and saves each matching review as a dataset row.

You can then download the dataset as JSON, CSV, Excel or HTML, or send it to Google Sheets, Slack, a database or your BI tool.

### Who is it for?

- **Reputation and customer-experience teams** tracking new reviews and owner responses across locations every day or week.
- **Multi-location brands and franchises** comparing ratings, complaints and service aspects between branches.
- **Agencies and local SEO consultants** auditing client and competitor review profiles and review velocity.
- **Market and competitor researchers** collecting review text for sentiment analysis, topic modeling or LLM summarization.
- **Hospitality, healthcare and retail analysts** who need Food / Service / Atmosphere / Rooms aspect ratings and visit context (dine-in vs. takeout, price per person, wait time).
- **Data scientists** building labeled review datasets in many languages, with Google's translation alongside the original text.

### Why use this scraper?

- **Fast and cheap** — plain HTTP requests to Google's public reviews feed, 50 reviews per request, 256 MB memory.
- **Exact timestamps** — `publishedAtDate` is Google's exact timestamp, not just "3 weeks ago".
- **Original + translated text** — the original review is always in `text`; when it's in another language you also get Google's translation into your chosen language.
- **Owner responses** included on the same row.
- **Rich context** — per-aspect ratings, visit details, review photos, likes, Local Guide status, reviewer review/photo counts.
- **Monitoring-friendly** — Newest sort plus a start date stops paging at the first older review, so daily runs read and pay only for new reviews plus the small per-place fee.
- **GDPR switch** — turn off personal data to drop reviewer names, IDs, profile links and avatars.
- **Clear failures** — places that don't exist are reported as "not found" instead of silently returning nothing.

### What data can you extract from Google Maps reviews?

| Field | Description |
| --- | --- |
| `reviewId`, `reviewUrl` | Stable Google review ID and direct link |
| `stars` | Star rating 1–5 |
| `text` | Original review text (null for rating-only reviews) |
| `textTranslated`, `originalLanguage`, `translatedLanguage` | Google translation and language codes |
| `publishedAtDate`, `publishAt` | Exact ISO timestamp and the relative text Google shows |
| `likesCount` | "Helpful" likes |
| `name`, `reviewerId`, `reviewerUrl`, `reviewerPhotoUrl` | Reviewer identity (optional, see personal data) |
| `reviewerNumberOfReviews`, `reviewerNumberOfPhotos`, `isLocalGuide` | Reviewer profile signals |
| `responseFromOwnerText`, `responseFromOwnerAgo` | Owner reply and its relative time |
| `reviewImageUrls` | Photos attached to the review |
| `reviewDetailedRating` | Aspect ratings, e.g. `{"Food": 5, "Service": 4}` |
| `reviewContext` | Visit details, e.g. order type, meal type, price per person |
| `title`, `address`, `categoryName`, `categories` | Place name, address and categories |
| `totalScore`, `reviewsCount` | Place average rating and total review count |
| `placeId`, `fid`, `cid`, `url`, `location`, `website`, `phone` | Place identifiers, link, coordinates and contacts |
| `searchString`, `language`, `scrapedAt` | Which input produced the row, request language, collection time |

### How much does it cost to scrape Google Maps reviews?

This Actor uses pay-per-event pricing: a small fee per run (which includes the first place), a small fee for each additional place, and a fee per saved review. Reviews are charged only when they pass your filters and are saved to the dataset.

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
| --- | --- | --- | --- | --- |
| Run start (once per run, includes the first place) | $0.0005 | $0.0005 | $0.0005 | $0.0005 |
| Additional place looked up | $0.00035372 | $0.00030758 | $0.00023992 | $0.00018455 |
| Review saved | $0.0003404 | $0.000296 | $0.00023088 | $0.0001776 |

"Additional place" is charged once for each distinct place input after the first, whether or not any reviews match your filters, because the place is still looked up and its reviews are read. Inputs that Google can't find count as a place too. Exact repeats of the same input are looked up and charged only once.

Cost examples on the Bronze tier:

- **100 reviews** of one place: $0.0005 + 100 × $0.000296 ≈ **$0.030**
- **1,000 reviews** from 10 places (100 each): $0.0005 + 9 × $0.00030758 + 1,000 × $0.000296 ≈ **$0.30**
- **Monitoring 50 locations** daily, 5 new reviews each: $0.0005 + 49 × $0.00030758 + 250 × $0.000296 ≈ **$0.089** per run
- **10,000 reviews**: ≈ **$2.96** plus the place fees

On the Apify Free plan's monthly credit you can export well over ten thousand reviews. Platform compute is included in these event prices.

### How to scrape Google Maps reviews

1. Open the Actor in Apify Console and click **Try for free**.
2. Add places: paste Google Maps place URLs, add place IDs, or type "business name + city" into **Search queries**.
3. Set **Max reviews per place** (0 = all reviews Google lists).
4. Choose a **sort order**. Use **Newest** for monitoring.
5. Optionally set **Only reviews published since**, **Star ratings** or a **Keyword filter**.
6. Click **Start** and download results from the **Output** tab as JSON, CSV or Excel.

### Input parameters

| Parameter | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Google Maps place URLs: full `/maps/place/...` URLs, `maps.app.goo.gl` share links, `?cid=` links, `place_id:` links. One place per URL. |
| `placeIds` | array | Google place IDs (`ChIJ...`) or feature IDs (`0x...:0x...`). |
| `searchQueries` | array | "Business name + city". Each query is resolved to the single best-matching place. |
| `maxReviews` | integer | Reviews saved per place after filters. Default 100; 0 = all. |
| `reviewsSort` | string | `newest` (default), `mostRelevant`, `highestRanking`, `lowestRanking`. |
| `reviewsStartDate` | string | `YYYY-MM-DD` or relative (`30 days`, `2 weeks`, `6 months`, `1 year`). |
| `reviewsFilterString` | string | Keep reviews containing this phrase (case-insensitive, original or translated text). |
| `starRatings` | array | Keep reviews with these ratings, e.g. `["1","2"]`. |
| `language` | string | Interface/translation language, e.g. `en`, `de`, `pt-BR`. Default `en`. |
| `personalData` | boolean | Include reviewer name, ID, profile URL and photo. Default `true`. |
| `proxyConfiguration` | object | Apify Proxy (datacenter) by default. Residential and Google SERP proxy groups are not supported (the run stops at once with a clear error); your own proxy URLs work. |

Example input:

```json
{
    "startUrls": [
        { "url": "https://www.google.com/maps/place/Statue+of+Liberty/data=!4m5!3m4!1s0x89c25090129c363d:0x40c6a5770d25022b!8m2!3d40.6892494!4d-74.0445004" }
    ],
    "placeIds": ["ChIJCar0f49ZwokR6ozLV-dHNTE"],
    "searchQueries": ["Cafe Sacher Wien"],
    "maxReviews": 300,
    "reviewsSort": "newest"
}
```

### Output example

One real row (reviewer identity replaced with placeholders, long texts shortened):

```json
{
    "title": "Café Sacher",
    "address": "Philharmoniker Str. 4, 1010 Wien, Austria",
    "placeId": "ChIJI85wbpwHbUcR2nlviUzwg9s",
    "fid": "0x476d079c6e70ce23:0xdb83f04c896f79da",
    "cid": "15817750527769278938",
    "categoryName": "Cafe",
    "categories": ["Cafe"],
    "totalScore": 3.9,
    "reviewsCount": 20716,
    "location": { "lat": 48.2039459, "lng": 16.3698418 },
    "phone": "+43 1 514560",
    "url": "https://www.google.com/maps?cid=15817750527769278938",
    "reviewId": "ChdDSUhNMG9nS0VJQ0FnSUMtZ2NYYnhBRRAB",
    "stars": 1,
    "text": "La acomodadora, una señora rubia, nos atendió fatal, tuvimos que esperar…",
    "textTranslated": "The hostess, a blonde woman, treated us terribly. We had to wait…",
    "originalLanguage": "es",
    "translatedLanguage": "en",
    "publishAt": "Edited a day ago",
    "publishedAtDate": "2026-10-28T08:36:47.648Z",
    "likesCount": 0,
    "name": "Reviewer Name",
    "reviewerId": "1145235341000000000",
    "reviewerUrl": "https://www.google.com/maps/contrib/1145235341000000000/reviews?hl=en",
    "reviewerNumberOfReviews": 2,
    "reviewerNumberOfPhotos": 0,
    "isLocalGuide": false,
    "responseFromOwnerText": "Thank you very much for your review. I truly regret that your visit…",
    "responseFromOwnerAgo": "3 years ago",
    "reviewImageUrls": [],
    "reviewDetailedRating": { "Food": 2, "Service": 1, "Atmosphere": 2 },
    "reviewContext": { "Order type": "Dine in", "Meal type": "Other", "Price per person": "€10–20" },
    "reviewOrigin": "Google",
    "searchString": "Cafe Sacher Wien",
    "language": "en",
    "scrapedAt": "2026-10-30T07:33:25.311Z"
}
```

The dataset has three views: **Reviews** (main table), **Reviewers** and **Place context**.

### Tips, limits and how failures are reported

- **Monitoring**: schedule the Actor daily with `reviewsSort: "newest"` and `reviewsStartDate: "2 days"`. Deduplicate across runs by `reviewId`.
- **Edited reviews**: Google reports the time of the last edit; `publishAt` then starts with "Edited". The start-date filter uses that timestamp.
- **Rating sorts**: Google's Highest/Lowest rating lists show a limited number of reviews per star level, so use Newest or Most relevant to export a place's complete history.
- **Filters are applied after download, with a read limit.** Any filter (start date, keyword or stars) reads up to 300 reviews per place, then continues only while at least one review in 15 matches. Exceptions where the scraper stops exactly instead: a start date with **Newest** sort stops at the first older review, and a star filter with **Highest/Lowest rating** sort stops when the sorted list passes your ratings. So a start date with Most relevant, Highest or Lowest sort can miss older matching reviews deep in the list; use Newest sort for complete date windows. For 1–2 star reviews, combine the star filter with Lowest rating sort. The log shows how many reviews were read and saved per place.
- **Search queries** pick one best match. For chains ("Starbucks Seattle") this is Google's top-ranked branch; add the street to target a specific branch, or use its place URL. Category searches like "plumbers in Austin" are not expanded into many places; use place URLs for that.
- **Not found**: a place ID or URL that Google doesn't know, or a query with no matching reviewed place, is logged and counted as "not found" in the final status message; other places continue.
- **Errors**: rate-limit and network errors are retried with a fresh proxy session. If every place fails, the run fails with a clear message instead of finishing empty.
- **Maximum cost per run**: if you set one, the run stops when it is reached and keeps the reviews saved so far. The final status message says "Partial results" and how many place inputs were not processed.
- **Proxy**: the default Apify datacenter proxy works for Google reviews. Residential and Google SERP proxy groups are rejected with a clear error before any work starts and before the start fee, because they cost more per run than this Actor's prices cover.
- Rating-only reviews (no text) are included with `text: null`. Use the keyword filter or post-processing to drop them.

### Integrations

- **Google Sheets**: send new reviews to a sheet with the Apify Google Sheets integration and build a reputation dashboard.
- **Slack / email alerts**: use a webhook on run success to post new 1–2 star reviews to a Slack channel for fast owner responses.
- **Zapier, Make, n8n**: trigger CRM tickets or support tasks for negative reviews.
- **BI and warehouses**: load the dataset into BigQuery, Snowflake or Postgres and track rating trends per location.
- **LLM pipelines**: feed `text`/`textTranslated` into an LLM to summarize complaints, extract topics or draft owner replies.

### Use the API

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~google-maps-place-reviews-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["Katz'\''s Delicatessen New York"],"maxReviews":100,"reviewsSort":"newest"}'
```

JavaScript:

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/google-maps-place-reviews-scraper').call({
    placeIds: ['ChIJCar0f49ZwokR6ozLV-dHNTE'],
    maxReviews: 200,
    reviewsStartDate: '30 days',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].text);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("automation-lab/google-maps-place-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.google.com/maps?cid=15817750527769278938"}],
    "maxReviews": 100,
    "starRatings": ["1", "2"],
    "reviewsSort": "lowestRanking",
})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["stars"], review["text"])
```

### Use with AI agents via MCP

Connect the Actor to Claude, Cursor or any MCP client through the Apify MCP server.

Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/google-maps-place-reviews-scraper"
```

Claude Desktop / Cursor / VS Code JSON configuration:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/google-maps-place-reviews-scraper"
        }
    }
}
```

Selecting this Actor also adds the run-status, dataset and key-value store helper tools. A safe recipe for agents:

1. **Bound the run before starting it.** Set `maxReviews` (for example 50) and a small number of places, so the run's row count is known in advance: at most places × `maxReviews` rows. Optionally set a maximum cost per run in the call options.
2. **Start one run and keep its run ID.** If the call returns before the run finishes, poll that same run with `get-actor-run` (backoff 2–10 s) until it is SUCCEEDED, FAILED, ABORTED or TIMED-OUT, with an overall deadline you choose (for example 5 minutes). Never start a duplicate run because a call timed out; if the deadline passes, report the run ID and its current status to the user instead.
3. **Read results in pages, within a total budget.** Use `get-dataset-items` with explicit `limit` (for example 20), `offset` and `fields` (for example `title,stars,text,publishedAtDate,responseFromOwnerText`). Stop when you reach your total row budget (for example 200 rows) or byte budget (for example 100 KB), and keep the rest in Apify storage.
4. **Check the size of each page before it reaches the model.** Row limits do not bound bytes: one review can be several KB, so 20 rows is usually under 20 KB but not always. If your MCP client or host can intercept tool responses, measure each page's serialized UTF-8 size before passing it to the model. When a page would exceed the remaining byte budget, either fetch fewer rows (smaller `limit`, or drop `text`/`textTranslated` from `fields`) or pass only the rows that fit and record the rest as omitted. A single row larger than the per-page budget should be summarized or skipped and reported as omitted, not passed in whole. Clients that cannot intercept tool responses cannot guarantee a hard byte ceiling; there, keep `limit` small and `fields` narrow.
5. **Report what was read and what was not.** Tell the user the dataset ID, the total row count (`itemCount` from `get-dataset-info`), the next unread `offset` (the dataset offset where you stopped, not the number of rows you passed on) and how many rows you omitted for size. Say "partial" whenever you stop before the end of the dataset.
6. **Report partial runs honestly.** The run's status message lists how many places were saved, not found and failed. If the run stopped at the maximum cost per run, the status message starts its last sentence with "Partial results" and says how many place inputs were not processed. If the run FAILED or TIMED-OUT, its dataset can still hold reviews saved before it stopped; say that the results are partial and which places are missing.
7. **Large exports** (thousands of reviews) should be downloaded by the user from the dataset (CSV/JSON/Excel) rather than read into the model context.

Example prompts:

- "Get the 50 newest Google reviews for Katz's Delicatessen in New York and summarize the main complaints."
- "Export all 1 and 2 star reviews from the last 3 months for these three hotel URLs and group them by topic."
- "Compare Food, Service and Atmosphere ratings for Café Sacher and Café Central in Vienna."

### Is it legal to scrape Google Maps reviews?

This Actor collects publicly visible reviews that anyone can see without logging in. It does not log in, bypass paywalls or access private data. Reviews do contain personal data (reviewer names and profile links), so if you work under GDPR or similar laws, make sure you have a legitimate purpose, keep only what you need, or turn off **Include reviewer personal data**. Respect Google's terms and the reviewers' rights when you republish content. If unsure, consult your lawyer.

### Error diagnostics and privacy

If a run or a place fails, the Actor sends a sanitized error report (error message, stack trace, Actor/run/build IDs and a scrubbed copy of the input with secrets, cookies, tokens and email-like values removed) to the operator's private GlitchTip instance. Reports are kept for 30 days and used only to fix bugs. Review texts and reviewer data are never included.

### FAQ

**How many reviews can I get per place?**
Set `maxReviews` to 0 to export all reviews Google lists with Newest or Most relevant sort. Large places (tens of thousands of reviews) take longer; for monitoring, use a start date.

**Can I get reviews in a specific language?**
Original text is always kept. Set `language` (for example `de`) to receive Google's translation into that language in `textTranslated` for reviews written in other languages.

**Why did a place return fewer reviews than its review count?**
Google's review count includes rating-only and hidden reviews, and rating sorts show a limited number of reviews per star level. Filters also reduce the number saved. The log shows how many reviews were read and saved per place.

**My search query found the wrong branch. What should I do?**
Add the street or neighborhood, or paste the exact Google Maps place URL instead.

**The run says "not found" for my input.**
Check that the URL opens a single place on Google Maps (not a search list) and that the place ID is complete. For search queries, use the exact business name and city.

### Related scrapers

- [Google Search Results Scraper](https://apify.com/automation-lab/google-search-scraper) — organic results, ads and local packs from Google Search.
- [Bing Maps Places Scraper](https://apify.com/automation-lab/bing-maps-places-scraper) — business listings from Bing Maps.
- [Booking.com Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper) — hotel guest reviews from Booking.com.
- [Airbnb Reviews Scraper](https://apify.com/automation-lab/airbnb-reviews) — guest reviews for Airbnb listings.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — product reviews from Amazon.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/google-maps-place-reviews-scraper/changelog.md

# Actor input Schema

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

Google Maps place URLs. Supported forms: full place URLs (google.com/maps/place/...), short share links (maps.app.goo.gl/...), URLs with ?cid=, and URLs with place_id:. Each URL is one place. Search-result URLs with many places are not expanded; use Search queries instead.

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

Google place IDs such as ChIJPTacEpBQwokRKwIlDXelxkA (the ID used by the Google Places API). Feature IDs in the 0x...:0x... form are accepted too.

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

Business name plus location, for example "Katz's Delicatessen New York". Each query is resolved to the single best-matching Google Maps place, and that place's reviews are exported. For chains, Google's top-ranked branch is used; add the street or use the place URL to target a specific branch.

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

Maximum number of reviews saved for each place, after filters. Set 0 to export all reviews Google lists for the place. You pay per saved review.

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

Order in which Google returns reviews. "Newest" is best for monitoring and is required for the start-date filter to stop early.

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

Keep only reviews published on or after this date. Use YYYY-MM-DD (for example 2026-01-01) or a relative window such as "30 days", "2 weeks", "6 months", "1 year". With Newest sort, the scraper stops paging exactly at the first older review. With other sorts, older reviews are skipped and the filter read limit applies (300 reviews per place, then at least one match per 15 read), so older matches deep in the list can be missed; use Newest sort for complete date windows. Google's exact timestamp is used; for edited reviews this is the time of the last edit.

## `reviewsFilterString` (type: `string`):

Keep only reviews whose text contains this phrase (case-insensitive substring match on the original text and on Google's translation). Matching happens after download: per place the scraper reads 300 reviews, then keeps reading only while it finds at least one match per 15 reviews read. Very rare phrases may therefore stop early.

## `starRatings` (type: `array`):

Keep only reviews with these star ratings. Leave empty for all ratings. Tip: combine with "Lowest rating" sort for 1-2 star reviews or "Highest rating" for 4-5 star reviews; the scraper then stops as soon as Google's sorted list moves past your ratings. With other sorts, filtering uses the same read limit as the keyword filter.

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

Language code for Google's interface and translations, for example en, de, fr, es, pt-BR. Original review text is always kept in `text`; when a review is in another language, Google's translation into this language is added in `textTranslated`.

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

Include reviewer name, profile ID, profile URL and photo. Turn off to export reviews without personal data (GDPR-friendly). Reviewer review/photo counts and Local Guide status are kept.

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

Apify Proxy is used by default (datacenter). The default works for nearly all runs. Residential and Google SERP proxy groups are not supported and stop the run at once with a clear error; you can use your own proxy URLs instead.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Statue+of+Liberty/data=!4m5!3m4!1s0x89c25090129c363d:0x40c6a5770d25022b!8m2!3d40.6892494!4d-74.0445004"
    }
  ],
  "maxReviews": 20,
  "reviewsSort": "newest",
  "language": "en",
  "personalData": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All saved reviews with text, stars, dates, reviewer, owner response and photos.

## `reviewers` (type: `string`):

Reviewer-focused view: reviewer name, profile, review/photo counts and Local Guide status per review.

## `places` (type: `string`):

Place context per review: name, address, category, rating, review count, IDs and contacts.

# 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/Statue+of+Liberty/data=!4m5!3m4!1s0x89c25090129c363d:0x40c6a5770d25022b!8m2!3d40.6892494!4d-74.0445004"
        }
    ],
    "maxReviews": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-maps-place-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/Statue+of+Liberty/data=!4m5!3m4!1s0x89c25090129c363d:0x40c6a5770d25022b!8m2!3d40.6892494!4d-74.0445004" }],
    "maxReviews": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-maps-place-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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/Statue+of+Liberty/data=!4m5!3m4!1s0x89c25090129c363d:0x40c6a5770d25022b!8m2!3d40.6892494!4d-74.0445004"
    }
  ],
  "maxReviews": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation-lab/google-maps-place-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/google-maps-place-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oFlqHHL97n3Kw5Aef/builds/fmKoZ4zoofvEhrb3L/openapi.json