# Google Reviews Scraper (`fatihai-tools/google-reviews-scraper`) Actor

Extract Google Maps reviews for any business. Get review text, ratings, reviewer names, dates, and response data. Perfect for reputation monitoring, sentiment analysis, and local SEO research.

- **URL**: https://apify.com/fatihai-tools/google-reviews-scraper.md
- **Developed by:** [fatih dağüstü](https://apify.com/fatihai-tools) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 0.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 Reviews Scraper — Extract Google Maps Reviews & Ratings

**Scrape Google Maps reviews for any business.** Get reviewer names, star ratings, review text, dates, business contact info, and aggregate ratings — at scale, without a browser.

> **Pricing:** Pay only for what you get. **$5 per 1,000 reviews** (Pay-Per-Event). No monthly fees.

---

### What This Actor Does

This actor extracts **Google Maps reviews** from:

- **Direct Google Maps URLs** — paste any `google.com/maps/place/...` URL
- **Search queries** — e.g., `"dentist new york"`, `"best restaurants miami"` — the actor finds matching businesses automatically

#### Data You Get Per Review

| Field | Description |
|-------|-------------|
| `reviewerName` | Name of the person who left the review |
| `rating` | Star rating (1–5) |
| `text` | Full review text |
| `date` | Review publication date |
| `reviewerReviews` | Total number of reviews by this user |
| `businessName` | Name of the business |
| `businessRating` | Average star rating of the business |
| `businessTotalReviews` | Total review count on Google |
| `businessAddress` | Full business address |
| `businessPhone` | Business phone number |
| `businessWebsite` | Business website URL |
| `businessCategory` | Business type/category |
| `sourceUrl` | Google Maps URL scraped |
| `scrapedAt` | ISO timestamp of when data was collected |

---

### Why Use This Actor?

#### Use Cases

- **Reputation monitoring** — Track reviews for your business or competitors
- **Lead generation** — Find businesses by search query and analyze their reputation
- **Market research** — Compare businesses in a city/niche by rating and review volume
- **Review sentiment analysis** — Feed review text into your NLP pipeline
- **Local SEO audits** — Analyze Google ratings across multiple locations
- **Competitor analysis** — Monitor what customers say about competitors

---

### How to Use

#### Option 1: Scrape by Google Maps URL

1. Go to [Google Maps](https://maps.google.com)
2. Search for a business
3. Copy the URL from your browser (e.g., `https://www.google.com/maps/place/Starbucks/@40.7128,-74.0060,17z/...`)
4. Paste it into **Place URLs** input

#### Option 2: Scrape by Search Query

Enter queries like:
- `dentist new york`
- `best pizza chicago`
- `plumber london`
- `hotel near eiffel tower paris`

The actor will search Google Maps, find matching businesses, and extract their reviews.

#### Input Parameters

```json
{
  "placeUrls": [
    "https://www.google.com/maps/place/YourBusiness/@lat,lng,17z/"
  ],
  "searchQueries": [
    "coffee shop brooklyn"
  ],
  "maxReviews": 100,
  "minRating": 1,
  "language": "en",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

#### Sample Output

```json
{
  "reviewerName": "Jane Smith",
  "rating": 5,
  "text": "Absolutely fantastic! The service was incredible and the food was even better. Will definitely come back.",
  "date": "2024-03-15",
  "reviewerReviews": 47,
  "businessName": "The Grand Cafe",
  "businessRating": 4.7,
  "businessTotalReviews": 1243,
  "businessAddress": "123 Main St, New York, NY 10001",
  "businessPhone": "+1 212-555-0100",
  "businessWebsite": "https://thegrandcafe.com",
  "businessCategory": "Restaurant",
  "sourceUrl": "https://www.google.com/maps/place/The+Grand+Cafe/@40.7128,-74.0060,17z/",
  "scrapedAt": "2024-04-01T10:23:45.000Z"
}
```

***

### Pricing

| Plan | Reviews | Cost |
|------|---------|------|
| Trial | 20 reviews | Free |
| Starter | 1,000 reviews | $5 |
| Growth | 10,000 reviews | $50 |
| Scale | 100,000 reviews | $500 |

**Pay-Per-Event:** You are charged $0.005 per review extracted. You only pay for actual results.

***

### Competitor Comparison

| Feature | This Actor | Manual Export | Other Scrapers |
|---------|-----------|---------------|----------------|
| No login required | ✅ | ❌ | Varies |
| Search queries | ✅ | ❌ | Rarely |
| Business metadata | ✅ | ✅ | Sometimes |
| Pay per result | ✅ | N/A | Rarely |
| Residential proxy | ✅ | N/A | Sometimes |
| Language filter | ✅ | ❌ | Rarely |
| Rating filter | ✅ | ❌ | Rarely |
| No browser needed | ✅ | N/A | Rarely |

***

### Technical Notes

#### How Google Maps Review Scraping Works

Google Maps loads most review content via JavaScript. This actor uses a **static HTML approach** (no browser/Playwright) which means:

1. **JSON-LD structured data** is extracted first — Google often embeds business info and a subset of reviews in the page HTML for SEO purposes
2. **Embedded script data** is parsed for additional review signals
3. **Google Search knowledge panels** are used as a fallback to get business metadata

**For businesses with JSON-LD markup** (most major chains and verified businesses), you will get:

- Full business info (name, address, phone, website, rating, total reviews)
- Reviews that Google has embedded in the structured data (typically the most relevant ones)

**For maximum review coverage**, pair this actor with a headless browser actor or the [Google Maps Scraper](https://apify.com/compass/crawler-google-places) for JS-rendered content.

#### Anti-Bot Protection

- Rotates User-Agent strings (Chrome, Firefox, Safari, Edge)
- Uses residential proxies (recommended)
- Applies random delays of 3–6 seconds between requests
- Retries on detection with exponential backoff

#### Proxy Recommendation

Use **Apify Residential Proxies** for best results. Google detects datacenter IPs aggressively.

***

### FAQ

**Q: How many reviews can I get per business?**
A: Depends on what Google embeds in static HTML. For businesses with structured data, typically 5–20 reviews. The `maxReviews` parameter caps the total.

**Q: Does it work for all countries?**
A: Yes. Google Maps is global. Use the `language` parameter to control the interface language (e.g., `de` for German, `fr` for French).

**Q: Can I filter by star rating?**
A: Yes. Use `minRating: 4` to only get 4 and 5-star reviews.

**Q: Will this work with Google My Business URLs?**
A: Yes — both `google.com/maps/place/...` and short `maps.app.goo.gl` URLs are supported.

**Q: Is this legal?**
A: This actor scrapes publicly available information from Google Maps. It respects `robots.txt` and rate limits. Always check Google's Terms of Service and your local laws before using scraped data commercially.

**Q: What if Google blocks the scraper?**
A: The actor detects bot protection responses and retries with delays. Using residential proxies significantly reduces blocking. If issues persist, reduce concurrency.

**Q: Can I get reviews in a specific language?**
A: Set the `language` parameter (e.g., `"es"` for Spanish) to see reviews in that language where available.

***

### Related Actors by intelligent\_yaffle

- [Google Maps Email Extractor](https://apify.com/intelligent_yaffle/google-maps-email-extractor) — Find email addresses from Google Maps business listings
- [LinkedIn Company Scraper](https://apify.com/intelligent_yaffle/linkedin-company-scraper) — Get company data from LinkedIn
- [LinkedIn Profile Scraper](https://apify.com/intelligent_yaffle/linkedin-profile-scraper) — Extract LinkedIn professional profiles
- [Contact Email Finder](https://apify.com/intelligent_yaffle/contact-email-finder) — Find contact emails from any website
- [Leads Finder](https://apify.com/intelligent_yaffle/leads-finder) — All-in-one B2B lead generation tool

***

### Support

Found a bug or need a custom feature? [Open an issue](https://apify.com/intelligent_yaffle/google-reviews-scraper) or contact us through Apify.

**Keywords:** google reviews scraper, google maps reviews extractor, business review scraper, google review api alternative, scrape google reviews, reputation monitoring tool, google maps data extractor, review sentiment analysis, local business scraper, google business profile reviews

# Actor input Schema

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

List of Google Maps place URLs to scrape reviews from. Example: https://www.google.com/maps/place/Eiffel+Tower/@48.8583701,2.2922926,17z/

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

Search queries to find businesses and scrape their reviews. Example: 'dentist new york', 'best pizza chicago', 'plumber london'

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

Maximum number of reviews to extract per business. Note: Google Maps embeds a limited number of reviews in the initial HTML without JavaScript rendering.

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

Only return reviews with this star rating or higher (1–5). Use 1 to get all reviews.

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

Language code for Google Maps interface. Affects review language returned. Examples: 'en', 'de', 'fr', 'es', 'tr'

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

Proxy settings. Residential proxies recommended for Google Maps.

## Actor input object example

```json
{
  "placeUrls": [
    "https://www.google.com/maps/place/Apify/@50.0755381,14.4378005,15z/"
  ],
  "searchQueries": [
    "best coffee shop manhattan"
  ],
  "maxReviews": 100,
  "minRating": 1,
  "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 = {
    "placeUrls": [
        "https://www.google.com/maps/place/Apify/@50.0755381,14.4378005,15z/"
    ],
    "searchQueries": [
        "best coffee shop manhattan"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihai-tools/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 = {
    "placeUrls": ["https://www.google.com/maps/place/Apify/@50.0755381,14.4378005,15z/"],
    "searchQueries": ["best coffee shop manhattan"],
}

# Run the Actor and wait for it to finish
run = client.actor("fatihai-tools/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 '{
  "placeUrls": [
    "https://www.google.com/maps/place/Apify/@50.0755381,14.4378005,15z/"
  ],
  "searchQueries": [
    "best coffee shop manhattan"
  ]
}' |
apify call fatihai-tools/google-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Reviews Scraper",
        "description": "Extract Google Maps reviews for any business. Get review text, ratings, reviewer names, dates, and response data. Perfect for reputation monitoring, sentiment analysis, and local SEO research.",
        "version": "1.0",
        "x-build-id": "Ry4MuQh0Ftrk3g7rC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fatihai-tools~google-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fatihai-tools-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/fatihai-tools~google-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fatihai-tools-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/fatihai-tools~google-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fatihai-tools-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. Example: https://www.google.com/maps/place/Eiffel+Tower/@48.8583701,2.2922926,17z/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Search queries to find businesses and scrape their reviews. Example: 'dentist new york', 'best pizza chicago', 'plumber london'",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Business",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per business. Note: Google Maps embeds a limited number of reviews in the initial HTML without JavaScript rendering.",
                        "default": 100
                    },
                    "minRating": {
                        "title": "Minimum Star Rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with this star rating or higher (1–5). Use 1 to get all reviews.",
                        "default": 1
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for Google Maps interface. Affects review language returned. Examples: 'en', 'de', 'fr', 'es', 'tr'",
                        "default": "en"
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies recommended for Google Maps."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
