# Google Maps Place Scraper (`romy/google-maps-place-scraper`) Actor

Extract place details and reviews from Google Maps using keyword search — no API key required. Get business names, addresses, ratings, phone numbers, websites, opening hours, and user reviews at scale

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

## Pricing

from $1.00 / 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 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 Place Scraper

Search **Google Maps** by keyword and extract place details at scale — no API key required. Get business names, addresses, ratings, phone numbers, websites, opening hours, and more.

### What does Google Maps Place Scraper do?

This Actor searches Google Maps for places matching your keywords and extracts structured data for each result. You can search by business type, location, or any keyword you would use in Google Maps.

> **Need reviews too?** Use [Google Maps Place Detail Scraper](https://apify.com/RomySaputraSihananda/google-maps-place-detail-scraper) to scrape full details and user reviews from specific place URLs.

Runs on [Apify](https://apify.com) — schedule it, access results via API, export to CSV/JSON/Excel, and integrate with hundreds of tools.

### Why use Google Maps Place Scraper?

- **B2B lead generation** — find businesses in any niche with phone, website, and address
- **Local SEO research** — benchmark your competitors' ratings and review counts
- **Market research** — map the competitive landscape in any city or industry
- **Data enrichment** — augment your existing business lists with ratings and contact info

### How to use Google Maps Place Scraper

1. Open the Actor in Apify Console and click **Try for free**
2. Enter your search queries (e.g. `coffee shop Jakarta Selatan`, `dentist Bandung`)
3. Set max places per query and click **Start**
4. Download data as JSON, CSV, or Excel from the **Dataset** tab

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `queries` | array | Search keywords or Google Maps URLs | required |
| `maxPlacesPerQuery` | integer | Max places per query (0 = first page ~20) | 0 |
| `language` | string | Language code for results (en, id, ja…) | en |
| `country` | string | Country code for results (us, id, jp…) | us |

**Example input:**
```json
{
  "queries": ["coffee shop Jakarta Selatan", "gym Bintaro"],
  "maxPlacesPerQuery": 20
}
````

### Output

Each place is pushed as a `type: "place"` record.

**Place example:**

```json
{
  "type": "place",
  "name": "Kopi Kenangan",
  "address": "Jl. Perum Dasana Indah No.A-08, Sawah Baru, Ciputat",
  "item_id": "0x2e69ef847f039e49:0x1fddd20442ba99e1",
  "place_id": "ChIJSZhl04H7aS4RcKN6oTyYp4M",
  "latitude": -6.2918998,
  "longitude": 106.7266464,
  "rating_star": 4.5,
  "review_count": 312,
  "category": "Coffee shop",
  "phone": "+62 811-1234-5678",
  "website": "https://kopikita.id",
  "open_hours": "Open ⋅ Closes 10 PM",
  "open_status": "open",
  "tags": ["Coffee", "Cafe"],
  "description": "Modern coffee chain serving signature drinks"
}
```

**Data fields:**

| Field | Description |
|-------|-------------|
| `name` | Business name |
| `address` | Full address |
| `item_id` | Internal Google Maps hex ID |
| `place_id` | Google Place ID |
| `latitude` / `longitude` | GPS coordinates |
| `rating_star` | Average star rating (1–5) |
| `review_count` | Total number of reviews |
| `category` | Business category |
| `phone` | Phone number |
| `website` | Website URL |
| `open_hours` | Current open/close hours text |
| `open_status` | `open` or `closed` |
| `schedule` | Weekly hours schedule |
| `tags` | Place tags/labels |
| `description` | Short description |
| `popular_times` | Busy times by day and hour |

You can download the dataset in **JSON, CSV, HTML, or Excel** format.

### Pricing

This Actor uses **Pay Per Event** pricing — you only pay for what you scrape.

| Event | Price |
|-------|-------|
| Actor start | $0.05 |
| Place scraped | $0.005 |

**Cost estimates:**

- 20 places (1 page): ~$0.15
- 100 places: ~$0.55
- 1,000 places: ~$5.05

### Tips

- **Narrow your queries** for more relevant results: `"vegan restaurant Kemang Jakarta"` beats `"restaurant Jakarta"`
- **Set maxPlacesPerQuery** to limit costs during testing; remove the limit for full scrapes
- **Multiple queries** let you cover different areas: one query per city or neighborhood
- First page returns ~20 places; set `maxPlacesPerQuery > 20` to paginate further

### FAQ and Disclaimer

**Is this legal?** Web scraping public data is generally permitted, but always review Google's Terms of Service and your local regulations before large-scale use. This Actor scrapes publicly visible information only.

**Will it get blocked?** For reasonable request volumes, the Actor works well without a proxy. For high-volume scraping, consider using [Apify Proxy](https://apify.com/proxy) (configure via input).

**Missing fields?** Some fields (phone, website, hours) may not appear in search results for all places — Google sometimes requires opening the place detail page directly.

**Need reviews?** Use [Google Maps Place Detail Scraper](https://apify.com/RomySaputraSihananda/google-maps-place-detail-scraper) to scrape reviews from specific place URLs.

**Issues or feature requests?** Open a ticket in the Issues tab.

# Actor input Schema

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

Keywords or Google Maps URLs to search (e.g. 'coffee shop Jakarta', 'https://www.google.com/maps/search/...')

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

Maximum number of places to scrape per query (0 = up to first page, ~20 places)

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

Language code for Google Maps results (e.g. 'en', 'id', 'ja')

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

Country code for Google Maps results (e.g. 'us', 'id', 'jp')

## Actor input object example

```json
{
  "queries": [
    "coffee shop Jakarta Selatan"
  ],
  "maxPlacesPerQuery": 0,
  "language": "en",
  "country": "us"
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "coffee shop Jakarta Selatan"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("romy/google-maps-place-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 shop Jakarta Selatan"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Place Scraper",
        "description": "Extract place details and reviews from Google Maps using keyword search — no API key required. Get business names, addresses, ratings, phone numbers, websites, opening hours, and user reviews at scale",
        "version": "0.0",
        "x-build-id": "AaTJMryGacIeccdp2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/romy~google-maps-place-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-romy-google-maps-place-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/romy~google-maps-place-scraper/runs": {
            "post": {
                "operationId": "runs-sync-romy-google-maps-place-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/romy~google-maps-place-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-romy-google-maps-place-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords or Google Maps URLs to search (e.g. 'coffee shop Jakarta', 'https://www.google.com/maps/search/...')",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPlacesPerQuery": {
                        "title": "Max Places Per Query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of places to scrape per query (0 = up to first page, ~20 places)",
                        "default": 0
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for Google Maps results (e.g. 'en', 'id', 'ja')",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country code for Google Maps results (e.g. 'us', 'id', 'jp')",
                        "default": "us"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```