# Google Maps Scraper — Places, Details, Reviews, Geocoding (`experthasan/google-maps-scraper`) Actor

Scrape Google Maps places, place details, reviews, geocoding and autocomplete suggestions. No API key, no headless browser — fast direct requests.

- **URL**: https://apify.com/experthasan/google-maps-scraper.md
- **Developed by:** [Mahmudul Hasan](https://apify.com/experthasan) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 place scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are 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, Details, Reviews & Geocoding

Extract business data from Google Maps without an API key, a Google Cloud project, or a
billing quota. This Actor talks to Google's own map endpoints directly — no headless
browser — so runs are fast and cheap.

### What you get

| Action | What it returns |
| ------ | --------------- |
| **Search places** | Every business matching a query: name, address, coordinates, rating, review count, price level, categories, phone, website, place ID, Maps URL |
| **Place details** | The full record for a single named place |
| **Reviews** | Individual reviews for a place — author, rating, text, date, likes |
| **Geocode** | Address → latitude/longitude, plus the matched place name and formatted address |
| **Autocomplete** | Search-as-you-type suggestions for a partial query |

Results land in the run's dataset and export to JSON, CSV, Excel, XML or via the API.

### Pricing

Pay only for what you get back. No subscription, no monthly minimum.

| You pay for | Price |
| ----------- | ----- |
| Each place scraped | **$1.50 per 1,000** |
| Each review scraped | **$0.40 per 1,000** |
| Each address geocoded | **$0.50 per 1,000** |
| Each autocomplete query | **$0.30 per 1,000** |
| Actor start | $0.05 per 1,000 runs |

That is roughly **2.5× cheaper than the leading Google Maps scrapers on Apify Store**, and
platform compute is included — you are never billed separately for usage.

Set a **maximum cost per run** in the run options and the Actor stops cleanly the moment it
gets there. Nothing is charged for queries that return no data.

### Input

```json
{
  "action": "search",
  "queries": [
    "coffee shops in Austin",
    "pharmacy in Dhaka"
  ],
  "maxPlacesPerQuery": 20,
  "country": "us",
  "language": "en"
}
```

| Field | Description |
| ----- | ----------- |
| `action` | `search`, `place_details`, `reviews`, `geocode` or `autocomplete` |
| `queries` | One or more queries. Batch them — one run with 50 queries is far cheaper than 50 runs. |
| `maxPlacesPerQuery` | Cap on places returned per search query (1–100, default 20) |
| `maxReviewsPerPlace` | Cap on reviews per place (1–500, default 20) |
| `reviewsSort` | `most_relevant`, `newest`, `highest` or `lowest` |
| `latitude` / `longitude` / `zoom` | Optional viewport bias for searches |
| `country` / `language` | Google `gl` and `hl` codes, e.g. `gb` / `en` |
| `proxyConfiguration` | Optional. Google Maps is lightly protected, so a proxy is usually unnecessary. |
| `requestDelaySeconds` | Pause between Google requests. Raise it if you see blocked responses. |

### Output

One dataset item per result. A `search` item looks like:

```json
{
  "type": "place",
  "query": "coffee shops in Austin",
  "name": "Merit Coffee",
  "address": "222 W 4th St, Austin, TX 78701",
  "latitude": 30.2667,
  "longitude": -97.7456,
  "rating": 4.6,
  "reviews_count": 1284,
  "price_level": "$$",
  "categories": ["Coffee shop", "Cafe"],
  "phone": "+1 512-585-0621",
  "website": "https://meritcoffee.com",
  "place_id": "ChIJ...",
  "maps_url": "https://www.google.com/maps/search/coffee+shops+in+Austin"
}
```

A `reviews` item carries `author`, `rating`, `text`, `published` and `likes` alongside
`place_name` and `feature_id`. Failed queries are written as `{"type": "error", ...}` items
rather than killing the run, and are not charged.

### Common uses

- Build local business lead lists by category and city
- Monitor competitor ratings and review volume over time
- Enrich a CRM with phone numbers, websites and coordinates
- Bulk-geocode a spreadsheet of addresses
- Feed place data to an AI agent (this Actor supports agentic payments via x402 and Skyfire)

### Integrations

Trigger runs on a schedule, or connect the output to Google Sheets, Airtable, Slack, Make,
Zapier, or your own webhook. Everything is also reachable through the
[Apify API](https://docs.apify.com/api/v2) and the JavaScript and Python clients.

### Notes and limits

- This is an **unofficial scraper**. Google occasionally changes its internal response
  layout; when a parse comes back empty the Actor logs a warning and moves on rather than
  failing the run.
- Lookup by raw `place_id` is not supported for `place_details` and `reviews` — pass a
  name plus location instead (e.g. `Blue Bottle Coffee San Francisco`). Place IDs are still
  returned in search output.
- Review pagination is best-effort; very high `maxReviewsPerPlace` values may return fewer
  reviews than requested.
- Scrape only public data and use the output in line with Google's terms and applicable law.

### Support

Found a bug or need a field that is not extracted yet? Open an issue on the Actor's **Issues**
tab and it will be looked at.

# Actor input Schema

## `action` (type: `string`):

What to extract. Each action bills a different event — see the Pricing tab.

## `queries` (type: `array`):

One query per line. For `search`: "pharmacy in Dhaka". For `place_details` / `reviews`: "Blue Bottle Coffee San Francisco". For `geocode`: a full address. For `autocomplete`: a partial string.

## `maxPlacesPerQuery` (type: `integer`):

Only used by the `search` action. Each place returned is billed as one `place-scraped` event.

## `maxReviewsPerPlace` (type: `integer`):

Only used by the `reviews` action. Each review returned is billed as one `review-scraped` event.

## `reviewsSort` (type: `string`):

Only used by the `reviews` action.

## `latitude` (type: `string`):

Optional. Bias `search` around a point. Must be paired with longitude.

## `longitude` (type: `string`):

Optional. Bias `search` around a point. Must be paired with latitude.

## `zoom` (type: `integer`):

Map zoom for the search viewport (3 = country, 21 = building). Only applied when latitude and longitude are set.

## `country` (type: `string`):

Two-letter country code used for the Google request, e.g. `us`, `gb`, `bd`.

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

Two-letter language code for the results, e.g. `en`, `es`, `de`.

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

Google Maps is lightly protected, so a proxy is usually unnecessary. Enable it if you hit rate limits at high volume.

## `requestDelaySeconds` (type: `integer`):

Seconds to wait between consecutive Google requests. Raise this if you see blocked responses.

## Actor input object example

```json
{
  "action": "search",
  "queries": [
    "coffee shops in Austin"
  ],
  "maxPlacesPerQuery": 20,
  "maxReviewsPerPlace": 20,
  "reviewsSort": "most_relevant",
  "zoom": 12,
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "requestDelaySeconds": 1
}
```

# Actor output Schema

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

Every scraped item. Places carry name, address, coordinates, rating, review count, categories, phone, website and place\_id; geocode items carry the resolved coordinates; autocomplete items carry the suggestion list.

## `reviews` (type: `string`):

The same dataset opened on the reviews view — author, rating, text, date and likes for each review returned by the `reviews` action.

# 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 = {
    "queries": [
        "coffee shops in Austin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("experthasan/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 = { "queries": ["coffee shops in Austin"] }

# Run the Actor and wait for it to finish
run = client.actor("experthasan/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 '{
  "queries": [
    "coffee shops in Austin"
  ]
}' |
apify call experthasan/google-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,experthasan/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/X1CXJrhkWfSgZ0jIK/builds/lAyZp4Ht6EKP7EfwW/openapi.json