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

Extract up to 500 Google reviews per business. Filter by rating, language, or text. Pay only for reviews that match your filters.

- **URL**: https://apify.com/iblead/google-maps-reviews-scraper.md
- **Developed by:** [Ibrahim Demol](https://apify.com/iblead) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.30 / 1,000 scraped reviews

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 Maps Reviews Scraper -- Full Review Data

Extract Google Maps reviews for any business by place ID or Google Maps URL. Get up to 500 reviews per business with the full review text, star rating, reviewer name, and date. Results are returned instantly.

This is a lookup actor. Provide place IDs or Google Maps URLs for the businesses whose reviews you want, and get structured review data back.

### What data do you get?

**Per business:**

| Field | Description |
|-------|-------------|
| `name` | Business name |
| `place_id` | Google Place ID |
| `google_maps_url` | Direct Google Maps link |
| `rating` | Overall Google rating (1.0 - 5.0) |
| `review_count` | Total number of Google reviews |
| `reviews` | Array of individual reviews (up to 500) |

**Per review (inside the `reviews` array):**

| Field | Description |
|-------|-------------|
| `name` | Reviewer's display name |
| `rating` | Star rating given by this reviewer (1-5) |
| `text` | Full review text |
| `time_ago` | Relative time of the review (e.g. "3 months ago") |
| `lang` | Language of the review |
| `profile_id` | Reviewer's Google profile ID |
| `visit_date` | Date the reviewer visited the business (if provided) |
| `reviewer_reviews` | Total number of reviews by this reviewer |

### Use cases

- **Sentiment analysis**: Collect reviews for a set of businesses and run NLP or LLM analysis to identify common complaints, praise patterns, or feature requests at scale.
- **Reputation monitoring**: Track reviews for your own business or your clients' businesses. Compare review volumes and sentiment over time.
- **Competitor benchmarking**: Pull reviews for all competitors in a category and location. Compare what customers praise and complain about across the market.
- **Customer research**: Read what real customers say about businesses in a specific niche before entering a new market or launching a competing product.
- **Content generation**: Use review insights to create data-driven blog posts, industry reports, or marketing materials backed by real customer feedback.
- **Quality scoring**: Build custom quality scores for businesses based on review text analysis, beyond the simple 1-5 star average.
- **Location intelligence**: Analyze review themes by geography to understand regional customer preferences and service expectations.

### How to use

1. Get a free API key at [app.iblead.com](https://app.iblead.com) (200 free credits, no credit card).
2. Open this actor in Apify Console.
3. In the **Place IDs or Google Maps URLs** field, paste your list of businesses. Accepted formats:
   - Google Maps Feature IDs: `0x89c2598f7ff4aa09:0x313547e757cb8cea`
   - Full Google Maps URLs: `https://www.google.com/maps/place/...`
4. Enter your API key and run.

Each business returns its overall rating, review count, and an array of individual reviews with full text.

### Input parameters

| Parameter | Required | Type | Description |
|-----------|----------|------|-------------|
| `place_ids` | Yes | Array | List of Google Maps place IDs or full Google Maps URLs. |
| `min_stars` | No | Integer | Only return reviews with this rating or higher (1-5). |
| `max_stars` | No | Integer | Only return reviews with this rating or lower (1-5). Set to 1 to get only negative reviews. |
| `only_with_text` | No | Boolean | Skip reviews that have no written text (rating-only reviews). Default: false. |
| `language` | No | String | Only return reviews in this language (ISO code: 'en', 'fr', 'de', etc.). |
| `sort_by` | No | String | Sort reviews: "newest" (default), "highest_rating", or "lowest_rating". |
| `api_key` | Yes | String | Your IBLead API key. |

### Pricing

This actor charges **$0.30 per 1,000 reviews**.

| Actor | Price per 1K reviews | Max reviews/business | Speed |
|-------|---------------------|---------------------|-------|
| **IBLead Reviews (this actor)** | **$0.30** | 500 | Instant |
| Compass Reviews Scraper | ~$0.60 | Varies | Live scraping (slow) |

The price is per review, not per business. A business with 200 reviews counts as 200 units. A business with 5 reviews counts as 5 units.

### FAQ

**How many reviews can I get per business?**
Up to 500 reviews per business. This covers the vast majority of businesses -- only a small fraction of Google Maps listings have more than 500 reviews.

**Are reviews available for all 50M+ businesses?**
Reviews are stored for businesses that have them. Some businesses have zero reviews on Google Maps. For those, the `reviews` array will be empty and the `review_count` will be 0.

**Can I filter reviews by date or rating?**
Yes. You can filter by star rating (min_stars, max_stars), by language, and by text presence (only_with_text). You can also sort by newest, highest rating, or lowest rating. You are only charged for reviews that match your filters.

**What languages are the reviews in?**
Reviews are in whatever language the reviewer wrote them in. The `lang` field tells you the detected language for each review. There is no translation -- you get the original text.

**How fresh are the reviews?**
Reviews are collected as part of the regular data refresh cycle. Very recent reviews (posted in the last few days) may not be included yet.

**How does pricing work exactly?**
You are charged per review returned, not per business. If you look up 10 businesses and they have a total of 2,000 reviews, you are charged for 2,000 review units. Businesses with zero reviews cost nothing. This makes the pricing fair -- you only pay for the data you actually receive.

**Can I combine this with other IBLead actors?**
Yes. A typical workflow: (1) use the flagship actor to search businesses by category and city, (2) pick the businesses you want to analyze based on rating or review count, (3) feed those place IDs into this Reviews actor to get the full review text. This way you search cheaply at $3.50/1K and only pull detailed reviews for businesses that matter.

**What is the output format?**
Each business is one row in your Apify dataset. The `reviews` field is a JSON array containing individual review objects. You can export the dataset as JSON, CSV, or Excel from the Apify Console. In CSV format, the reviews array is serialized as a JSON string in a single cell.

### About IBLead

IBLead covers 50M+ businesses across 38 countries and 4,037 Google Maps categories. Review data is collected alongside business information during regular refresh cycles. Sign up at [app.iblead.com](https://app.iblead.com) for 200 free credits.

# Actor input Schema

## `place_ids` (type: `array`):

List of Google Maps Feature IDs (e.g. 0x89c2598f7ff4aa09:0x313547e757cb8cea) or full Google Maps URLs.
## `min_stars` (type: `integer`):

Only return reviews with this rating or higher (1-5).
## `max_stars` (type: `integer`):

Only return reviews with this rating or lower (1-5). Set to 1 to get only negative reviews.
## `only_with_text` (type: `boolean`):

Skip reviews that have no written text (rating-only reviews).
## `language` (type: `string`):

Only return reviews in this language (ISO code: 'en', 'fr', 'de', 'es', 'it', etc.).
## `sort_by` (type: `string`):

How to sort the reviews.
## `api_key` (type: `string`):

Your IBLead API key. Sign up free at https://app.iblead.com to get one (200 free credits).

## Actor input object example

```json
{
  "place_ids": [
    "0x89c2598f7ff4aa09:0x313547e757cb8cea"
  ],
  "only_with_text": false,
  "sort_by": "newest"
}
````

# 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 = {
    "place_ids": [
        "0x89c2598f7ff4aa09:0x313547e757cb8cea"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("iblead/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 = { "place_ids": ["0x89c2598f7ff4aa09:0x313547e757cb8cea"] }

# Run the Actor and wait for it to finish
run = client.actor("iblead/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 '{
  "place_ids": [
    "0x89c2598f7ff4aa09:0x313547e757cb8cea"
  ]
}' |
apify call iblead/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper",
        "description": "Extract up to 500 Google reviews per business. Filter by rating, language, or text. Pay only for reviews that match your filters.",
        "version": "0.1",
        "x-build-id": "UwRaC3v24AbyaHwqv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/iblead~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-iblead-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/iblead~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-iblead-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/iblead~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-iblead-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": [
                    "place_ids",
                    "api_key"
                ],
                "properties": {
                    "place_ids": {
                        "title": "Place IDs or Google Maps URLs",
                        "type": "array",
                        "description": "List of Google Maps Feature IDs (e.g. 0x89c2598f7ff4aa09:0x313547e757cb8cea) or full Google Maps URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "min_stars": {
                        "title": "Minimum stars",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with this rating or higher (1-5)."
                    },
                    "max_stars": {
                        "title": "Maximum stars",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with this rating or lower (1-5). Set to 1 to get only negative reviews."
                    },
                    "only_with_text": {
                        "title": "Only reviews with text",
                        "type": "boolean",
                        "description": "Skip reviews that have no written text (rating-only reviews).",
                        "default": false
                    },
                    "language": {
                        "title": "Review language",
                        "type": "string",
                        "description": "Only return reviews in this language (ISO code: 'en', 'fr', 'de', 'es', 'it', etc.)."
                    },
                    "sort_by": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "highest_rating",
                            "lowest_rating"
                        ],
                        "type": "string",
                        "description": "How to sort the reviews.",
                        "default": "newest"
                    },
                    "api_key": {
                        "title": "IBLead API Key",
                        "type": "string",
                        "description": "Your IBLead API key. Sign up free at https://app.iblead.com to get one (200 free credits)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
