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

Extract business data from Google Maps search results — names, addresses, phones, websites, ratings, reviews, opening hours, and 20+ fields. Covers any location or category. Grid search mode finds thousands of places per city.

- **URL**: https://apify.com/automly/google-maps-scraper.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** Lead generation, Travel, Developer tools
- **Stats:** 199 total users, 22 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 1.00 out of 5 stars

## Pricing

from $5.55 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

### What is Google Maps Scraper?

**Google Maps Scraper** extracts business data from Google Maps search results at scale. Enter any search query — like "restaurants in New York" or "dentists in London" — and get structured data for every place: names, addresses, phone numbers, websites, ratings, review counts, categories, coordinates, and more.

Unlike the official Google Places API, which caps results at 60 per search, this scraper returns **hundreds of results per query**. Enable **Grid Search** mode to break through the ~200-result limit and extract **thousands of places** across any city or region.

### What data can you extract from Google Maps?

| Field | Example |
|-------|---------|
| 📌 Business name | `Koshary Abou Tarek` |
| 📍 Full address | `16 Marouf, Qasr El Nil, Cairo, Egypt` |
| 📞 Phone number | `+20 2 25775935` |
| 🌐 Website URL | `https://www.aboutarek.com` |
| ⭐ Rating | `4.3` |
| 💬 Review count | `41,797` |
| 🏷️ Categories | `Restaurant, Fast food` |
| 💰 Price level | `$$` |
| 🗺️ GPS coordinates | `30.0509, 31.2394` |
| 🆔 Google Place ID | `ChIJN6wPHnhBWBQR...` |
| 🕐 Timezone | `Africa/Cairo` |
| 🔗 Google Maps URL | Direct link to the listing |

### How does this Google Maps Scraper work?

The scraper reverse-engineers the internal Google Maps search API — the same requests your browser makes when you search on Google Maps. No browser automation or Puppeteer needed. This makes it significantly **faster and cheaper** than browser-based scrapers.

1. **Session setup** — Visits Google Maps to obtain valid session cookies
2. **Search priming** — Sends an initial request to prepare the search context (ensures full data including review counts)
3. **Paginated extraction** — Fetches results in pages of 20, parsing the protobuf-encoded JSON response
4. **Grid search** (optional) — Splits your target area into a grid of smaller cells, runs localized searches in each cell, and deduplicates across all results

#### Simple mode vs Grid Search mode

| | Simple mode | Grid Search mode |
|--|-------------|------------------|
| **Results per query** | Up to ~220 | Up to thousands |
| **Speed** | Fast (~30 seconds) | Slower (depends on grid size) |
| **Best for** | Quick data pulls | Exhaustive coverage of a city |
| **How it works** | Single search + pagination | Splits area into grid cells, searches each |

### How to scrape Google Maps data

1. Click **Try for free** to open the scraper
2. Enter your search queries (e.g., `restaurants in new york`, `hotels in dubai`)
3. Set **Max Places Per Search** to control how many results you want
4. *(Optional)* Enable **Grid Search** for more results — set the cell size in km
5. Click **Start** and wait for the results
6. Download your data as **JSON**, **CSV**, **Excel**, or **XML**

#### Input example

```json
{
    "searchStringsArray": [
        "restaurants in new york",
        "coffee shops in brooklyn"
    ],
    "maxCrawledPlacesPerSearch": 200,
    "language": "en",
    "countryCode": "us",
    "enableGridSearch": true,
    "gridCellKm": 5
}
```

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

Apify gives you **$5 of free monthly credits** on the Free plan. This scraper is lightweight — it uses direct HTTP requests, not a browser — so it consumes very little compute.

| Plan | Monthly credits | Estimated results |
|------|----------------|-------------------|
| **Free** | $5 | ~5,000+ places |
| **Starter** ($49/mo) | $49 | ~50,000+ places |
| **Scale** ($499/mo) | $499 | 500,000+ places |

Actual costs vary by query complexity and grid search settings.

### Output example

