# Google Business Reviews Scraper (`scrapeforge/google-reviews-scraper`) Actor

Scrape reviews from any Google Business Profile on Google Maps. Get review text, star ratings, reviewer info, photos, owner responses, and more. Supports sorting by relevance, newest, highest or lowest rating. Fast, lightweight, no browser needed Perfect for reputation monitoring and market research

- **URL**: https://apify.com/scrapeforge/google-reviews-scraper.md
- **Developed by:** [ScrapeForge](https://apify.com/scrapeforge) (community)
- **Categories:** E-commerce, Social media, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 cost per results

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 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 Business Reviews Scraper

Extract reviews from any Google Business Profile. Fast, reliable extraction at scale.

### Features

- **Fast extraction** — Optimized for speed and efficiency
- **Multiple input modes** — Paste Google Maps URLs, Place IDs, or search by keyword
- **Sort options** — Get reviews by relevance, newest, highest rated, or lowest rated
- **Multi-language** — Fetch reviews in any language
- **Low resource usage** — Minimal memory and bandwidth
- **Automatic pagination** — Fetches all reviews, even for places with thousands
- **Deduplication** — No duplicate reviews in your dataset

### What data do you get?

Each review includes:

| Field | Description |
|-------|-------------|
| `text` | Full review text |
| `rating` | Star rating (1-5) |
| `publishedTime` | When the review was posted |
| `likesCount` | Number of "helpful" votes |
| `language` | Review language |
| `images` | Photos attached to the review |
| `ownerResponse.text` | Business owner's reply |
| `ownerResponse.publishedAt` | When the owner replied |
| `reviewer.name` | Reviewer's display name |
| `reviewer.profileUrl` | Reviewer's Google profile URL |
| `reviewer.avatarUrl` | Reviewer's profile picture |
| `reviewer.totalReviews` | Total reviews by this reviewer |
| `reviewer.isLocalGuide` | Whether the reviewer is a Local Guide |
| `placeName` | Name of the business |

#### Sample output

```json
{
    "reviewId": "ChdDSUhN...",
    "text": "Amazing food and great service! The pasta was incredible.",
    "rating": 5,
    "publishedTime": "2 weeks ago",
    "publishedAt": "2026-03-20T12:00:00.000Z",
    "likesCount": 3,
    "language": "en",
    "images": [],
    "ownerResponse": {
        "text": "Thank you for your kind words!",
        "publishedAt": "3 days ago"
    },
    "reviewer": {
        "name": "John Doe",
        "profileUrl": "https://www.google.com/maps/contrib/...",
        "avatarUrl": "https://lh3.googleusercontent.com/...",
        "totalReviews": 42,
        "isLocalGuide": true
    },
    "placeFeatureId": "0x89aa1fc7a3c44681:0xa30d7f68fdfd53e6",
    "placeName": "Restaurant Example"
}
````

### Input

| Field | Description | Default |
|-------|-------------|---------|
| `placeURLs` | List of Google Maps place URLs | `[]` |
| `searchQueries` | Search for businesses by keyword | `[]` |
| `maxReviewsPerPlace` | Max reviews per place. `0` for all | `0` |
| `sortBy` | Sort: `relevant`, `newest`, `highest`, `lowest` | `relevant` |
| `language` | Language code (en, es, fr, de, etc.) | `en` |
| `proxy` | Proxy configuration (recommended) | Apify Proxy |

#### Example input

```json
{
    "placeURLs": [
        "https://www.google.com/maps/place/..."
    ],
    "maxReviewsPerPlace": 500,
    "sortBy": "newest",
    "language": "en"
}
```

#### Search and scrape

```json
{
    "searchQueries": [
        "best restaurants in New York"
    ],
    "maxReviewsPerPlace": 100,
    "sortBy": "relevant"
}
```

### Use cases

- **Reputation monitoring** — Track reviews of your business or competitors
- **Market research** — Analyze customer sentiment across locations
- **Competitor analysis** — Compare review patterns and ratings
- **Lead generation** — Find businesses with specific review characteristics
- **Academic research** — Collect structured review data for analysis
- **Local SEO** — Monitor review trends and owner response rates

### How it works

This scraper fetches reviews in bulk using an optimized extraction pipeline. This means:

- **No scroll delays** — Reviews are fetched via pagination, not scrolling
- **Minimal bandwidth** — Only structured data is transferred
- **Low memory** — Runs in as little as 256MB

### Export formats

Export your data in JSON, CSV, Excel, XML, or HTML. Integrate via the Apify API, webhooks, or connect directly to Google Sheets, Slack, Zapier, Make, and more.

### Limitations

- Only publicly visible reviews are accessible
- Some reviews may be filtered by Google and not shown
- Google may rate-limit requests — use proxy for best results
- Review photos may have expiring URLs

### Disclaimer

This is an **unofficial** actor and is **not affiliated with, endorsed by, or sponsored by Google**. It is developed and maintained independently. Google, Google Maps, and Google Business Profile are trademarks of Google LLC.

This actor accesses only publicly available data. Users are responsible for ensuring their use complies with Google's Terms of Service and all applicable laws. By using this actor, you agree that you are solely responsible for how you use the extracted data.

# Actor input Schema

## `placeURLs` (type: `array`):

List of Google Maps place URLs to scrape reviews from.

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

Search for businesses by keyword (e.g., 'restaurants in New York'). Reviews from all found places will be scraped.

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

Country name to narrow search queries (e.g., 'United States', 'Spain'). Only applies to searchQueries.

## `state` (type: `string`):

State or region name (e.g., 'California', 'Catalonia'). Only applies to searchQueries.

## `city` (type: `string`):

City name (e.g., 'New York', 'Barcelona'). Only applies to searchQueries.

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

Maximum number of reviews to scrape per place. Set to 0 for all reviews.

## `sortBy` (type: `string`):

Sort order for reviews.

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

Language code for reviews (e.g., en, es, fr, de).

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

Only return reviews published after this date. Supports absolute dates (YYYY-MM-DD, ISO datetime) or relative dates (e.g., '3 months', '1 year', '30 days'). Works best with sortBy set to 'newest'.

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

Only return reviews containing this keyword (case-insensitive). Leave empty for all reviews.

## `reviewsTranslation` (type: `string`):

How to handle review translations. 'onlyOriginal' returns original text only. 'onlyTranslated' returns only the translated text. 'originalAndTranslated' returns both.

## `translateLanguage` (type: `string`):

Target language code for translation (e.g., 'en', 'es', 'fr'). Required when reviewsTranslation is not 'onlyOriginal'.

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

When enabled, reviewer name, profile URL, avatar, and ID are included. Disable for GDPR compliance.

## `proxy` (type: `object`):

Proxy settings. Recommended for avoiding rate limits.

## Actor input object example

```json
{
  "placeURLs": [],
  "searchQueries": [],
  "country": "",
  "state": "",
  "city": "",
  "maxReviewsPerPlace": 0,
  "sortBy": "relevant",
  "language": "en",
  "reviewsStartDate": "",
  "reviewsFilterString": "",
  "reviewsTranslation": "onlyOriginal",
  "translateLanguage": "",
  "scrapeReviewsPersonalData": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all extracted reviews with reviewer data, ratings, and owner responses

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeforge/google-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapeforge/google-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 '{}' |
apify call scrapeforge/google-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Business Reviews Scraper",
        "description": "Scrape reviews from any Google Business Profile on Google Maps. Get review text, star ratings, reviewer info, photos, owner responses, and more. Supports sorting by relevance, newest, highest or lowest rating. Fast, lightweight, no browser needed Perfect for reputation monitoring and market research",
        "version": "1.0",
        "x-build-id": "0KnBw8rx82N35N1cJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeforge~google-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeforge-google-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/scrapeforge~google-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeforge-google-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/scrapeforge~google-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeforge-google-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": {
                    "placeURLs": {
                        "title": "Google Maps Place URLs",
                        "type": "array",
                        "description": "List of Google Maps place URLs to scrape reviews from.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Search for businesses by keyword (e.g., 'restaurants in New York'). Reviews from all found places will be scraped.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country name to narrow search queries (e.g., 'United States', 'Spain'). Only applies to searchQueries.",
                        "default": ""
                    },
                    "state": {
                        "title": "State / Region",
                        "type": "string",
                        "description": "State or region name (e.g., 'California', 'Catalonia'). Only applies to searchQueries.",
                        "default": ""
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name (e.g., 'New York', 'Barcelona'). Only applies to searchQueries.",
                        "default": ""
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per place. Set to 0 for all reviews.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "relevant",
                            "newest",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "Sort order for reviews.",
                        "default": "relevant"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for reviews (e.g., en, es, fr, de).",
                        "default": "en"
                    },
                    "reviewsStartDate": {
                        "title": "Reviews start date",
                        "type": "string",
                        "description": "Only return reviews published after this date. Supports absolute dates (YYYY-MM-DD, ISO datetime) or relative dates (e.g., '3 months', '1 year', '30 days'). Works best with sortBy set to 'newest'.",
                        "default": ""
                    },
                    "reviewsFilterString": {
                        "title": "Filter by keyword",
                        "type": "string",
                        "description": "Only return reviews containing this keyword (case-insensitive). Leave empty for all reviews.",
                        "default": ""
                    },
                    "reviewsTranslation": {
                        "title": "Review translation mode",
                        "enum": [
                            "onlyOriginal",
                            "onlyTranslated",
                            "originalAndTranslated"
                        ],
                        "type": "string",
                        "description": "How to handle review translations. 'onlyOriginal' returns original text only. 'onlyTranslated' returns only the translated text. 'originalAndTranslated' returns both.",
                        "default": "onlyOriginal"
                    },
                    "translateLanguage": {
                        "title": "Translate to language",
                        "type": "string",
                        "description": "Target language code for translation (e.g., 'en', 'es', 'fr'). Required when reviewsTranslation is not 'onlyOriginal'.",
                        "default": ""
                    },
                    "scrapeReviewsPersonalData": {
                        "title": "Include reviewer personal data",
                        "type": "boolean",
                        "description": "When enabled, reviewer name, profile URL, avatar, and ID are included. Disable for GDPR compliance.",
                        "default": true
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for avoiding rate limits.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
