# Google Maps Scraper (`mina_safwat/google-maps-scraper`) Actor

Extracts rich place data from Google Maps at lightning speed ⚡ .. including names, addresses, phone numbers, websites, ratings, reviews, and precise coordinates 📍. Run it on one or multiple search queries and get clean, reliable results in seconds 🚀

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

## Pricing

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

Extract **business listings from Google Maps** — name, address, phone number, website, rating, review count, coordinates, and place ID — for any list of search queries you give it. No API key, no quotas, no Places API billing.

### What does Google Maps Scraper do?

This Actor scrapes [Google Maps](https://www.google.com/maps) results pages directly. For each query you submit (e.g. *"restaurants in Miami"* or *"marketing agencies near Buffalo, New York"*), it walks the full paginated result set and saves every place it finds as a structured record in your Apify dataset.

Run it ad-hoc from the Apify Console, schedule it, or call it from your code via the Apify API. Pair it with Apify's proxy rotation to scale up safely.

### Why use Google Maps Scraper?

- **Lead generation** — build a list of local businesses (with phone, website, and address) for outbound sales or cold email.
- **Local SEO research** — see who ranks for the queries that matter to your clients, in the language and country of your choice.
- **Market analysis** — count restaurants, gyms, dentists, agencies in any area; compare ratings and review volume.
- **Directory building** — seed a niche directory site with thousands of pre-categorized listings.
- **No Places API hassles** — no quota caps, no per-request billing, no API key management.

### How to use Google Maps Scraper

1. Click **Try for free** (or open the Actor and click **Run**).
2. In the **Input** tab, add one search query per line (e.g. `restaurants in Miami`).
3. (Optional) Set the **language** and **country** codes to localize the results.
4. (Optional) Set **Max results per query** if you want to cap each query.
5. Click **Start**. Watch the log; results appear in the **Output** tab as they're scraped.
6. When the run finishes, download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input

The Actor accepts the following input fields (defined in the **Input** tab):

| Field | Type | Description |
| ----- | ---- | ----------- |
| `queries` | array of strings | One Google Maps search query per item. Required. |
| `language` | string | Two-letter language code (e.g. `en`, `es`, `de`). Default: `en`. |
| `country` | string | Two-letter country code (e.g. `us`, `gb`, `fr`). Default: `us`. |
| `maxResultsPerQuery` | integer | Max places per query. `0` or empty = no limit (Google Maps typically caps at ~120). |
| `maxConcurrency` | integer | Queries scraped in parallel. Default `3`. Recommended: 3–5. |

Example input JSON:

```json
{
    "queries": [
        "restaurants in Miami",
        "marketing agencies near New York"
    ],
    "language": "en",
    "country": "us",
    "maxResultsPerQuery": 0,
    "maxConcurrency": 3
}
````

### Output

Each item in the dataset is one Google Maps place. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Example output item:

```json
{
    "id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
    "url_place": "https://www.google.com/maps/place/?q=place_id:ChIJN1t_tDeuEmsRUsoyG83frY4",
    "title": "Joe's Stone Crab",
    "category": "Seafood restaurant",
    "address": "11 Washington Ave, Miami Beach, FL 33139",
    "phoneNumber": "(305) 673-0365",
    "completePhoneNumber": "+1 305-673-0365",
    "domain": "joesstonecrab.com",
    "url": "https://www.joesstonecrab.com/",
    "coor": "25.768,-80.135",
    "stars": 4.4,
    "reviews": 6128,
    "source_query": "restaurants in Miami"
}
```

### Data table

| Field | Type | Description |
| ----- | ---- | ----------- |
| `id` | string | Google Maps place ID (stable, unique). |
| `url_place` | string | Direct Google Maps link to the place. |
| `title` | string | Business name. |
| `category` | string | Primary category (e.g. *Seafood restaurant*). |
| `address` | string | Full address as shown on Maps. |
| `phoneNumber` | string | Local-format phone number (may be empty). |
| `completePhoneNumber` | string | International (E.164-style) phone number (may be empty). |
| `domain` | string | Bare domain of the business website (may be empty). |
| `url` | string | Full website URL (may be empty). |
| `coor` | string | `latitude,longitude` pair. |
| `stars` | number | Average star rating. |
| `reviews` | number | Review count. |
| `source_query` | string | The query that returned this place. |

Duplicate places (same `id`) are filtered out across all queries in a single run.

### How much does it cost to scrape Google Maps?

Cost depends on how many queries you run and how many results each returns. The Actor uses lightweight HTTP requests (no headless browser), so a typical query of ~120 results consumes a few seconds of compute and a small amount of bandwidth. Apify's free tier is more than enough to evaluate the Actor and run small jobs.

### Tips and advanced options

- **Localize results.** Set `language` and `country` to the codes for your target audience — Google's results vary significantly by locale.
- **Tune concurrency.** `maxConcurrency` of 3–5 is a good balance. Going higher risks Google rate-limiting you for the rest of the run.
- **Use proxies for large jobs.** When running many queries, attach Apify Proxy via your run settings so requests rotate IPs.
- **Cap costs with `maxResultsPerQuery`.** If you only need the top 20 places per query, set this to 20 and the Actor will stop paginating early.
- **Schedule recurring runs.** Use Apify's scheduler to refresh your dataset weekly or monthly.

### FAQ, disclaimers, and support

**Is scraping Google Maps legal?** This Actor only requests publicly accessible Google Maps pages — the same pages any user can view in a browser. You are responsible for ensuring your use of the data complies with Google's Terms of Service and the laws of your jurisdiction. Do not collect personal data without a lawful basis.

**Why are some fields empty?** Not every business has a website, phone number, or rating on Google Maps. Empty strings are normal.

**Why did I get fewer results than expected?** Google Maps caps any single query at ~120 results regardless of how many businesses match. To get more, split your query geographically (e.g. by neighborhood or city) and submit them as separate queries.

**Found a bug or have a feature request?** Open an issue in the Actor's **Issues** tab — feedback is always welcome, and custom solutions are available on request.

# Actor input Schema

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

List of Google Maps search queries (one per line). Examples: 'restaurants in Miami', 'marketing agencies near New York'.

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

Two-letter Google Maps language code (e.g. 'en', 'es', 'fr', 'de').

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

Two-letter Google Maps country code (e.g. 'us', 'gb', 'de', 'fr').

## `maxResultsPerQuery` (type: `integer`):

Maximum number of places to scrape per query. Leave at 0 (or empty) for no limit — Google Maps typically caps results at ~120 per query.

## `maxConcurrency` (type: `integer`):

How many queries to scrape in parallel. Recommended: 3–5. Higher values risk rate-limiting from Google.

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

Proxy used to fetch Google Maps. Apify Proxy is enabled by default to rotate IPs across queries and avoid rate-limiting.

## Actor input object example

```json
{
  "queries": [
    "restaurants in Miami",
    "marketing agencies near New York"
  ],
  "language": "en",
  "country": "us",
  "maxResultsPerQuery": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "queries": [
        "restaurants in Miami",
        "marketing agencies near New York"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mina_safwat/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": [
        "restaurants in Miami",
        "marketing agencies near New York",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("mina_safwat/google-maps-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": [
    "restaurants in Miami",
    "marketing agencies near New York"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call mina_safwat/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper",
        "description": "Extracts rich place data from Google Maps at lightning speed ⚡ .. including names, addresses, phone numbers, websites, ratings, reviews, and precise coordinates 📍. Run it on one or multiple search queries and get clean, reliable results in seconds 🚀",
        "version": "0.1",
        "x-build-id": "jT6f5tnlQN9Xrrt8o"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mina_safwat~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mina_safwat-google-maps-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/mina_safwat~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mina_safwat-google-maps-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/mina_safwat~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mina_safwat-google-maps-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": "List of Google Maps search queries (one per line). Examples: 'restaurants in Miami', 'marketing agencies near New York'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Two-letter Google Maps language code (e.g. 'en', 'es', 'fr', 'de').",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter Google Maps country code (e.g. 'us', 'gb', 'de', 'fr').",
                        "default": "us"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of places to scrape per query. Leave at 0 (or empty) for no limit — Google Maps typically caps results at ~120 per query.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent queries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many queries to scrape in parallel. Recommended: 3–5. Higher values risk rate-limiting from Google.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to fetch Google Maps. Apify Proxy is enabled by default to rotate IPs across queries and avoid rate-limiting.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