Each place is returned as a JSON object with fields matching the popular [Google Maps Scraper by Compass](https://apify.com/compass/crawler-google-places) format:

```json
{
    "title": "Koshary Abou Tarek",
    "categoryName": "Restaurant",
    "address": "16 Marouf, Qasr El Nil, Cairo Governorate, Egypt",
    "website": "https://www.aboutarek.com/",
    "phone": "+20 2 25775935",
    "totalScore": 4.3,
    "reviewsCount": 41797,
    "categories": ["Koshari restaurant", "Fast food restaurant", "Restaurant"],
    "placeId": "ChIJN6wPHnhBWBQRH4fLwPXXXXX",
    "url": "https://www.google.com/maps/place/?q=place_id:ChIJN6wPHnhBWBQR...",
    "location": {
        "lat": 30.0509,
        "lng": 31.2394
    },
    "price": "$$",
    "timezone": "Africa/Cairo",
    "searchString": "restaurants in cairo",
    "rank": 1,
    "temporarilyClosed": false,
    "permanentlyClosed": false,
    "isAdvertisement": false
}
```

### What can you do with Google Maps data?

👉 **Lead generation** — Build prospecting lists with business names, phone numbers, emails, and websites

👉 **Competitor analysis** — Find and compare businesses by ratings, review counts, and categories in any location

👉 **Market research** — Analyze business density, pricing, and customer sentiment across regions

👉 **Local SEO auditing** — Monitor your business listings and compare against competitors

👉 **Real estate analysis** — Map nearby amenities, restaurants, and services around properties

👉 **Sales prospecting** — Target specific business types in specific areas for outreach campaigns

👉 **Academic research** — Collect geo-spatial data for urban planning, economics, and social science studies

### Grid Search: how to get thousands of results

Google Maps limits every search to approximately 200 results. The **Grid Search** feature bypasses this by splitting your target area into smaller geographic cells, searching each one independently, and deduplicating the combined results.

#### How it works

1. A bounding box is defined around your target city (auto-detected for 20+ major cities, or set manually)
2. The box is divided into a grid of cells based on your chosen cell size (default: 5 km)
3. Each cell runs its own paginated search with a localized viewport
4. Results are deduplicated by Google Place ID across all cells

#### Example results by cell size

| Cell size | Cells (Cairo) | Unique results | Time |
|-----------|---------------|----------------|------|
| 10 km | 4 | ~90 | ~2 min |
| 5 km | 16 | ~150 | ~4 min |
| 2 km | 110 | ~340 | ~8 min |
| 1 km | 440 | 500+ | ~20 min |

#### Supported cities (auto-detected)

Cairo, New York, London, Dubai, Paris, Tokyo, Istanbul, Riyadh, Mumbai, Berlin, Los Angeles, Chicago, Singapore, Bangkok, Rome, Jeddah, Alexandria, Doha, Amman, Beirut

For any other location, provide custom bounds via the `customBounds` input parameter.

### Advantages over the Google Places API

| | This scraper | Google Places API |
|--|-------------|-------------------|
| **Max results per search** | ~220 (unlimited with grid) | 60 |
| **Cost per 1,000 results** | ~$0.10 | $32+ |
| **Rate limits** | None | 100 requests/sec |
| **Fields included** | All visible data | Varies by billing tier |
| **Setup required** | None | API key + billing account |
| **Review counts** | Always included | Requires extra API call |

### Integrations and API access

This scraper runs on the Apify platform, giving you access to:

- **REST API** — Start runs and fetch results programmatically
- **Webhooks** — Get notified when a run completes
- **Scheduling** — Run the scraper on a daily, weekly, or custom schedule
- **Integrations** — Connect to Google Sheets, Zapier, Make, Slack, and more
- **Python & JavaScript clients** — Use the [Apify Python SDK](https://docs.apify.com/sdk/python/) or [JavaScript SDK](https://docs.apify.com/sdk/js/)

#### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automly/google-maps-scraper").call(run_input={
    "searchStringsArray": ["restaurants in new york"],
    "maxCrawledPlacesPerSearch": 100,
    "enableGridSearch": True,
    "gridCellKm": 5,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["phone"], item["totalScore"])
```

### FAQ

**How many results can I get per search?**
In simple mode, up to ~220 results. With Grid Search enabled, you can get thousands depending on cell size and the density of the area.

**Does it work for any country?**
Yes. Set the `language` and `countryCode` parameters to match your target market.

**Can I search multiple queries at once?**
Yes. Pass an array of search strings and each will be scraped sequentially.

**How fast is it?**
Simple mode takes 20-40 seconds for 200 results. Grid search with 2km cells across a major city takes 5-10 minutes for 300+ results.

**Is a Google API key required?**
No. This scraper works without any API key or Google account.

**Output is compatible with other Google Maps scrapers?**
Yes. The output format matches the popular [Google Maps Scraper by Compass](https://apify.com/compass/crawler-google-places), so you can use it as a drop-in replacement in existing workflows.

# Actor input Schema

## `searchStringsArray` (type: `array`):

List of search queries to run on Google Maps (e.g., 'restaurants in cairo', 'hotels in dubai'). Each query will be searched separately.

## `maxCrawledPlacesPerSearch` (type: `integer`):

Maximum number of places to scrape per search query. In simple mode, Google Maps returns up to ~220 results. Enable grid search to get more.

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

Language code for Google Maps results (e.g., 'en', 'ar', 'fr').

## `countryCode` (type: `string`):

Country code for Google Maps results (e.g., 'us', 'eg', 'ae').

## `enableGridSearch` (type: `boolean`):

Split the search area into a grid of smaller cells to find more results. This bypasses the ~200 result limit per single search by running localized searches across the area. Requires either a known city in the query or custom bounds.

## `gridCellKm` (type: `number`):

Size of each grid cell in kilometers. Smaller cells find more results but take longer. Recommended: 5 for quick scans, 2 for thorough scraping, 1 for exhaustive coverage.

## `maxPagesPerCell` (type: `integer`):

Maximum number of result pages to fetch per grid cell (20 results per page). Only applies when grid search is enabled.

## `proxyConfig` (type: `object`):

Select proxies to use. Residential proxies are recommended for best results, but datacenter proxies also work.

## `customBounds` (type: `object`):

Custom bounding box for grid search as JSON: {"south": lat, "west": lng, "north": lat, "east": lng}. If not provided, auto-detects from known cities.

## Actor input object example

```json
{
  "searchStringsArray": [
    "restaurants in new york",
    "hotels in dubai"
  ],
  "maxCrawledPlacesPerSearch": 100,
  "language": "en",
  "countryCode": "us",
  "enableGridSearch": false,
  "gridCellKm": 5,
  "maxPagesPerCell": 5,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `places` (type: `string`):

Scraped Google Maps business listings with names, addresses, phones, websites, ratings, reviews, opening hours, coordinates, and more.

# 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 = {
    "searchStringsArray": [
        "restaurants in new york"
    ],
    "proxyConfig": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automly/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 = {
    "searchStringsArray": ["restaurants in new york"],
    "proxyConfig": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automly/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 '{
  "searchStringsArray": [
    "restaurants in new york"
  ],
  "proxyConfig": {
    "useApifyProxy": true
  }
}' |
apify call automly/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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