# Google Maps Scraper - Fast (`keenly_oligarchy/google-maps-scraper-fast`) Actor

- **URL**: https://apify.com/keenly\_oligarchy/google-maps-scraper-fast.md
- **Developed by:** [Compass](https://apify.com/keenly_oligarchy) (community)
- **Categories:** Travel
- **Stats:** 1 total users, 1 monthly users, 81.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 review scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Finder

Extract public Google Maps reviews and place-level rating statistics from one or
more direct place URLs. Get review text, star ratings, exact dates, reviewer
profiles, review photos, owner responses, place identifiers, and the complete
one-to-five-star distribution in structured data.

The Actor uses lightweight HTTPS requests and writes one dataset item per place,
with its reviews nested in the `reviews` array. Results are ready to use through
the Apify API or download from the dataset in JSON, CSV, Excel, XML, and other
supported formats.

For very large places, Apify's 9 MB maximum size for one dataset item would make
one nested place record impossible to save. In that case, the Actor switches
automatically to one dataset item per review. This is lossless: every review is
returned with its place details, and no reviews are dropped because of the item
size limit.

### Why use this Actor?

- **Review-level pricing:** pay $0.25 per 1,000 delivered reviews.
- **Exact review dates:** receive ISO timestamps instead of only relative labels
  such as "2 months ago."
- **Flexible sorting:** collect the newest, most relevant, highest-rated, or
  lowest-rated reviews.
- **Place statistics:** retrieve the overall rating, total review count, and
  one-to-five-star distribution—even without downloading individual reviews.
- **Rich public review data:** include reviewer profiles, review photos, and
  business-owner responses when available.
- **Multiple places per run:** process a list of direct Google Maps place URLs
  with one Actor run.
- **Automation ready:** integrate through the Apify API, schedules, webhooks,
  Make, Zapier, or your preferred data pipeline.

### Common use cases

- Monitor customer feedback and reputation
- Find recent negative reviews that need attention
- Compare ratings and review trends across business locations
- Analyze competitors and local markets
- Build review dashboards and reporting workflows
- Export public review data for research or sentiment analysis

### Quick start

Provide at least one direct Google Maps place URL:

```json
{
  "startUrls": [
    {
      "url": "https://maps.google.com/?cid=9386448008816829753"
    }
  ],
  "maxReviews": 100,
    "reviewsSort": "newest",
    "language": "en",
    "scrapeReviewsPersonalData": true,
    "streamReviews": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

Click **Start** and open the run's **Dataset** tab when it finishes.

### Input options

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | required | Direct Google Maps place URLs, CID URLs, or `maps.app.goo.gl` share links. |
| `maxReviews` | integer | `100` | Maximum reviews returned per place. Use `0` for place statistics only. |
| `reviewsSort` | string | `newest` | Review order: `mostRelevant`, `newest`, `highestRanking`, or `lowestRanking`. |
| `language` | string | `en` | Google Maps interface language, such as `en`, `de`, `es`, or `fr`. Review text is not translated. |
| `maxCrawledPlaces` | integer | `100` | Maximum number of supplied place URLs processed in the run. |
| `scrapeReviewsPersonalData` | boolean | `true` | Include public reviewer names, profile IDs, profile links, and avatar URLs. |
| `streamReviews` | boolean | `true` in the Console form | Show completed reviews in the Dataset while the run is still active. Output uses individual review rows while streaming. |
| `requestDelaySecs` | integer | `1` | Delay between review-page requests. Increase it if requests are rate-limited. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings used to improve reliability during review pagination. |
| `allowedCountries` | array | empty | Optional country allowlist using ISO-2 codes or country names. |

This Actor accepts direct place URLs; it does not discover businesses from a
free-text search query. Add each desired place to `startUrls`.

You can request up to `100000` reviews per place. The Actor returns every review
that Google makes accessible for the selected sort order, subject to your run's
spending limit and Google's availability of the data.

#### Sort orders

- `newest` — newest reviews first
- `mostRelevant` — Google's relevance ranking
- `highestRanking` — highest ratings first
- `lowestRanking` — lowest ratings first

Use `newest` when collecting reviews incrementally. Ranked Google views can
return fewer accessible reviews for very large places.

#### Watch reviews appear during a run

Keep **Show reviews while scraping** enabled to see each completed review page
appear in the Dataset while the Actor is running. The run status message updates
with the number of reviews saved so far. The log also reports every page with
the newly extracted review count and the running total. Streaming uses the
individual-review format shown below, so each visible row is a complete review
with its place context.

For API callers that require one final nested place object, send
`"streamReviews": false`. Large final results still switch automatically to
lossless individual review rows when required by Apify's item-size limit.

#### Retrieve place statistics only

Set `maxReviews` to `0` when you need place details and the rating distribution
without individual reviews:

```json
{
  "startUrls": [
    { "url": "https://maps.app.goo.gl/YOUR_PLACE_LINK" }
  ],
  "maxReviews": 0
}
```

### Output

Each successfully resolved place creates one dataset item:

```json
{
  "title": "Example Business",
  "address": "Main Street 1, Berlin, Germany",
  "categories": ["Restaurant"],
  "categoryName": "Restaurant",
  "location": {
    "lat": 52.52,
    "lng": 13.405
  },
  "totalScore": 4.2,
  "reviewsCount": 153,
  "reviewsDistribution": {
    "oneStar": 8,
    "twoStar": 4,
    "threeStar": 9,
    "fourStar": 31,
    "fiveStar": 101
  },
  "placeId": "ChIJ...",
  "cid": "1234567890",
  "fid": "0x...:0x...",
  "url": "https://www.google.com/maps/place/?q=place_id:ChIJ...",
  "reviews": [
    {
      "reviewId": "ChZDSUhN...",
      "name": "Jane Doe",
      "reviewerId": "123...",
      "reviewerUrl": "https://www.google.com/maps/contrib/123...",
      "profilePhotoUrl": "https://lh3.googleusercontent.com/...",
      "reviewUrl": "https://www.google.com/maps/reviews/...",
      "stars": 5,
      "text": "Great service and a friendly team.",
      "language": "en",
      "publishedAtDate": "2026-08-01T12:00:00Z",
      "publishedAt": "a week ago",
      "likesCount": 0,
      "responseFromOwnerText": "Thank you for your feedback!",
      "reviewImageUrls": []
    }
  ]
}
```

#### Large-result format

When the nested place item would exceed Apify's 9 MB item limit, the Actor
automatically writes individual review items instead. Each review keeps its
place context, so the result remains easy to group by `placeId`:

```json
{
  "placeId": "ChIJ...",
  "title": "Example Business",
  "address": "Main Street 1, Berlin, Germany",
  "placeUrl": "https://www.google.com/maps/place/?q=place_id:ChIJ...",
  "reviewId": "ChZDSUhN...",
  "stars": 5,
  "text": "Great service and a friendly team.",
  "publishedAtDate": "2026-08-01T12:00:00Z",
  "reviewUrl": "https://www.google.com/maps/reviews/..."
}
```

Use the **Reviews** dataset view to browse this format in Apify Console. API
clients can identify it by the top-level `reviewId` field; the normal nested
place format has a top-level `reviews` array instead.

#### Place fields

The output includes the place name, address, categories, coordinates, overall
rating, total Google review count, star distribution, Google Place ID, CID,
feature ID, canonical Google Maps URL, and collected reviews.

#### Review fields

Available review information includes the review ID, rating, text, detected
language, exact publication timestamp, relative publication label, direct review
URL, reviewer details, public profile photo, review photos, and owner-response
text. Some fields can be `null` or empty when Google does not provide them.

### Pricing

The primary pricing event is **Review scraped**:

| Event | Price | When it is charged |
| --- | ---: | --- |
| Review scraped | **$0.00025 per review** | For every review successfully delivered in the output. |
| Place scraped | **$0.001 per place** | For every resolved place with details and aggregate statistics. |
| Actor start | **$0.00005 per start** | Apify's standard Actor-start event. |

Therefore:

- 100 delivered reviews cost $0.025 in review events.
- 1,000 delivered reviews cost **$0.25 in review events**.
- Place and Actor-start charges are added separately.

The run will not charge for more reviews than it actually delivers. Apify may
also show platform-usage costs separately if usage pass-through is enabled for
the Actor.

### Use the Actor through the API

You can run the Actor from any application using your Apify API token. Replace
`YOUR_USERNAME` with the Actor owner's Apify username.

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("YOUR_USERNAME/google-maps-reviews-finder").call(
    run_input={
        "startUrls": [
            {"url": "https://maps.google.com/?cid=9386448008816829753"}
        ],
        "maxReviews": 100,
        "reviewsSort": "newest",
        "language": "en",
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Install the client with:

```bash
pip install apify-client
```

#### JavaScript

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

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const run = await client.actor('YOUR_USERNAME/google-maps-reviews-finder').call({
    startUrls: [
        { url: 'https://maps.google.com/?cid=9386448008816829753' },
    ],
    maxReviews: 100,
    reviewsSort: 'newest',
    language: 'en',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with:

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

### Reliability and limitations

- Google Maps can change its public interfaces, so the amount and availability
  of data may change over time.
- Review text remains in the language written by the reviewer; the `language`
  input does not translate it.
- Deleted, private, or otherwise unavailable reviews cannot be returned.
- Reviewer information is limited to data publicly displayed by Google Maps.
- Some Google sorting modes may expose fewer reviews than the place's displayed
  total review count.
- Unresolvable URLs do not create a dataset item. Other valid URLs in the same
  run continue processing.
- The Actor returns public review photos but does not currently collect general
  storefront or place-gallery photos.

For larger runs, keep Apify Proxy enabled and consider increasing
`requestDelaySecs` if Google begins rate-limiting requests.

### Responsible use

This Actor collects information publicly available on Google Maps. You are
responsible for using the data in accordance with applicable laws, privacy and
data-protection requirements, and the terms that apply to your use case. Avoid
using personal data for spam, harassment, discrimination, or unlawful profiling.

### Support

If a place cannot be resolved or the returned review count looks incorrect,
open an issue from the Actor's **Issues** tab. Include the run ID, input URL,
expected result, and relevant log messages. Do not include your Apify API token
or other credentials.

When reporting an issue, sharing the run ID is normally enough for diagnosis.

# Actor input Schema

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

Full Google Maps place URLs, maps.app.goo.gl share links, CID URLs, or URLs containing a Google Place ID.

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

Maximum reviews returned for each place. Use 0 to fetch only place details and the star distribution.

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

Order in which Google Maps reviews are collected.

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

Language code used for Google Maps interface text and relative dates, for example en or de. Review text remains in its original language.

## `maxCrawledPlaces` (type: `integer`):

Process at most this many entries from startUrls.

## `scrapeReviewsPersonalData` (type: `boolean`):

Include public reviewer name, profile ID, profile URL, and avatar URL.

## `streamReviews` (type: `boolean`):

Write completed review pages to the Dataset during the run. This makes live progress visible and uses one Dataset item per review.

## `requestDelaySecs` (type: `integer`):

Politeness delay between review pages. Increase this if Google rate-limits the run.

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

Apify Proxy is recommended for reliable review pagination and avoiding long Google rate-limit backoffs.

## `proxyUrls` (type: `array`):

Legacy advanced option for direct HTTP/SOCKS proxy URLs. Prefer proxyConfiguration in the Actor UI.

## `allowedCountries` (type: `array`):

Optional ISO-2 codes or country names. Places outside this list return no result.

## `maxImages` (type: `integer`):

Accepted for drop-in input compatibility. Review photos remain included in reviewImageUrls.

## `scrapeContacts` (type: `boolean`):

Accepted for drop-in input compatibility. Contact enrichment is not performed.

## `onlyDataFromSearchPage` (type: `boolean`):

Accepted for drop-in input compatibility.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://maps.google.com/?cid=9386448008816829753"
    }
  ],
  "maxReviews": 100,
  "reviewsSort": "newest",
  "language": "en",
  "maxCrawledPlaces": 100,
  "scrapeReviewsPersonalData": true,
  "streamReviews": true,
  "requestDelaySecs": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "proxyUrls": [],
  "allowedCountries": [],
  "maxImages": 0,
  "scrapeContacts": false,
  "onlyDataFromSearchPage": false
}
```

# Actor output Schema

## `results` (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://maps.google.com/?cid=9386448008816829753"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("keenly_oligarchy/google-maps-scraper-fast").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://maps.google.com/?cid=9386448008816829753" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("keenly_oligarchy/google-maps-scraper-fast").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://maps.google.com/?cid=9386448008816829753"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call keenly_oligarchy/google-maps-scraper-fast --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5rH44rgAs2di5uZox/builds/KszwgHYQEuVIJvEgK/openapi.json