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

Scrape Google Maps reviews by place URL or search query. Extract reviewer names, star ratings, review text, dates, owner responses, and photo counts. Sort by newest, highest/lowest rating, or relevance. Filter by minimum rating. Multi-language support.

- **URL**: https://apify.com/miccho27/google-maps-reviews-scraper.md
- **Developed by:** [Tatsuya Mizuno](https://apify.com/miccho27) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Maps Reviews Scraper - Extract Customer Reviews, Ratings & Owner Responses at Scale

Scrape Google Maps reviews for any business -- reviewer names, star ratings, full review text, dates, photo counts, and owner responses. Search by place name or paste Google Maps URLs directly. Multi-language support, sort options, and rating filters. The best free alternative to ReviewTrackers ($49/mo), Birdeye ($299/mo), and Google Places API ($17/1000 requests).

### Who Is This For?

- **Reputation managers** -- Monitor customer reviews across multiple locations
- **Market researchers** -- Analyze competitor sentiment and service quality
- **Local SEO specialists** -- Track review velocity and rating trends
- **Restaurant/hotel owners** -- Export reviews for internal analysis and response planning
- **Data analysts** -- Build review datasets for NLP, sentiment analysis, and trend research
- **Agencies** -- Generate client review reports automatically

### Features

- Search Google Maps by keyword or paste direct place URLs
- Extract reviewer name, rating (1-5 stars), full review text, date
- Capture owner/business responses to reviews
- Sort reviews by newest, highest rating, lowest rating, or relevance
- Filter by minimum star rating
- Multi-language support (en, ja, es, de, fr, pt, and more)
- Photo count per review
- Playwright-based for reliable JavaScript rendering
- Export as JSON, CSV, or Excel

### Pricing -- Free to Start

| Tier | Cost | What You Get |
|------|------|-------------|
| **Free trial** | $0 | Apify free tier includes monthly compute credits |
| **Pay per review** | ~$0.005-0.02/review | Only pay for actual Apify compute used |
| **vs. ReviewTrackers** | Saves $49/mo | No subscription, pay per use |
| **vs. Birdeye** | Saves $299/mo | No annual contract required |
| **vs. Google Places API** | Saves $17/1K req | No API key, no billing setup |

### Quick Start (3 Steps)

1. **Click "Try for free"** on this Actor's page in Apify Store
2. **Enter a search query** (e.g., "best pizza in New York") or paste Google Maps place URLs
3. **Click "Start"** and get reviews with ratings, text, and dates as JSON, CSV, or Excel

### How It Compares to Paid Review Tools

| Feature | This Actor (FREE) | ReviewTrackers ($49/mo) | Birdeye ($299/mo) | Google Places API ($17/1K) |
|---------|-------------------|------------------------|-------------------|---------------------------|
| Review extraction | Unlimited | Limited plans | Limited plans | 5 reviews max per request |
| Owner responses | Yes | Yes | Yes | Yes |
| Sort/filter options | 4 sort + rating filter | Limited | Yes | No sort |
| Multi-language | Yes (any) | English-focused | Multi-language | Yes |
| Bulk processing | Yes | Yes | Yes | Rate limited |
| API access | Yes (Apify API) | Yes | Yes | Yes |
| Scheduling | Yes (Apify scheduler) | Built-in | Built-in | Manual |
| Monthly cost | $0 (pay per run) | $49+ | $299+ | ~$17/1K calls |

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `searchQuery` | string | No* | - | Google Maps search query (e.g., "ramen in Tokyo") |
| `placeUrls` | string[] | No* | - | Direct Google Maps place URLs |
| `maxReviews` | integer | No | 50 | Max reviews per place (1-500) |
| `language` | string | No | "en" | Language code for results |
| `sortBy` | string | No | "newest" | Sort: newest, highest_rating, lowest_rating, most_relevant |
| `minRating` | integer | No | - | Filter reviews by minimum star rating (1-5) |

*At least one of `searchQuery` or `placeUrls` is required.

#### Example Input -- Search by Query

```json
{
  "searchQuery": "best ramen in Tokyo",
  "maxReviews": 30,
  "language": "en",
  "sortBy": "newest"
}
````

#### Example Input -- Direct Place URLs

```json
{
  "placeUrls": [
    "https://www.google.com/maps/place/Ichiran+Shibuya/@35.6595,...",
    "https://www.google.com/maps/place/Fuunji/@35.6896,..."
  ],
  "maxReviews": 100,
  "sortBy": "highest_rating",
  "language": "ja"
}
```

#### Example Input -- Negative Review Monitoring

```json
{
  "placeUrls": [
    "https://www.google.com/maps/place/Your+Business/@..."
  ],
  "maxReviews": 200,
  "sortBy": "lowest_rating",
  "minRating": 1
}
```

### Output Example

```json
{
  "success": true,
  "placeUrl": "https://www.google.com/maps/place/Ichiran+Shibuya/...",
  "placeName": "Ichiran Shibuya",
  "placeRating": 4.3,
  "totalReviewCount": 8542,
  "address": "1-22-7 Jinnan, Shibuya, Tokyo 150-0041",
  "category": "Ramen restaurant",
  "reviewerName": "John D.",
  "rating": 5,
  "text": "Best tonkotsu ramen I've ever had. The solo booth concept is unique and the customization sheet lets you dial in exactly the flavor you want. Worth the 30 minute wait.",
  "date": "2 weeks ago",
  "ownerResponse": "Thank you for visiting Ichiran Shibuya! We're glad you enjoyed the experience.",
  "photoCount": 3,
  "sortedBy": "newest",
  "language": "en",
  "scrapedAt": "2026-04-01T12:00:00.000Z"
}
```

### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `success` | boolean | Whether scraping succeeded |
| `placeUrl` | string | Google Maps URL of the place |
| `placeName` | string | Business name |
| `placeRating` | number | Overall rating (1.0-5.0) |
| `totalReviewCount` | number | Total reviews on the listing |
| `address` | string | Full address |
| `category` | string | Business category |
| `reviewerName` | string | Name of the reviewer |
| `rating` | integer | Star rating (1-5) |
| `text` | string | Full review text |
| `date` | string | Relative or absolute date |
| `ownerResponse` | string | Business owner's reply (null if none) |
| `photoCount` | integer | Number of photos attached to review |
| `sortedBy` | string | Sort method used |
| `scrapedAt` | string | ISO timestamp of extraction |

### Real-World Use Cases

#### 1. Multi-Location Reputation Monitoring

Schedule daily runs for all your business locations. Export to Google Sheets via Apify integrations. Track rating trends and response rates over time.

#### 2. Competitor Sentiment Analysis

Scrape reviews for top 10 competitors in your area. Analyze common complaints and praise points to find your competitive advantage.

#### 3. Review Response Automation

Extract new reviews daily, identify negative ones (1-2 stars), and pipe into your CRM or Slack for immediate response.

#### 4. Local SEO Keyword Research

Mine review text for natural language that customers use to describe your business. Use these keywords in your Google Business Profile and website content.

#### 5. Restaurant/Hotel Benchmarking

Compare review volume, average ratings, and common topics across similar businesses in a market for investment or expansion decisions.

### FAQ

**Q: How many reviews can I scrape per place?**
A: Up to 500 reviews per place. Google Maps loads reviews dynamically, so the Actor scrolls the panel to load more. Very popular places with 10,000+ reviews can be sampled by adjusting `maxReviews` and `sortBy`.

**Q: Can I get reviews in Japanese / Spanish / other languages?**
A: Yes. Set the `language` parameter to any Google-supported language code (e.g., 'ja', 'es', 'de', 'fr'). The Actor will request reviews in that language and translate reviewer content where Google provides translations.

**Q: Are owner responses always captured?**
A: Yes, when present. If the business has replied to a review, the `ownerResponse` field contains the full text. If no reply exists, the field is `null`.

**Q: Can I filter to only see negative reviews?**
A: Yes. Set `sortBy` to "lowest\_rating" and optionally set `minRating` to 1 to see only 1-star reviews. You can also filter in post-processing by the `rating` field.

**Q: Is this compliant with Google's Terms of Service?**
A: This Actor extracts publicly available review data. Ensure your usage complies with applicable terms and local data protection regulations. Common legitimate uses include reputation monitoring, competitive analysis, and academic research.

### Pricing

Pay Per Event -- charged per review extracted. Typical cost: $0.005-0.02 per review depending on Apify compute usage. Free tier available for testing.

### Tags

google-maps, reviews, scraper, ratings, sentiment-analysis, reputation-management, local-seo, review-monitoring, customer-feedback, google-business-profile

# Actor input Schema

## `searchQuery` (type: `string`):

Search for places by keyword. Examples: 'restaurants in Tokyo', 'hotels near Times Square'. Reviews will be scraped for each found place.

## `placeUrls` (type: `array`):

Direct Google Maps place URLs to scrape reviews from. Use this when you know the exact places.

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

Maximum number of reviews to extract per place (1-500).

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

How to sort the reviews before extracting.

## `minRating` (type: `integer`):

Only include reviews with this rating or higher (1-5). Leave empty for all ratings.

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

Language code for results. Examples: 'en', 'ja', 'es', 'de', 'fr'.

## Actor input object example

```json
{
  "searchQuery": "restaurants in Shibuya Tokyo",
  "maxReviews": 50,
  "sortBy": "newest",
  "language": "en"
}
```

# 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 = {
    "searchQuery": "restaurants in Shibuya Tokyo"
};

// Run the Actor and wait for it to finish
const run = await client.actor("miccho27/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 = { "searchQuery": "restaurants in Shibuya Tokyo" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper",
        "description": "Scrape Google Maps reviews by place URL or search query. Extract reviewer names, star ratings, review text, dates, owner responses, and photo counts. Sort by newest, highest/lowest rating, or relevance. Filter by minimum rating. Multi-language support.",
        "version": "1.0",
        "x-build-id": "mF5p8LsCMrnHbrsjg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/miccho27~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-miccho27-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/miccho27~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-miccho27-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/miccho27~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-miccho27-google-maps-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for places by keyword. Examples: 'restaurants in Tokyo', 'hotels near Times Square'. Reviews will be scraped for each found place."
                    },
                    "placeUrls": {
                        "title": "Google Maps Place URLs",
                        "type": "array",
                        "description": "Direct Google Maps place URLs to scrape reviews from. Use this when you know the exact places.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Place",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per place (1-500).",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "newest",
                            "highest_rating",
                            "lowest_rating",
                            "most_relevant"
                        ],
                        "type": "string",
                        "description": "How to sort the reviews before extracting.",
                        "default": "newest"
                    },
                    "minRating": {
                        "title": "Minimum Rating Filter",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include reviews with this rating or higher (1-5). Leave empty for all ratings."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for results. Examples: 'en', 'ja', 'es', 'de', 'fr'.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
