# Google Maps Places Scraper (`receptional_blender/google-maps-places`) Actor

Turn any Google Maps search into a clean list of local businesses — name, star rating, review count, address and phone number. Ideal for lead lists, local market research and location datasets.

- **URL**: https://apify.com/receptional\_blender/google-maps-places.md
- **Developed by:** [Assia Fadli](https://apify.com/receptional_blender) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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 Places Scraper

Turn any Google Maps search into a structured list of local businesses. Give it the
same queries you would type into Maps — `coffee shops in Berlin`, `dentists near
Lisbon`, `restaurants alger` — and it returns each place's name, star rating, review
count, address and phone number as clean dataset rows.

Great for building local lead lists, comparing competitors in an area, powering
location datasets, or feeding downstream analytics.

### What you get

For every business found in the search results, one dataset record:

| Field     | Description                                   |
| --------- | --------------------------------------------- |
| `name`    | Business name                                 |
| `rating`  | Average star rating (e.g. `4.1`)              |
| `reviews` | Number of reviews (e.g. `(15)`)               |
| `address` | Address / category line shown in the listing  |
| `phone`   | Phone number, when Google Maps exposes one    |

#### Example output

```json
{
  "name": "Chez Wahab Boutaji",
  "rating": "4.1",
  "reviews": "(15)",
  "address": "Restaurant · Downtown",
  "phone": ""
}
```

### Input

| Field           | Type            | Description                                                                                     |
| --------------- | --------------- | ----------------------------------------------------------------------------------------------- |
| `searchTerms`   | array of string | One or more Google Maps queries to run. The original field name `searchs` is accepted as alias. |
| `maxPlaces`     | integer         | Optional cap on the total number of places delivered across the run.                            |
| `proxyConfiguration` | object    | Proxy applied to every request. Apify Proxy is recommended to reduce blocking.                  |

Example input:

```json
{
  "searchTerms": ["coffee shops in Berlin", "dentists near Lisbon"],
  "maxPlaces": 200,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### How it works

1. Each search term is turned into a Google Maps search URL.
2. A real Chrome browser opens the page and scrolls the results panel until Google
   stops loading new entries.
3. Every business card in the list is parsed into a record and pushed to the dataset.

### Pricing

This actor uses the **pay-per-event** model. You are charged once per
`place-scraped` event — that is, once for each place record delivered to your
dataset. Set `maxPlaces` if you want a firm upper bound on the run.

### Author

Built and maintained by **Assia Fadli**. Licensed under MIT.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more Google Maps queries to run, exactly as you would type them into the Maps search box — e.g. "coffee shops in Berlin", "dentists near Lisbon" or "restaurants alger". Each term produces its own set of place records. (The original field name "searchs" is still accepted for backward compatibility.)

## `maxPlaces` (type: `integer`):

Optional hard cap on the total number of place records delivered across the whole run. Leave empty to keep every result Google Maps loads for your searches.

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

Proxy applied to every request. Keeping Apify Proxy on reduces blocking and rate limiting on Google Maps. You may pick specific groups or a country, or supply your own proxy URLs.

## Actor input object example

```json
{
  "searchTerms": [
    "coffee shops in Berlin",
    "dentists near Lisbon"
  ],
  "maxPlaces": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchTerms": [
        "restaurants alger"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("receptional_blender/google-maps-places").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 = {
    "searchTerms": ["restaurants alger"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("receptional_blender/google-maps-places").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 '{
  "searchTerms": [
    "restaurants alger"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call receptional_blender/google-maps-places --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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