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

Scrape Google Maps business search results — name, type, rating, review count, address, phone, website.

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

## Pricing

from $0.90 / 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 (Apify Actor)

Scrapes Google Maps business search results — name, type, rating, review count,
address, phone, and website.

### Input

| Field | Type | Default | Notes |
|-------|------|---------|-------|
| `query` | string | — | **Required.** What to search, e.g. `"coffee shops"` |
| `location` | string | — | Where to search, e.g. `"London"`. Combined as `"<query> in <location>"`. Optional |
| `maxResults` | integer | — | Max results to return. **Leave empty to return all available** |
| `scrapeContactDetails` | boolean | `false` | Add **emails + social profiles** for each business (slower, more proxy data) |
| `scrapePlaceDetails` | boolean | `false` | Add **full hours, price, description, attributes, links & more** for each business (slower, more proxy data) |
| `scrapeReviews` | boolean | `false` | Add the **top reviews** (author, rating, time, text) for each business. Implies `scrapePlaceDetails`. Ignored when `maxReviews` is set |
| `maxReviews` | integer | `0` | Page through and return **up to N reviews** per business. `0` = off. Much slower (browser-based); supersedes `scrapeReviews` |
| `proxyConfiguration` | object | RESIDENTIAL | Proxy settings (residential recommended) |

### Output

One dataset item per business:

```json
{
  "business_name": "Monmouth Coffee Company",
  "business_type": "Coffee shop",
  "average_rating": "4.5",
  "review_count": 3069,
  "address": "27 Monmouth St, London WC2H 9EU, United Kingdom",
  "phone": "+44 20 7232 3010",
  "website": "http://www.monmouthcoffee.co.uk/",
  "latitude": 51.5055334,
  "longitude": -0.0914069,
  "place_id": "ChIJ94DTm1cDdkgRibmgxzXy2EQ",
  "feature_id": "0x4876037c9bd380f7:0x44d8f235c7a0b989",
  "google_maps_url": "https://www.google.com/maps/place/?q=place_id:ChIJ94DTm1cDdkgRibmgxzXy2EQ",
  "opening_hours": { "Monday": "7:30 am–6 pm" }
}
````

When **`scrapeContactDetails`** is enabled, each item also includes contact fields
(found from the business's website; `null`/empty when the site doesn't list them):

```json
{
  "emails": ["info@prufrockcoffee.com"],
  "facebook": "https://www.facebook.com/Prufrockcoffee",
  "instagram": "https://www.instagram.com/prufrockcoffee/",
  "twitter": "https://twitter.com/PrufrockCoffee",
  "linkedin": null,
  "youtube": null,
  "tiktok": null,
  "pinterest": null
}
```

When **`scrapePlaceDetails`** is enabled, each item is filled out with everything
Google publishes for the place — full week hours, pricing, an editorial summary,
booking links, and the complete grouped attribute list. Any field Google doesn't
publish is simply omitted (e.g. price is absent for banks/museums, `menu_url` for
non-restaurants):

```json
{
  "opening_hours": {
    "Monday": "11:30 AM–9:30 PM",
    "Tuesday": "11:30 AM–9:30 PM",
    "Wednesday": "11:30 AM–9:30 PM",
    "Thursday": "11:30 AM–10:30 PM",
    "Friday": "11:30 AM–10:30 PM",
    "Saturday": "11:30 AM–10:30 PM",
    "Sunday": "11:30 AM–9:30 PM"
  },
  "price_level": "$$$$",
  "price_description": "Expensive",
  "description": "High-end New American meals on 60th floor",
  "plus_code": "PX5R+5C New York",
  "timezone": "America/New_York",
  "menu_url": "https://www.manhattarestaurant.com/restaurant-menu/",
  "reservation_url": "https://www.opentable.com/restaurant/profile/1021741",
  "order_url": "https://www.ubereats.com/store/...",
  "attributes": {
    "Service options": ["Dine-in", "Delivery", "Outdoor seating"],
    "Accessibility": ["Wheelchair accessible entrance", "Wheelchair accessible restroom"],
    "Offerings": ["Alcohol", "Coffee", "Vegan options", "Vegetarian options"],
    "Dining options": ["Lunch", "Dinner", "Brunch", "Catering"],
    "Amenities": ["Bar onsite", "Restroom", "Wi-Fi", "Gender-neutral restroom"],
    "Atmosphere": ["Cozy", "Romantic", "Upscale"],
    "Crowd": ["Groups", "LGBTQ+ friendly", "Tourists"],
    "Planning": ["Accepts reservations", "Reservations required"],
    "Payments": ["Credit cards", "Debit cards", "NFC mobile payments"],
    "Children": ["Good for kids", "High chairs", "Kids' menu"],
    "Parking": ["Paid street parking"],
    "From the business": ["Identifies as women-owned"]
  }
}
```

The `attributes` groups vary by place type (a museum has `Highlights`,
`Crowd`, `Planning`; a shop has `Service options`, `Payments`, `Recycling`, etc.).

When **`scrapeReviews`** is enabled (top reviews) or **`maxReviews`** is set (up
to N reviews), each item includes a `reviews` array:

```json
{
  "reviews": [
    {
      "author": "Joe Hunt",
      "author_review_count": 42,
      "rating": 5,
      "relative_time": "2 months ago",
      "text": "The guest roast Lumen coffee from Colombia was amazing. Great service too.",
      "profile_url": "https://www.google.com/maps/contrib/1234567890"
    }
  ]
}
```

### Run locally

```bash
echo '{ "query": "coffee shops", "location": "London" }' \
  > storage/key_value_stores/default/INPUT.json
