# Google Maps Places & Business Scraper (`axlymxp/google-maps-places-scraper`) Actor

Scrape Google Maps business listings at scale — name, category, full address, GPS, phone, website, rating, review count, opening hours and photos as clean JSON. Built for lead generation, local SEO and market research. Simple, transparent pricing — pay only for the results you get.

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

## Pricing

from $2.00 / 1,000 dataset items

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/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

## Google Maps Places & Business Scraper

Turn any keyword + location into a clean, structured list of Google Maps
businesses — **name, category, full address, GPS, phone, website, rating, review
count, opening hours and photos** — exported as JSON, CSV, or Excel, ready for
your CRM, spreadsheet, or data pipeline.

No Google API key, no quotas, no login. Just search terms and a place.

### Who it's for

- **Agencies & lead generation** — build call/outreach lists with **phone
  numbers, websites and full addresses** for any niche in any city.
- **Local SEO & market research** — map competitors by category with ratings,
  review counts, categories and hours.
- **PropTech / SaaS / directory builders** — a **stable JSON schema** with
  `place_id`, `cid` and `ftid` for clean joins and deduplication, callable from
  code, MCP, or an AI assistant.

### What you get (output fields)

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business / place name |
| `primary_category` / `categories` | string / array | Business category and all labels |
| `rating` / `review_count` | number / int | Average star rating and number of reviews |
| `phone` / `phone_display` | string | Phone in E.164 (`+1415…`) and local format |
| `website` / `website_domain` | string | Business website and bare domain |
| `full_address` | string | Complete formatted address |
| `street` / `city` / `state` / `postal_code` / `country_code` | string | Structured address parts |
| `neighborhood` / `timezone` / `plus_code` | string | District, IANA timezone, Plus Code |
| `latitude` / `longitude` | number | GPS coordinates |
| `opening_hours` | object | `{today, status, week[]}` (full week with detail enrichment) |
| `price_level` | string | Relative price band, e.g. `$$` |
| `photos` | array | `{photo_id, url, width, height, caption, media_type}` |
| `thumbnail` / `description` | string | Primary image and editorial summary |
| `attributes` | object | Grouped amenities/accessibility (e.g. Service options) |
| `place_id` / `cid` / `ftid` / `kgmid` | string | Stable Google identifiers |
| `maps_url` | string | Canonical Google Maps place URL |
| `search_query` / `search_location` / `scraped_at` | string | Row provenance |

### High-value use cases

1. **B2B lead lists** — "dentists in Chicago", "law firms in London" → a CSV of
   names, phones, websites and addresses for outreach.
2. **Local competitor analysis** — pull every "coffee shop" in a district with
   ratings and review counts to benchmark your location.
3. **Store/agent locators & directories** — power a niche directory site with a
   fresh, deduplicated business dataset keyed by `place_id`.
4. **Territory & market sizing** — count and map businesses per category across
   neighborhoods for sales planning.
