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

Extract public reviews from Google Maps place URLs with structured reviewer, rating, text, and place metadata.

- **URL**: https://apify.com/fetch\_cat/google-maps-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Maps reviews from public place URLs and save clean review records to an Apify dataset.

The actor is built for Google Maps place review monitoring, local SEO research, reputation analysis, and customer-feedback collection. It accepts Google Maps place URLs, resolves the place, requests review pages, and outputs one dataset item per review.

### Value proposition

Turn public Google Maps place reviews into structured datasets without manually opening each listing. Use it to monitor reputation, compare locations, audit customer feedback, and feed review data into BI, SEO, or support workflows.

### Who is it for

This Google Maps Reviews Scraper is useful for local SEO teams, agencies, franchise operators, reputation managers, market researchers, and product teams that need structured public review data for places they monitor.

### What data can you get

- Scrapes Google Maps reviews for one or more places.
- Supports result limits across the whole run and per place.
- Supports review sort order: most relevant, newest, highest rating, or lowest rating.
- Saves reviewer name, rating, review text, language, published time, reviewer profile URL, and place metadata.
- Uses retries and proxy configuration for more stable Google Maps sessions.
- Charges per saved review so small runs stay inexpensive.

### Input

Provide one or more Google Maps place URLs in `startUrls`.

Recommended URL format is a full Google Maps place URL that contains the `0x...:0x...` place data identifier, for example:

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163!8m2!3d40.7484405!4d-73.9856644!9m1!1b1"
    }
  ],
  "maxItems": 50,
  "reviewsPerPlace": 50,
  "sort": "mostRelevant"
}
```

#### Input fields

- `startUrls` — Google Maps place URLs to process.
- `maxItems` — maximum number of review records saved across all places.
- `reviewsPerPlace` — maximum number of reviews saved for each input place.
- `sort` — review sort order: `mostRelevant`, `newest`, `highestRating`, or `lowestRating`.
- `language` — Google UI language code used for requests. Default is `en`.
- `country` — Google region code used for requests. Default is `US`.
- `pageSize` — page size for fallback review requests.
- `requestDelayMillis` — delay between review page requests.
- `maxRequestRetries` — bounded retries for stale sessions or placeholder responses.
- `proxyConfiguration` — Apify Proxy or custom proxy settings.

### Output

Each dataset item is one Google Maps review.

Important output fields:

- `placeTitle` — place name from the Google Maps URL/session.
- `placeAddress` — place address when available.
- `placeUrl` — canonical Google Maps place URL used by the run.
- `placeDataId` — Google Maps internal place data identifier.
- `placeRating` — overall place rating when available.
- `reviewId` — unique review identifier.
- `reviewerName` — public reviewer display name.
- `reviewerUrl` — reviewer profile or reviews URL.
- `reviewerPhotoUrl` — reviewer avatar URL when available.
- `rating` — review rating from 1 to 5.
- `text` — full review text.
- `publishedAt` — review publish timestamp when available.
- `ownerResponse` — owner response when available.
- `language` — detected/source review language when available.
- `scrapedAt` — timestamp when the actor saved the item.

### Example output

```json
{
  "placeTitle": "Empire State Building",
  "placeAddress": "Empire State Building, 20 W 34th St., New York, NY 10001",
  "placeDataId": "0x89c259a9b3117469:0xd134e199a405a163",
  "reviewerName": "A Google User",
  "rating": 5,
  "text": "Great view and a classic New York experience.",
  "publishedAt": "2026-05-29T01:25:39.874Z",
  "language": "en",
  "scrapedAt": "2026-07-09T15:58:28.897Z"
}
```

### Pricing

This actor uses pay-per-event pricing.

| Event | Store tier | Price |
|---|---|---:|
| Run start | All tiers | $0.005 per run |
| Review extracted | Free | $0.00115 per saved review |
| Review extracted | Bronze | $0.001 per saved review |
| Review extracted | Silver | $0.00078 per saved review |
| Review extracted | Gold | $0.0006 per saved review |
| Review extracted | Platinum | $0.00048 per saved review |
| Review extracted | Diamond | $0.0004 per saved review |

You can control cost with `maxItems` and `reviewsPerPlace`. For example, set `maxItems` to `100` to stop after 100 reviews even if the input places have many more reviews.

### Example inputs

#### Scrape latest reviews for one place

```json
{
  "startUrls": [{ "url": "https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163!8m2!3d40.7484405!4d-73.9856644!9m1!1b1" }],
  "maxItems": 25,
  "reviewsPerPlace": 25,
  "sort": "newest"
}
```

#### Scrape a small sample from multiple places

```json
{
  "startUrls": [
    { "url": "https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163!8m2!3d40.7484405!4d-73.9856644!9m1!1b1" }
  ],
  "maxItems": 10,
  "reviewsPerPlace": 10,
  "sort": "mostRelevant"
}
```

### API usage

You can run the actor from the Apify API or client libraries. Pass the same JSON input you would use in the Apify Console.

#### Apify CLI

```bash
apify call fetch_cat/google-maps-reviews-scraper --input-file input.json
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-maps-reviews-scraper').call({
  startUrls: [{ url: 'https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163' }],
  maxItems: 10
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/google-maps-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163'}],
    'maxItems': 10,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~google-maps-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163"}],"maxItems":10}'