apify run
```

Results land in `storage/datasets/default/`. (Add `"maxResults": 40` to cap the
number of results; omit it to get everything.)

### Deploy

```bash
apify login
apify push
```

### Monetization (pay-per-event)

The actor emits pay-per-event charge events so the premium enrichments bill only
when used. Configure prices for these event names under the actor's
**Monetization → Pay per event** settings in the Apify Console:

| Event | Price (live) | Charged | When |
|-------|--------------|---------|------|
| `apify-default-dataset-item` (primary) | $0.90 / 1,000 | per business returned | always (built-in, automatic) |
| `place-details` | $2.50 / 1,000 | per business enriched | `scrapePlaceDetails` / `scrapeReviews` |
| `review` | $2.00 / 1,000 | per review returned | `scrapeReviews` / `maxReviews` |
| `contact-details` | $2.50 / 1,000 | per business enriched | `scrapeContactDetails` |
| `apify-actor-start` | $0.00005 | per run | always (built-in) |

Pricing model is **pay-per-event with platform usage included** (the customer
pays only the event prices; compute + proxy are absorbed). The `place-details`,
`review` and `contact-details` events run a browser / crawl websites, so their
prices are set above raw proxy + compute cost.

The base per-result charge is Apify's built-in `apify-default-dataset-item`
event (billed automatically on dataset writes); the three custom events above
meter the premium enrichments on top. Charges are best-effort: until the
pay-per-event pricing is configured in the Console, the events are ignored and
runs are unaffected.

### Notes

- **Proxies recommended.** The input defaults to the `RESIDENTIAL` Apify Proxy
  group; keep it for best results.
- Leave `maxResults` empty to return all available results; set it to cap the
  output.

# Actor input Schema

## `query` (type: `string`):

What to search for on Google Maps, e.g. 'coffee shops'.

## `location` (type: `string`):

Where to search, e.g. 'London'. Combined with the query as '<query> in <location>'. Optional.

## `maxResults` (type: `integer`):

Maximum number of results to return. Leave empty to return all available results.

## `scrapeContactDetails` (type: `boolean`):

Crawl each business's website to extract email addresses and social media profiles (Facebook, Instagram, X/Twitter, LinkedIn, YouTube, TikTok, Pinterest). Much slower and uses more proxy data.

## `scrapePlaceDetails` (type: `boolean`):

Add the full Monday–Sunday opening hours, price level, editorial description, menu/reservation/order links, plus code, timezone, and the complete grouped attributes (service options, accessibility, amenities, offerings, atmosphere, payments, parking, and more) for each business. Slower and uses more proxy data.

## `scrapeReviews` (type: `boolean`):

Add the top published reviews for each business (author, star rating, time, and full text). Enabling this also includes place details. Slower and uses more proxy data. Ignored when 'Max reviews' is set.

## `maxReviews` (type: `integer`):

Page through and return up to this many reviews per business (author, star rating, time, full text). Leave empty/0 to skip. Much slower and uses more resources/proxy data — supersedes 'Scrape top reviews'.

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

Proxy settings. Residential proxies are recommended.

## Actor input object example

```json
{
  "query": "coffee shops",
  "location": "London",
  "scrapeContactDetails": false,
  "scrapePlaceDetails": false,
  "scrapeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `businesses` (type: `string`):

All scraped businesses in the default dataset.

# 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 = {
    "query": "coffee shops",
    "location": "London"
};

// Run the Actor and wait for it to finish
const run = await client.actor("elormcodes1/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 = {
    "query": "coffee shops",
    "location": "London",
}

# Run the Actor and wait for it to finish
run = client.actor("elormcodes1/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 '{
  "query": "coffee shops",
  "location": "London"
}' |
apify call elormcodes1/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper",
        "description": "Scrape Google Maps business search results — name, type, rating, review count, address, phone, website.",
        "version": "0.1",
        "x-build-id": "h3MZZ8mTPF64qZl5A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/elormcodes1~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-elormcodes1-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/elormcodes1~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-elormcodes1-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/elormcodes1~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-elormcodes1-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "What to search for on Google Maps, e.g. 'coffee shops'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search, e.g. 'London'. Combined with the query as '<query> in <location>'. Optional."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of results to return. Leave empty to return all available results."
                    },
                    "scrapeContactDetails": {
                        "title": "Scrape contact details (emails + social profiles)",
                        "type": "boolean",
                        "description": "Crawl each business's website to extract email addresses and social media profiles (Facebook, Instagram, X/Twitter, LinkedIn, YouTube, TikTok, Pinterest). Much slower and uses more proxy data.",
                        "default": false
                    },
                    "scrapePlaceDetails": {
                        "title": "Scrape place details (full hours, pricing, attributes & more)",
                        "type": "boolean",
                        "description": "Add the full Monday–Sunday opening hours, price level, editorial description, menu/reservation/order links, plus code, timezone, and the complete grouped attributes (service options, accessibility, amenities, offerings, atmosphere, payments, parking, and more) for each business. Slower and uses more proxy data.",
                        "default": false
                    },
                    "scrapeReviews": {
                        "title": "Scrape top reviews",
                        "type": "boolean",
                        "description": "Add the top published reviews for each business (author, star rating, time, and full text). Enabling this also includes place details. Slower and uses more proxy data. Ignored when 'Max reviews' is set.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Max reviews per business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Page through and return up to this many reviews per business (author, star rating, time, full text). Leave empty/0 to skip. Much slower and uses more resources/proxy data — supersedes 'Scrape top reviews'."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
