# Google Maps Business Scraper API | 💵 $2/1K (`webdata_labs/google-maps-business-scraper-api`) Actor

\[ 💵  $2.00 / 1K] Export Google Maps business listings by query with names, categories, phones, ratings, websites and Maps URLs.

- **URL**: https://apify.com/webdata\_labs/google-maps-business-scraper-api.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 google maps business listings

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

Export structured Google Maps business listings by keyword, category, brand, city, or neighborhood. Use the dataset for market research, location intelligence, competitor analysis, CRM enrichment, and local business directories.

This Actor returns **all matching businesses**. It does not filter for businesses without websites and does not score sales leads. For that specialized workflow, use the separate Google Maps No-Website Leads Scraper.

### 📦 What you get

Each dataset row can include:

- Business name and category
- Address and phone number
- Rating and review count
- Website URL and direct Google Maps URL
- Years in business and current open status, when Google exposes them
- The search query that produced the listing

Results are ready to download as JSON, CSV, Excel, XML, or RSS, and can be consumed through the Apify API.

### 🎯 Common use cases

- Compare competitors across cities or neighborhoods
- Measure market density by category and location
- Enrich an existing CRM or company database
- Build business directories and territory lists
- Analyze ratings, review volume, and local brand coverage
- Monitor chains, franchises, and branch locations

### 🚀 Ready-to-run examples

- [Find local businesses in any city](https://apify.com/webdata_labs/google-maps-business-scraper-api/examples/find-local-businesses-in-a-city) — export plumbers in Austin with contact details, ratings, reviews, websites, and Maps URLs.
- [Research competitor locations on Google Maps](https://apify.com/webdata_labs/google-maps-business-scraper-api/examples/research-competitor-locations) — analyze coffee-shop coverage and local competition in London.

Both example Tasks have been run successfully in Apify Cloud and include a public input preview and the `Google Maps businesses` dataset view.

### ⚙️ Input

Enter one or more focused Google Maps searches. Category plus location usually produces the most predictable coverage.

```json
{
  "searchQueries": [
    "coffee shops in London, UK",
    "coworking spaces in Manchester, UK"
  ],
  "maxBusinessesPerQuery": 100,
  "countryCode": "gb",
  "language": "en"
}
````

#### Input fields

| Field | Description | Default |
|---|---|---|
| `searchQueries` | One or more category, keyword, or brand searches with a location | Required |
| `maxBusinessesPerQuery` | Maximum unique listings exported for each query, up to 1,500 | `100` |
| `countryCode` | Two-letter Google localization country code | `us` |
| `language` | Google result language | `en` |

### 📤 Output

```json
{
  "name": "Example Coffee",
  "category": "Coffee shop",
  "address": "10 Example Street, London",
  "phone": "+44 20 0000 0000",
  "rating": 4.6,
  "reviewsCount": 384,
  "yearsInBusiness": 7,
  "openStatus": "Open",
  "websiteUrl": "https://example.com/",
  "googleMapsUrl": "https://maps.google.com/?cid=123456789",
  "searchQuery": "coffee shops in London, UK"
}
```

Some fields can be `null` because Google does not publish every attribute for every listing. Duplicate businesses found across multiple input queries are emitted once per run.

### 🔌 API usage

Start a synchronous run and receive the dataset items:

```bash
curl "https://api.apify.com/v2/acts/webdata_labs~google-maps-business-scraper-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["dentists in Miami, FL"],"maxBusinessesPerQuery":50}'
```

You can also schedule recurring runs, trigger the Actor from Make or Zapier, send results through webhooks, or use the official Apify client libraries.

### 💵 Pricing

The Actor costs **$2 per 1,000 exported listings** ($0.002 per dataset item). You pay for delivered rows; Apify platform usage is included in the event price shown on the Actor page.

### 🌍 Coverage and limits

- Google controls result depth. Broad searches may not expose every business in a large region.
- For deeper coverage, split a city into neighborhoods or use several specific category queries.
- Sponsored listings are skipped.
- Email addresses are not normally present in Google Maps listings and are not returned.
- Localization depends on the query language, `countryCode`, and `language` settings.
- Use the data in accordance with applicable laws and Google's terms.

### ❓ FAQ

**Does this only return businesses without websites?**\
No. It exports every matching listing, including businesses with and without websites.

**Does it return emails?**\
No. Google Maps generally does not expose business email addresses. Use the returned website URLs in a separate contact-enrichment workflow if needed.

**How do I get more results?**\
Use focused searches by neighborhood, nearby city, or subcategory. Google usually provides better depth for several precise queries than for one broad regional query.

**Can I run it on a schedule?**\
Yes. Save the input as an Apify Task and attach a schedule or webhook.

### 🛠️ Support

If a run fails or an expected field is missing, open an issue on the Actor page and include the run URL, input, and expected behavior.

# Actor input Schema

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

Business category, brand, or keyword plus a location. Use one focused query per line for predictable coverage.

## `maxBusinessesPerQuery` (type: `integer`):

Maximum number of unique listings exported for each query. Use several neighborhood-level queries when you need deeper coverage.

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

Two-letter country code used to localize Google results, for example us, gb, de, or pt.

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

Google result language, for example en, de, es, or pt.

## Actor input object example

```json
{
  "searchQueries": [
    "coffee shops in London, UK"
  ],
  "maxBusinessesPerQuery": 20,
  "countryCode": "us",
  "language": "en"
}
```

# Actor output Schema

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

No description

## `OUTPUT` (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": [
        "coffee shops in London, UK"
    ],
    "maxBusinessesPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/google-maps-business-scraper-api").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": ["coffee shops in London, UK"],
    "maxBusinessesPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/google-maps-business-scraper-api").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 '{
  "searchQueries": [
    "coffee shops in London, UK"
  ],
  "maxBusinessesPerQuery": 20
}' |
apify call webdata_labs/google-maps-business-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Business Scraper API | 💵 $2/1K",
        "description": "[ 💵  $2.00 / 1K] Export Google Maps business listings by query with names, categories, phones, ratings, websites and Maps URLs.",
        "version": "0.1",
        "x-build-id": "WKpj9fnWBnx89XTzW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~google-maps-business-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-google-maps-business-scraper-api",
                "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/webdata_labs~google-maps-business-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-google-maps-business-scraper-api",
                "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/webdata_labs~google-maps-business-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-google-maps-business-scraper-api",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Google Maps search queries",
                        "type": "array",
                        "description": "Business category, brand, or keyword plus a location. Use one focused query per line for predictable coverage.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinessesPerQuery": {
                        "title": "Maximum businesses per query",
                        "minimum": 1,
                        "maximum": 1500,
                        "type": "integer",
                        "description": "Maximum number of unique listings exported for each query. Use several neighborhood-level queries when you need deeper coverage.",
                        "default": 100
                    },
                    "countryCode": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter country code used to localize Google results, for example us, gb, de, or pt.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Result language",
                        "type": "string",
                        "description": "Google result language, for example en, de, es, or pt.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
