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

Scrape every public Google Maps review for any business as clean JSON — text, star rating, date, reviewer name & photo, review photos and the owner's response, paginated to ALL reviews. Enter a place name or Google place\_id for the full review history + aggregate rating. No proxies, no login, no

- **URL**: https://apify.com/reefapi/google-maps-reviews-scraper.md
- **Developed by:** [ReefAPI](https://apify.com/reefapi) (community)
- **Categories:** E-commerce, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 ALL Reviews for Any Place as JSON

> 📮 **Need help, hit a problem, want a new feature, or a field that's missing from the output?** Email **support@reefapi.com** or open an issue on the **Issues** tab of this Actor — we reply fast and take feature requests seriously.

Scrape **every public Google Maps review** for a business or place as clean, structured JSON. Enter a place name (or its Google `place_id`) and get back the full review list — **review text, star rating, date, reviewer name & photo, review photos, and the owner's response** — paginated to as many reviews as you need. **No proxies, no CAPTCHAs, no login, no cookies to provide** — you just send the place and get the data. Fast (typically 1–4s per page) and ~99% success, everything as flat JSON.

### What is the Google Maps Reviews Scraper?

The Google Maps Reviews Scraper is a **Google reviews data API** built for one job: pulling the complete review history of a place. Where the official Places API returns only a handful of reviews per location, this Actor uses deep cursor pagination to collect the **entire** review list for a business — every star rating, the full review text in its original language, the reviewer's name and photo, attached review images and the business owner's reply. Resolve a place by a text query (`"Joe's Pizza New York"`) or by an exact `place_id`. It's the tool you use to **scrape Google Maps reviews** at scale for reputation monitoring, sentiment analysis and competitor research.

### What you get per review

- ⭐ **Star rating** (1–5) and **review text** (full, original language).
- 👤 **Reviewer** — name, profile photo and profile URL.
- 🗓️ **Date** — absolute timestamp + relative ("3 weeks ago").
- 🖼️ **Review photos** — image CDN URLs attached to the review.
- 💬 **Owner response** — the business's reply text + date (when present).
- 🌐 **Language** of the review, plus a place-level **aggregate** (overall rating + total review count).

### Why this scraper

- **All reviews, not a sample** — deep cursor pagination pulls the entire review history, not just the top few.
- **Zero setup** — no proxy config, no cookies, no Google login and no API key/quota to manage.
- **Clean JSON** — flat, ready for sentiment analysis, reputation monitoring or dashboards.
- **Resolve by name or id** — pass a text query or an exact `place_id` / `fid` / `cid`.

### What data can I extract?

Each review is one record. Key fields (from real output):

| Field | What it is |
|---|---|
| `review_id` | Stable id for the review |
| `author_name` | Reviewer's display name |
| `author_photo` | Reviewer's profile photo URL |
| `author_profile_url` | Link to the reviewer's Google profile |
| `rating` | Star rating (1–5) |
| `text` | Full review text |
| `language` | Detected language code |
| `relative_date` | Human age ("2 months ago") |
| `date` | Absolute ISO timestamp |
| `photos` / `photo_count` | Image URLs attached to the review + count |
| `owner_response` | Business owner's reply (when present) |

The response also includes a `place{}` object (name, rating, review_count, address, Maps ids), an `aggregate{rating, total}`, and `pagination{cursor, has_more}` for paging through more reviews.

> Field availability can vary — not every review has photos or an owner response, and Google can change its layout. Core fields (rating, text, author, date, review_id) are present for real reviews.

### How do I scrape Google reviews?

1. Open the Actor and go to the **Input** tab.
2. Enter the **Place** — a business name with a location hint (`"Louvre Museum Paris"`), or a Google `place_id` for an exact match.
3. Set **Max reviews** (leave empty for as many as available).
4. Click **Start**, then download the reviews as **JSON, CSV or Excel** from the **Dataset** tab.

### Input

```json
{ "query": "Joe's Pizza New York", "max_reviews": 200 }
````

- `query` — business name **with a location hint** (e.g. `"Blue Bottle Coffee Bryant Park New York"`).
- `place_id` — *(optional)* target an exact place by its Google `place_id` / `fid` / `cid`.
- `max_reviews` — how many reviews to return (1–2000; empty for all available).
- `params` — *(optional)* advanced JSON: `sort`, `lang`, `region`, `cursor`, …

### Output

Real response (trimmed — one place, one representative review):

```json
{
  "place": {
    "fid": "0x89c259aa8bb2f78b:0x495cd4c5b93ef616",
    "place_id": "0x89c259aa8bb2f78b:0x495cd4c5b93ef616",
    "cid": "5286334008307676694",
    "name": "Blue Bottle Coffee",
    "rating": 4.4,
    "review_count": 1392,
    "address": "54 W 40th St, New York, NY 10018",
    "maps_url": "https://www.google.com/maps?cid=5286334008307676694"
  },
  "reviews": [
    {
      "review_id": "Ci9DQUlRQUNvZENodHljRjlvT2xkaFVGZEVjVko1TUhCME1ERXRNM0pNUmxKcmRtYxAB",
      "author_name": "Sameer Somal",
      "author_photo": "https://lh3.googleusercontent.com/a-/…",
      "author_profile_url": "https://www.google.com/maps/contrib/112873241671424640773/reviews",
      "rating": 5,
      "text": "There's something reassuring about Blue Bottle — you know what you're getting, and it's always solid…",
      "language": "en",
      "relative_date": "3 weeks ago",
      "date": "2026-06-08T12:13:18Z",
      "photos": null,
      "photo_count": 0,
      "owner_response": null
    }
  ],
  "aggregate": { "rating": 4.4, "total": 1392 },
  "pagination": { "cursor": "OkRDakVJ…", "has_more": true }
}
```

### Use cases

- **Reputation monitoring** — track a business's reviews, rating trend and owner responses over time.
- **Sentiment analysis** — feed review text into NLP/AI for themes, complaints and praise.
- **Competitor research** — compare review volume, ratings and customer sentiment across places.
- **Lead qualification** — score local businesses by rating and review activity.
- **Voice-of-customer datasets** — build multilingual review corpora for product and CX teams.

### FAQ

**Is there an official Google reviews API?**
The official Places API returns only a small, fixed sample of reviews per place — you cannot page through a business's full history. This Actor is built specifically to collect *all* public reviews as structured JSON.

**Why scrape Google Maps reviews?**
Reviews are the richest public signal of customer sentiment. Pulled in full, they power reputation monitoring, sentiment models, competitor benchmarking and voice-of-customer analysis.

**How much does it cost?**
Billed on Apify's pay-as-you-go model, benchmarked to be competitive with other Google reviews scrapers. See the **Pricing** section on this Actor's page for the current rate.

**Can I integrate it?**
Yes — run it from the Apify **API** or the **Python / Node.js clients**, and connect the output to **Make, Zapier, n8n, Google Sheets, Slack, webhooks** or your database via Apify integrations.

**Is it legal to scrape Google reviews?**
This Actor reads publicly visible reviews (no login, no accounts). Reviews contain personal data (reviewer names, photos), so handle the output responsibly and per GDPR/CCPA — for example, anonymize where appropriate. Not legal advice.

***

Unofficial — not affiliated with Google. Public data only.

# Actor input Schema

## `query` (type: `string`):

The business name with a location hint — e.g. 'Joe's Pizza New York' or 'Louvre Museum Paris'. The scraper resolves the place and returns all its reviews. (Or pass a Google place\_id below for an exact match.)

## `place_id` (type: `string`):

Target an exact place by its Google id instead of a text query — the place\_id, fid (0x…:0x…) or numeric cid returned by a places search.

## `max_reviews` (type: `integer`):

How many reviews to return (1–2000). Leave empty for as many as available.

## `params` (type: `object`):

Any extra parameters as key/value JSON (sort, lang, region, cursor for pagination, …). Merged into the request.

## `action` (type: `string`):

Fixed to public place reviews.

## Actor input object example

```json
{
  "query": "Joe's Pizza New York",
  "max_reviews": 100,
  "action": "place/reviews"
}
```

# Actor output Schema

## `reviews` (type: `string`):

The list of public Google Maps reviews scraped for the place (one item per review).

# 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 = {
    "query": "Joe's Pizza New York",
    "max_reviews": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("reefapi/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 = {
    "query": "Joe's Pizza New York",
    "max_reviews": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("reefapi/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 '{
  "query": "Joe'\''s Pizza New York",
  "max_reviews": 100
}' |
apify call reefapi/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper",
        "description": "Scrape every public Google Maps review for any business as clean JSON — text, star rating, date, reviewer name & photo, review photos and the owner's response, paginated to ALL reviews. Enter a place name or Google place_id for the full review history + aggregate rating. No proxies, no login, no",
        "version": "0.1",
        "x-build-id": "Su2BKfLjXWG7olItW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reefapi~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reefapi-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/reefapi~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reefapi-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/reefapi~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reefapi-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": {
                    "query": {
                        "title": "Place (name + location)",
                        "type": "string",
                        "description": "The business name with a location hint — e.g. 'Joe's Pizza New York' or 'Louvre Museum Paris'. The scraper resolves the place and returns all its reviews. (Or pass a Google place_id below for an exact match.)"
                    },
                    "place_id": {
                        "title": "Google place_id / fid / cid (optional)",
                        "type": "string",
                        "description": "Target an exact place by its Google id instead of a text query — the place_id, fid (0x…:0x…) or numeric cid returned by a places search."
                    },
                    "max_reviews": {
                        "title": "Max reviews",
                        "type": "integer",
                        "description": "How many reviews to return (1–2000). Leave empty for as many as available."
                    },
                    "params": {
                        "title": "Advanced parameters",
                        "type": "object",
                        "description": "Any extra parameters as key/value JSON (sort, lang, region, cursor for pagination, …). Merged into the request."
                    },
                    "action": {
                        "title": "Action (fixed)",
                        "type": "string",
                        "description": "Fixed to public place reviews.",
                        "default": "place/reviews"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
