# Google Maps Places API & Scraper — Reviews, Phones, Websites (`openclawai/google-maps-scraper`) Actor

Google Maps scraper and Google Maps API alternative: places with names, addresses, phones, websites, ratings, reviews and GPS for any search. No API key. Pay per place.

- **URL**: https://apify.com/openclawai/google-maps-scraper.md
- **Developed by:** [Pika Choo](https://apify.com/openclawai) (community)
- **Categories:** AI, SEO tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 46 total users, 2 monthly users, 95.3% 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Maps Places API & Scraper — Reviews, Phones, Websites

**Google Maps scraper and places API** with no Google Maps API key. Type a search like `dentists in London` and get back names, addresses, phone numbers, websites, ratings, review counts, top Google Maps reviews, GPS coordinates and open status as clean JSON, CSV or Excel, for **$3 per 1,000 places**, charged only for places returned.

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.

**October 2026 update:** searches that Google answers with one place, with directions or with no match now finish cleanly with a clear status message instead of failing. Places are saved and charged one by one, so a run that reaches its timeout keeps every place scraped so far. If Google rate-limits the connection, the Actor retries through a datacenter proxy, then a residential proxy, by itself. Every place now carries its numeric Google `cid`.

***

### 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 reviews shown on the place page (up to 10) 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 reviews per place (up to 10). Adds about 3 seconds per place |
| `proxyConfiguration` | Direct access | Optional. The Actor switches to a datacenter proxy, then a residential proxy, by itself if Google rate-limits the connection; set one here only if you need a specific country |

#### 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
}
```

#### Scrape Google Maps 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?

A 20-place search usually finishes in 10 to 15 seconds at the default concurrency of 5 (measured October 28, 2026: median 9 seconds over 6 runs, slowest 14 seconds), and 60 places take about 2 minutes. Reviews add about 3 seconds per place. If the run has a short timeout, the Actor stops starting new places about 25 seconds before it and keeps everything already scraped.

#### Do I need proxies?

No. Direct access is the default and works for normal searches. If Google rate-limits the connection, the Actor retries through a datacenter proxy by itself, at no extra charge to you. If that is rate-limited too, it switches to a residential proxy and that run stops at 20 places, with a status message saying so; start it again for more. Set a proxy only if you want results as seen from a specific country.

#### 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 Google blocks the search page itself, the Actor retries through a datacenter proxy, then a residential proxy (a residential run stops at 20 places). If a run returns fewer places than expected, retry with a lower `concurrency` or a more specific query.

#### What if my search matches one place, or Google shows directions?

One match: you get that place. If Google answers with directions (for example `ferry from A to B`) or finds nothing, the run ends successfully with a status message that suggests a better query, and nothing is charged.

***

### 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 the top Google Maps reviews for each place (up to 10)**

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

⚠️ Adds ~3s per place

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

Optional. Leave as is to connect directly: if Google rate-limits the connection, the Actor retries through a datacenter proxy, then a residential proxy (20 places at most), by itself. Choose a proxy here only if you need results as seen from a specific country.

## 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/bO789zvyYjtVr4II0/openapi.json