# Google Maps Business Scraper – Extract Leads by Search Query (`endspec/google-maps-instant-business-scraper`) Actor

Search Google Maps by any query ("dentists in Miami", "coffee shops in Austin") and scrape business listings: name, full address, phone, website, rating, review count, category, geo coordinates and place ID. Great for local lead generation. No login, no API key. Pay only per business returned.

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

## Pricing

from $6.50 / 1,000 business returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Business Scraper — Extract Local Business Leads by Search

Search **Google Maps** by any query and scrape business listings at scale: name, full address, phone, website, rating, review count, category, geo coordinates and place ID. This Google Maps business scraper is built for **local lead generation** — one search returns a full page of businesses. No login, no cookies, no Google API key.

### Quick start (input → output)

**Input:**
```json
{ "query": "coffee shops in Austin, TX", "limit": 40 }
````

**Output (one row per business):**

```json
{
  "name": "Jo's Coffee – South Congress",
  "fullAddress": "1300 S Congress Ave, Austin, TX 78704, United States",
  "city": "Austin",
  "state": "Texas",
  "zipCode": "78704",
  "countryCode": "US",
  "phone": "+1 512-469-9003",
  "website": "https://www.joscoffee.com/south-congress-jos",
  "rating": 4.4,
  "reviewCount": 5200,
  "priceLevel": "$$",
  "type": "coffee shop",
  "latitude": 30.2510458,
  "longitude": -97.7493717,
  "placeId": "ChIJ1S_Bov20RIYRe7MiR8tYawY="
}
```

### What this actor does

- Searches Google Maps for your query and returns businesses with contact and location data.
- One request returns a full page (up to ~140 businesses); `limit` caps how many you get.
- Normalizes each business to a clean, documented shape ready for a CRM or spreadsheet.

### Input parameters

| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | ✅ | What + where, e.g. `dentists in Miami, FL`, `coffee shops in Austin, TX`. Include the location for best results. |
| `limit` | integer | — | Max businesses to return (default 40, max 200). |

**Important notes**

- Always include a **place** in the query (city/area) — "dentists" alone is too broad; "dentists in Miami" is ideal.
- `phone`, `website`, `rating` and `reviewCount` are present when Google lists them.
- An empty search returns a single error row and is **not** charged.

#### More input examples

```json
{ "query": "dentists in Miami, FL", "limit": 100 }
```

```json
{ "query": "restaurants in Austin, TX", "limit": 120 }
```

### Output

#### Field reference

| Field | Description |
|---|---|
| `name`, `fullAddress`, `city`, `state`, `zipCode`, `countryCode`, `neighborhood` | Identity + address. |
| `phone`, `phones`, `website`, `domain` | Contact. |
| `rating`, `reviewCount`, `priceLevel` | Reputation. |
| `type`, `subtypes`, `shortDescription` | Category. |
| `latitude`, `longitude` | Geo coordinates. |
| `placeId`, `businessId` | Stable identifiers. |

#### Output examples

**No results** (not charged):

```json
{ "status": "error", "error": "No businesses were found for this search. Try adding a city or a broader term. You were not charged." }
```

**Bad input** (not charged):

```json
{ "status": "error", "error": "That search could not be processed. Please adjust your query and try again. You were not charged." }
```

**Service busy** (not charged):

```json
{ "status": "error", "error": "The maps data service is temporarily unavailable — please retry shortly. You were not charged." }
```

### Use cases

- **Agencies / sales teams:** build local lead lists (phone + website) by niche and city.
- **Market research:** map competitor density, ratings and price levels in an area.
- **Data enrichment:** attach geo coordinates and place IDs to a business list.

### Best practices

- Always pair the niche with a location in `query`.
- Increase `limit` for exhaustive local coverage; you're billed per business returned.
- De-duplicate on `placeId` if you run overlapping searches.

### Pricing

Pay-per-event: charged **once per business returned**. Empty searches and errors are **never** charged.

### Legality

Business listings are publicly available. Use the data in compliance with Google's Terms of Service, anti-spam laws (e.g. CAN-SPAM/GDPR for any outreach), and applicable law. You are responsible for how you contact businesses and use the exported data.

### FAQ

**Do I need a Google API key?** No.
**How many businesses per search?** Up to 200 via `limit` (one search returns a large page).
**Do I get phone numbers?** Yes, when Google lists them.
**Can I search a whole city?** Yes — e.g. `"plumbers in Chicago, IL"`.

### Support

Email **contact@endspec.net** — we typically reply within one business day.

# Actor input Schema

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

What to search on Google Maps — include the place for best results (e.g. "dentists in Miami", "coffee shops in Austin, TX").

## `limit` (type: `integer`):

Maximum number of businesses to return in one run.

## Actor input object example

```json
{
  "query": "coffee shops in Austin, TX",
  "limit": 40
}
```

# 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 = {
    "query": "coffee shops in Austin, TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("endspec/google-maps-instant-business-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 in Austin, TX" }

# Run the Actor and wait for it to finish
run = client.actor("endspec/google-maps-instant-business-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 in Austin, TX"
}' |
apify call endspec/google-maps-instant-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Business Scraper – Extract Leads by Search Query",
        "description": "Search Google Maps by any query (\"dentists in Miami\", \"coffee shops in Austin\") and scrape business listings: name, full address, phone, website, rating, review count, category, geo coordinates and place ID. Great for local lead generation. No login, no API key. Pay only per business returned.",
        "version": "0.1",
        "x-build-id": "aSjps8qeyJDIMtXPy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/endspec~google-maps-instant-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-endspec-google-maps-instant-business-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/endspec~google-maps-instant-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-endspec-google-maps-instant-business-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/endspec~google-maps-instant-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-endspec-google-maps-instant-business-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 on Google Maps — include the place for best results (e.g. \"dentists in Miami\", \"coffee shops in Austin, TX\")."
                    },
                    "limit": {
                        "title": "Max Businesses",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of businesses to return in one run.",
                        "default": 40
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```