```

After the run finishes, download results from the default dataset.

### MCP

You can use this actor through the Apify MCP server by passing the same JSON input fields. Keep `maxItems` low for interactive assistant workflows and increase it for scheduled monitoring.

#### Remote MCP URL

Use the hosted Apify MCP endpoint with the actual actor slug:

```text
https://mcp.apify.com/?actors=fetch_cat/google-maps-reviews-scraper
```

For Claude-compatible clients, add the remote server with the actor slug:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?actors=fetch_cat/google-maps-reviews-scraper"
```

Configure your MCP client to send your Apify API token as a bearer token. Example configuration for clients that support remote HTTP MCP servers:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=fetch_cat/google-maps-reviews-scraper",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### Example prompts showing MCP usage

Prompt: "Run the Google Maps Reviews Scraper for this place URL and return the five newest negative reviews."

Prompt: "Monitor this Google Maps location and summarize recurring complaints from the latest 20 reviews."

Prompt: "Extract reviews for this place and group them by rating and language."

### Legality

This actor extracts publicly available Google Maps review data. You are responsible for using the results lawfully, respecting applicable privacy rules, Google terms, and any compliance requirements for your jurisdiction or organization.

### Tips for best results

- Use full Google Maps place URLs whenever possible.
- Keep `maxItems` modest for smoke tests.
- Use `newest` when monitoring recent reputation changes.
- Use Apify Proxy for cloud runs if direct requests are unstable from your network.
- If a place URL resolves to a limited or ambiguous view, open the exact place in Google Maps and copy the full URL again.

### Limitations

Google Maps changes its internal responses regularly. Some places, regions, or sessions can return limited data or placeholder responses. The actor uses retries and fallback requests, but a small number of URLs may still need a more specific Google Maps place URL.

### Support

If a run does not return the reviews you expected, include these details when contacting support:

- Apify run ID or run URL.
- The full input JSON used for the run.
- Expected output, such as the place and approximate number of reviews you expected.
- Actual output, including dataset item count and any warning messages.
- One reproducible public URL, preferably the full Google Maps place URL copied from Google Maps.

### FAQ

#### Can I scrape all reviews for a place?

Set a high `reviewsPerPlace` and `maxItems`. Very large places can have many pages, so start with a smaller test first.

#### Why did a run return fewer reviews than expected?

Google may return fewer reviews for a session, place, language, sort order, or region. Check the input URL and try a full place URL with the internal `0x...:0x...` identifier.

#### Does this require my own Google API key?

No. The actor does not require a Google Maps Platform API key.

#### Can I use proxies?

Yes. Use the `proxyConfiguration` input. Apify Proxy is enabled by default in the schema.

### Related actors

- [Google Play Reviews Scraper](https://apify.com/fetch_cat/google-play-reviews-scraper) — collect app reviews from Google Play.
- [Trustpilot Reviews Scraper](https://apify.com/fetch_cat/trustpilot-reviews-scraper) — collect company reviews from Trustpilot.
- [Yandex Maps Reviews Scraper](https://apify.com/fetch_cat/yandex-maps-reviews-scraper) — collect reviews from Yandex Maps places.
- [Apple Maps Places Scraper](https://apify.com/fetch_cat/apple-maps-places-scraper) — collect Apple Maps place data for local research.

### Development

```bash
npm install
npm run build
npm start
```

# Actor input Schema

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

Google Maps place URLs, share URLs, or URLs containing a Google Maps place identifier.

## `maxItems` (type: `integer`):

Maximum number of review records to save across all places.

## `reviewsPerPlace` (type: `integer`):

Maximum number of reviews to save for each input place.

## `sort` (type: `string`):

Review sort order requested from Google Maps.

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

Google UI language code used for review/session requests.

## `country` (type: `string`):

Google country/region code used for review/session requests.

## `pageSize` (type: `integer`):

Reviews requested per internal API/RPC page.

## `requestDelayMillis` (type: `integer`):

Delay between review page requests for the same place.

## `maxRequestRetries` (type: `integer`):

Bounded retries for stale or placeholder Google Maps sessions.

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

Proxy settings. Apify Proxy is enabled by default for Google Maps session consistency.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163!8m2!3d40.7484405!4d-73.9856644!9m1!1b1!16zL20vMDJuX3Fy"
    }
  ],
  "maxItems": 10,
  "reviewsPerPlace": 10,
  "sort": "mostRelevant",
  "language": "en",
  "country": "US",
  "pageSize": 10,
  "requestDelayMillis": 500,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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": [
        {
            "url": "https://www.google.com/maps/place/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163!8m2!3d40.7484405!4d-73.9856644!9m1!1b1!16zL20vMDJuX3Fy"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163!8m2!3d40.7484405!4d-73.9856644!9m1!1b1!16zL20vMDJuX3Fy" }] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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/Empire+State+Building/@40.7484405,-73.9856644,17z/data=!4m8!3m7!1s0x89c259a9b3117469:0xd134e199a405a163!8m2!3d40.7484405!4d-73.9856644!9m1!1b1!16zL20vMDJuX3Fy"
    }
  ]
}' |
apify call fetch_cat/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Oy3VMd7sXQLhyNCNU/builds/8mEDsjUNglpc4thjN/openapi.json