# Google Maps Scraper — Places, Reviews & Contact Data (`openclawai/google-maps-scraper`) Actor

Scrape business listings from Google Maps. Extract name, address, phone, website, rating, reviews, coordinates, timezone and more. Fast parallel scraping with residential proxy support.

- **URL**: https://apify.com/openclawai/google-maps-scraper.md
- **Developed by:** [Pika Choo](https://apify.com/openclawai) (community)
- **Categories:** AI, SEO tools, MCP servers
- **Stats:** 37 total users, 6 monthly users, 77.8% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.003 / place scraped

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## Google Maps Scraper — Places, Reviews & Contact Data

Scrape Google Maps business listings with **$3 per 1,000 place events**, plus applicable start and other charges with no API key. Type a search like `dentists in London`, get back names, addresses, phone numbers, websites, ratings, review counts, top reviews, GPS coordinates and open status as clean JSON, CSV or Excel.

Built for lead generation, local SEO and AI agents: pay per place, run it from the Apify API, the Python and JavaScript clients, or directly from Claude, Cursor and other agents through MCP.

Published by **Datapika**, under **openclawai** on Apify. [Inspect recorded output and download JSON or CSV](https://datapika.com/actors/google-maps-scraper#sample). Samples show a dated run and build, not guaranteed results for another query.

**September 9, 2026 update:** the browser driver and container versions now match, and an installation failure stops the build. A direct-access test returned three London coffee shops. The residential-proxy test timed out before returning data. Direct access is the default; test any proxy with a small input before relying on it. Existing tasks that explicitly enable a proxy retain that choice.

***

### Who uses this Google Maps scraper?

- **Lead generation and sales teams** building lists of local businesses with phone numbers and websites
- **Local SEO and marketing agencies** auditing client listings, ratings and competitor density
- **Market researchers** mapping how many restaurants, gyms or clinics exist in a city or district
- **Real estate and travel platforms** enriching listings with nearby amenities and attractions
- **Data and AI teams** feeding Google Maps data into CRMs, dashboards, RAG pipelines and agents
- **Reputation teams** tracking what customers say in reviews across locations

***

### What data do you get from Google Maps?

Each result is one place. Fields follow the dataset schema exactly, so you can rely on them in code.

| Field | Description |
|-------|-------------|
| `title` | Business name |
| `category` | Primary business category (e.g. "Coffee shop") |
| `place_id` | URL-encoded place name from Google Maps |
| `cid` | Google's internal numeric place identifier |
| `link` | Direct Google Maps URL for the place |
| `address` | Full street address |
| `latitude` / `longitude` | GPS coordinates |
| `plus_code` | Google Plus Code (open location code) |
| `timezone` | IANA timezone (e.g. `America/New_York`) |
| `phone` | Business phone number |
| `website` | Business website URL |
| `review_rating` | Average Google rating (1.0 to 5.0) |
| `review_count` | Total number of Google reviews |
| `status` | Current open/closed status with hours (e.g. "Open · Closes 9 PM") |
| `description` | Business description or editorial summary |
| `price_range` | Price indicator ($, $$, $$$) |
| `thumbnail` | URL of the main place photo |
| `reviews` | Top 10 reviews with reviewer name, rating, date and text (only when `scrapeReviews` is on) |
| `search_query` | The query that found this place |
| `scraped_at` | ISO timestamp of the scrape |

Fields that Google does not publish for a given place (for example `phone` or `price_range`) are returned empty or omitted rather than guessed.

***

### How do I run it? Input options explained

Only `query` is required. Everything else has a sensible default.

| Input | Default | What it does |
|-------|---------|--------------|
| `query` | required | The Google Maps search, e.g. `plumbers in Austin Texas` |
| `maxResults` | 20 | Maximum places to return (1 to 500). Google Maps shows roughly 120 results per search, so split large areas into several queries |
| `concurrency` | 5 | Places scraped in parallel (1 to 10). Above 10 Google starts rate limiting |
| `scrapeReviews` | false | Also collect the top 10 reviews per place. Adds about 3 seconds per place |
| `proxyConfiguration` | Direct access | Optional proxy settings. Validate your proxy connection with a small input; the reviewed residential test timed out. |

#### Find restaurants in a city

```json
{
    "query": "restaurants in New York",
    "maxResults": 50
}
```

#### Lead generation for local businesses

```json
{
    "query": "plumbers in Austin Texas",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

#### Scrape reviews too

```json
{
    "query": "coffee shops in London",
    "maxResults": 20,
    "scrapeReviews": true
}
```

**Tip:** to cover a whole city, run one query per neighbourhood or postcode (`cafes in Brooklyn`, `cafes in Queens`) instead of one giant query. Google caps each search at around 120 places.

***

### How much does it cost to scrape 1,000 Google Maps places?

Pricing is pay per event. You are only charged for places that were actually scraped.

| Event | Price |
|-------|-------|
| Place scraped | **$0.003 per place** |
| Actor start | $0.00005 per GB of memory (one-time per run) |

**Worked example:** several runs that together return 1,000 charged places costs 1,000 × $0.003 = **$3.00**, plus a one-time start fee of about $0.0002 at the default 4 GB memory. Scraping 10,000 places across ten queries costs about $30. A quick 20-place test costs $0.06.

Because this Actor uses pay-per-event pricing, compute time and proxy traffic are covered by the per-place price. You do not pay separate platform usage for it. Set a spending limit on the run if you want a hard cap.

***

### Sample output

One dataset item per place. Reviews appear only when `scrapeReviews` is enabled.

```json
{
    "title": "Joe's Coffee",
    "category": "Coffee shop",
    "place_id": "Joe's+Coffee",
    "cid": "12345678901234567",
    "link": "https://www.google.com/maps/place/...",
    "address": "123 Main St, New York, NY 10001, United States",
    "latitude": 40.7128,
    "longitude": -74.006,
    "plus_code": "Q257+V3 New York, USA",
    "timezone": "America/New_York",
    "phone": "+1 212-555-0100",
    "website": "https://www.joescoffee.com/",
    "review_count": 843,
    "review_rating": 4.5,
    "status": "Open · Closes 9 PM",
    "description": "Cozy neighborhood cafe serving specialty espresso drinks.",
    "price_range": "$$",
    "thumbnail": "https://lh3.googleusercontent.com/...",
    "reviews": [
        {
            "name": "Maria K.",
            "rating": 5,
            "description": "Best flat white in the neighbourhood.",
            "date": "2 weeks ago"
        }
    ],
    "search_query": "coffee shops in New York",
    "scraped_at": "2026-04-08T12:00:00Z"
}
```

Download the dataset as JSON, CSV, Excel, XML or RSS from the run page or the API.

***

### Use with AI agents and MCP

This Actor is exposed as an MCP tool, so Claude, Cursor, Windsurf, ChatGPT and any MCP-capable agent can search Google Maps and receive structured places without writing scraper code.

- MCP server URL: `https://mcp.apify.com/?tools=fetch-actor-details,openclawai/google-maps-scraper`
- Step-by-step agent guide: [datapika.com/actors/google-maps-scraper](https://datapika.com/actors/google-maps-scraper)

Typical agent prompts: "find 50 dental clinics in Manchester with phone numbers", "compare ratings of gyms near Union Square", "list hotels in Lisbon with more than 500 reviews".

***

### Integrations: API, Python, JavaScript and automation

- **REST API:** start a run with `POST https://api.apify.com/v2/acts/openclawai~google-maps-scraper/runs?token=YOUR_TOKEN` and read results from the run's default dataset.
- **Python:** `pip install apify-client`, then call `client.actor("openclawai/google-maps-scraper").call(run_input={...})`.
- **JavaScript / Node.js:** `npm install apify-client`, then `client.actor("openclawai/google-maps-scraper").call({...})`.
- **No-code:** connect through Apify's Zapier, Make, n8n, Google Sheets and webhook integrations.
- **Scheduling:** run it daily or weekly from the Apify Console to monitor ratings and new competitors.

Full code samples for every language are generated in the API tab of this page.

***

### FAQ

#### Does Google Maps have an official API, and why not use it?

Yes, the Google Places API exists, but it requires a Google Cloud project, an API key, billing setup, and it returns at most 20 results per request with limited review data. This scraper needs no API key, returns up to 500 places per query, and costs a flat $3 per 1,000 places.

#### Can I use the Google Maps scraper API to get phone numbers and emails?

Phone numbers and websites are returned for every place that publishes them. Email addresses are not shown on Google Maps, so they are not included. Pair the `website` field with an email-finder tool if you need emails.

#### How many results can I scrape per query?

Google Maps returns roughly 120 places for a single search. `maxResults` accepts up to 500, but to reach that you should run several narrower queries (by neighbourhood, postcode or category) and combine the datasets.

#### How fast is it?

Runtime depends on source response times, returned places, concurrency and whether reviews are enabled. A navigation times out after 45 seconds so a stalled connection does not wait indefinitely. Start with a small query and inspect the result before increasing limits.

#### Do I need proxies?

Direct access is the default after the September 9 diagnostic. Public-source access can change, and larger queries may fail or return incomplete results. If you need a proxy, configure and test it with your account and query; a country-specific proxy does not guarantee geographic coverage.

#### What output formats are supported?

JSON, CSV, Excel, XML, HTML table and RSS, all from the same dataset. Three ready-made views are available: Overview, Contacts, and Full Data.

#### Is scraping Google Maps legal?

The scraper only collects publicly visible business information. Business names, addresses and phone numbers are generally not personal data, but reviews contain reviewer names, so store and process them in line with GDPR, CCPA and your local laws, and respect Google's terms for your use case. This Actor does not log into any account and does not bypass access controls.

#### What happens when Google blocks a request?

Blocked or failed places are skipped and not charged. If a run returns fewer places than expected, retry with residential proxies, a lower `concurrency`, or a more specific query.

***

### Legal and ethical use

Use this data responsibly. Do not use it for spam, harassment, or any purpose that violates applicable law or Google's terms of service. You are responsible for how you use the collected data.

# Actor input Schema

## `query` (type: `string`):

**What to search on Google Maps**

Examples:
• `restaurants in New York`
• `dentists in London`
• `coffee shops near Times Square`
• `plumbers in Austin Texas`
• `hotels in Paris France`

## `maxResults` (type: `integer`):

**Maximum number of places to scrape**

🟢 Quick test: 5–20
🟡 Normal: 20–100
🔴 Large: 100–500

⚠️ Google Maps shows ~120 results per search query. Use a specific location for more focused results.

## `concurrency` (type: `integer`):

**Number of places to scrape in parallel**

⚡ Higher = faster. Default 5 works well with residential proxies.

🔴 Warning: above 10 may trigger rate limiting.

## `scrapeReviews` (type: `boolean`):

**Extract top 10 reviews for each place**

✅ Enabled: Get reviewer name, rating, date, and review text
❌ Disabled: Skip reviews (faster, cheaper)

⚠️ Adds ~3s per place

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

Direct access is the default. A September 9, 2026 direct-access test returned three places; the residential-proxy test timed out. Enable a proxy only after testing it with your account and query. Source availability can change.

## Actor input object example

```json
{
  "query": "restaurants in New York",
  "maxResults": 20,
  "concurrency": 5,
  "scrapeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "restaurants in New York",
    "maxResults": 20,
    "concurrency": 5,
    "scrapeReviews": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("openclawai/google-maps-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 = {
    "query": "restaurants in New York",
    "maxResults": 20,
    "concurrency": 5,
    "scrapeReviews": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("openclawai/google-maps-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "restaurants in New York",
  "maxResults": 20,
  "concurrency": 5,
  "scrapeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call openclawai/google-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,openclawai/google-maps-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hkRhEwU4uKBMH9OhR/builds/jzOKY1ZRj9ekDec8L/openapi.json