# Google Maps Reviews Scraper — Ratings, Text & Dates (`rp_openpro.ai/google-maps-reviews-scraper`) Actor

Extract Google Maps reviews in bulk by Place ID, CID, or URL: star rating, full review text, date, reviewer name, owner response, and photo count. Perfect for reputation monitoring, AI sentiment analysis, and competitor research. Pairs with our Google Maps Scraper — pipe placeIds straight in.

- **URL**: https://apify.com/rp\_openpro.ai/google-maps-reviews-scraper.md
- **Developed by:** [Rémi Pelloux](https://apify.com/rp_openpro.ai) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 results

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 — Ratings, Full Text, Dates & Owner Responses

**Extract customer reviews from any Google Maps place in bulk.** Feed it Place IDs, CIDs, or Maps URLs and get back every review as a clean row: **star rating, full review text, publication date, reviewer name, owner response, and photo count** — ready for CSV, Excel, sentiment analysis, or your reputation dashboard.

Works perfectly with our [Google Maps Scraper](https://console.apify.com/actors/cOE9BjYdgw74bcWyZ): scrape the places first (every row includes a `placeId`), then pipe those IDs straight into this Actor for the reviews.

---

### What you get per review

```json
{
    "place": "ChIJLU7jZClu5kcR4PcOOO6p3I0",
    "placeName": "Eiffel Tower",
    "reviewId": "Ci9DQUlRQUNvZENodHljRjl...",
    "reviewerName": "Jane Doe",
    "rating": 5,
    "publishedAt": "2 weeks ago",
    "text": "Going all the way up to the top of the tower was worth it. Such an amazing work of art and engineering.",
    "ownerResponse": null,
    "photoCount": 2,
    "scrapedAt": "2026-07-22T10:00:00.000Z"
}
````

***

### Use cases

- **Reputation monitoring** — schedule weekly runs on your (or your clients') locations; alert on new negative reviews.
- **AI sentiment analysis** — feed thousands of reviews into your LLM pipeline; the text is full-length, not truncated.
- **Competitor intelligence** — what do customers praise and complain about at competing businesses?
- **Lead prioritization** — businesses drowning in bad reviews are warm leads for reputation-management agencies.
- **Market research** — aggregate review language across a whole city or category.

***

### How to use

1. Paste Place IDs (from our Google Maps Scraper, the Google API, or any Maps URL) — one per line.
2. Set **Max reviews per place** and language.
3. Run and export JSON / CSV / Excel.

#### Input example

```json
{
    "placeIds": ["ChIJd8BlQ2BZwokRAFUEcm_qrcA", "ChIJLU7jZClu5kcR4PcOOO6p3I0"],
    "maxReviewsPerPlace": 100,
    "language": "en"
}
```

#### API (Node.js)

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('rp_openpro.ai/google-maps-reviews-scraper').call({
    placeIds: ['ChIJd8BlQ2BZwokRAFUEcm_qrcA'],
    maxReviewsPerPlace: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

***

### Pricing

You pay per **review delivered to your dataset**, plus a tiny one-time Actor Start fee. Reviews are deduplicated per run — the number of dataset rows always equals the number of charged events. Your "Max cost per run" setting is a hard ceiling.

🆓 Free trial: **30 reviews per run**.

***

### FAQ

#### Where do I get Place IDs?

Run our [Google Maps Scraper](https://console.apify.com/actors/cOE9BjYdgw74bcWyZ) — every business row includes `placeId` and `cid`. You can also pass full Google Maps URLs directly.

#### How many reviews can I get per place?

As many as Google Maps exposes through scrolling — typically all of them. Use `maxReviewsPerPlace` to control cost.

#### Are review dates exact?

Google Maps displays relative dates ("2 weeks ago"); we return them as shown, plus the scrape timestamp so you can anchor them.

#### Can I schedule recurring runs?

Yes — use Apify's scheduler for daily or weekly reputation monitoring.

***

*Built by [Leadsit.eu](https://leadsit.eu) — lead generation tools for modern sales teams.*

*SEO: google maps reviews scraper, extract google reviews to csv, google review sentiment analysis data, scrape google maps reviews by place id, reputation monitoring google reviews, bulk google reviews export, google my business reviews scraper, review scraper apify*

# Actor input Schema

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

One place per line. Accepts Google Place IDs (ChIJ…), CIDs (numeric), or full Google Maps place URLs. Tip: our Google Maps Scraper outputs a `placeId` for every business — pipe them straight in.

## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews to extract per place. Lower = faster + cheaper.

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

Display language for reviews (Google's hl parameter).

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

RESIDENTIAL Apify Proxy is strongly recommended — Google serves a degraded layout without reviews to datacenter IPs.

## Actor input object example

```json
{
  "placeIds": [
    "ChIJd8BlQ2BZwokRAFUEcm_qrcA",
    "https://www.google.com/maps/place/?q=place_id:ChIJd8BlQ2BZwokRAFUEcm_qrcA"
  ],
  "maxReviewsPerPlace": 50,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `reviews` (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 = {
    "placeIds": [
        "ChIJLU7jZClu5kcR4PcOOO6p3I0"
    ],
    "maxReviewsPerPlace": 50,
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rp_openpro.ai/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 = {
    "placeIds": ["ChIJLU7jZClu5kcR4PcOOO6p3I0"],
    "maxReviewsPerPlace": 50,
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rp_openpro.ai/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 '{
  "placeIds": [
    "ChIJLU7jZClu5kcR4PcOOO6p3I0"
  ],
  "maxReviewsPerPlace": 50,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call rp_openpro.ai/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper — Ratings, Text & Dates",
        "description": "Extract Google Maps reviews in bulk by Place ID, CID, or URL: star rating, full review text, date, reviewer name, owner response, and photo count. Perfect for reputation monitoring, AI sentiment analysis, and competitor research. Pairs with our Google Maps Scraper — pipe placeIds straight in.",
        "version": "1.0",
        "x-build-id": "HRfXwaoGG6ck32RDS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rp_openpro.ai~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rp_openpro.ai-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/rp_openpro.ai~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rp_openpro.ai-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/rp_openpro.ai~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rp_openpro.ai-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",
                "required": [
                    "placeIds"
                ],
                "properties": {
                    "placeIds": {
                        "title": "Places (Place ID, CID, or URL)",
                        "type": "array",
                        "description": "One place per line. Accepts Google Place IDs (ChIJ…), CIDs (numeric), or full Google Maps place URLs. Tip: our Google Maps Scraper outputs a `placeId` for every business — pipe them straight in.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per place",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per place. Lower = faster + cheaper.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "fr",
                            "de",
                            "es",
                            "it",
                            "pt-BR",
                            "nl",
                            "pl",
                            "ja",
                            "ko",
                            "zh-CN",
                            "ar",
                            "tr",
                            "sv",
                            "da",
                            "cs",
                            "uk"
                        ],
                        "type": "string",
                        "description": "Display language for reviews (Google's hl parameter).",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "RESIDENTIAL Apify Proxy is strongly recommended — Google serves a degraded layout without reviews to datacenter IPs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