5. **Data enrichment** — join `place_id`/`cid` into your existing records to add
   phone, hours, GPS and categories.

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQueries` | array | (required) | Keywords/categories, e.g. `["restaurants","dentist"]` |
| `location` | string | `""` | City/area to search within (geocoded), e.g. `"San Francisco, CA"` |
| `customCoordinates` | object | — | `{lat,lng,zoom}` to override geocoding for an exact viewport |
| `zoom` | integer | `14` | Viewport zoom (11≈city, 14≈district, 16≈neighborhood) |
| `maxItems` | integer | `100` | Stop after this many total places |
| `enrichPlaceDetails` | boolean | `false` | Extra per-place call: full-week hours, full gallery, editorial summary |
| `includePhotos` | boolean | `true` | Include the photo array in each row |
| `language` | string | `"en"` | Response language |
| `countryCode` | string | `"us"` | Country bias |
| `proxyConfiguration` | object | Residential | Apify Proxy (rotated on rate-limit) |

#### Example input

```json
{
  "searchQueries": ["coffee shops"],
  "location": "San Francisco, CA",
  "maxItems": 50,
  "includePhotos": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

#### Example output row

```json
{
  "name": "Blue Bottle Coffee",
  "primary_category": "Coffee shop",
  "categories": ["Coffee shop", "Cafe"],
  "rating": 4.5,
  "review_count": 1280,
  "phone": "+14156538205",
  "phone_display": "(415) 653-8205",
  "website": "https://bluebottlecoffee.com/",
  "full_address": "66 Mint St, San Francisco, CA 94103",
  "city": "San Francisco",
  "state": "CA",
  "postal_code": "94103",
  "country_code": "US",
  "latitude": 37.782,
  "longitude": -122.407,
  "opening_hours": { "today": "7 AM–6 PM", "status": "Open", "week": [] },
  "photos": [{ "photo_id": "AF1…", "url": "https://lh3.googleusercontent.com/…=s0", "width": 4032, "height": 3024, "media_type": "Photo" }],
  "place_id": "ChIJ8_Ju2YSAhYARz1234567890",
  "cid": "16472…",
  "maps_url": "https://www.google.com/maps/place/?q=place_id:ChIJ8_Ju2YSAhYARz1234567890",
  "search_query": "coffee shops",
  "search_location": "San Francisco, CA",
  "scraped_at": "2026-09-04T12:00:00Z"
}
```

### Scheduling, webhooks & integrations

- **Schedule** runs (hourly/daily/weekly) from the Apify Console to keep a fresh
  dataset.
- **Webhooks** notify your system on run finish; push results straight to
  Google Sheets, Make, Zapier, Slack, or S3.
- **API** — start runs and fetch the dataset in JSON/CSV/Excel with the Apify API
  or any Apify client library.

### Use it from an AI assistant (MCP)

This actor works with the **Apify MCP server**, so AI assistants (Claude, ChatGPT,
Cursor, VS Code) can call it as a tool — e.g. *"Get me every dentist in Austin
with a phone number and website."* Point your MCP client at Apify and invoke
`axlymxp/google-maps-places-scraper`.

### FAQ

**How many places can I get per search?**
Google returns roughly 120–200 places per term + viewport. To go wider, add more
search terms or split a city into smaller `location`/`customCoordinates` areas.

**Do I get email addresses?**
No. This actor returns the data Google Maps exposes — **phone and website**, not
email. Pipe the `website` field into an email-finder actor if you need emails.

**Do I get individual review text?**
No. You get the **rating**, **review count** and a **reviews URL**; full review
text is not part of this actor's scope.

**How fresh is the data?**
Every row is scraped live at run time (`scraped_at` timestamp included).

**Is it reliable?**
Yes — it calls Google Maps' own public endpoints and rotates Apify Residential
proxies, backing off automatically if Google rate-limits an IP.

**Is scraping Google Maps legal?**
The actor collects **publicly available** business information. You are
responsible for using the data in line with applicable laws and Google's terms.

**Something looks off — how do I get help?**
Open an issue on the actor's page; issues are monitored and addressed quickly.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords or business categories to search for on Google Maps, e.g. "restaurants", "dentist", "coffee shops". Each term is searched within the chosen location. You can also embed the place in the term (e.g. "plumbers in Austin") and leave Location empty.

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

City / area to search within, e.g. "San Francisco, CA" or "Berlin, Germany". It is geocoded to a map viewport (via OpenStreetMap). Leave empty to geocode each search term instead, or set Custom coordinates below for precise control.

## `customCoordinates` (type: `object`):

Optional. Override Location with an exact viewport centre: {"lat": 37.7749, "lng": -122.4194, "zoom": 14}. Zoom 11≈city, 14≈district, 16≈neighborhood.

## `zoom` (type: `integer`):

Map zoom used for the search viewport. Lower = wider area, higher = tighter. 11≈city, 14≈district, 16≈neighborhood.

## `maxItems` (type: `integer`):

Stop the whole run after this many places (across all search terms). Google caps a single term+area at roughly 120–200 places; widen the area or add terms for more.

## `enrichPlaceDetails` (type: `boolean`):

Fetch one extra request per place to add full-week opening hours, the full photo gallery and the editorial summary. Slower and billed per enriched place — off by default.

## `includePhotos` (type: `boolean`):

Include the array of place photos (id, full-resolution URL, size, caption) in each row.

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

Response language for names, categories and hours.

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

Country to bias results toward (Google 'gl' parameter).

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

Google Maps rate-limits per IP, so a rotating proxy is strongly recommended. Defaults to Apify Residential proxy; the actor rotates the session on any rate-limit.

## Actor input object example

```json
{
  "searchQueries": [
    "restaurants",
    "coffee shops"
  ],
  "location": "Berlin, Germany",
  "customCoordinates": {},
  "zoom": 14,
  "maxItems": 100,
  "enrichPlaceDetails": false,
  "includePhotos": true,
  "language": "en",
  "countryCode": "us",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQueries": [
        "restaurants"
    ],
    "location": "San Francisco, CA",
    "customCoordinates": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/google-maps-places-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 = {
    "searchQueries": ["restaurants"],
    "location": "San Francisco, CA",
    "customCoordinates": {},
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/google-maps-places-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 '{
  "searchQueries": [
    "restaurants"
  ],
  "location": "San Francisco, CA",
  "customCoordinates": {}
}' |
apify call axlymxp/google-maps-places-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axlymxp/google-maps-places-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/Qh9AAX9Qu2dFxfrlM/builds/eW5Fq3cOb5yWPSG6B/openapi.json