# Google Maps Local Business Finder (`gopalakrishnan/google-maps-scraper`) Actor

Search Google Maps by location and category to get a clean, deduplicated list of local businesses â names, addresses, phone numbers, ratings, websites, and place IDs. Built for lead generation; feed place IDs into review or enrichment Actors downstream.

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

## Pricing

from $1.50 / 1,000 places scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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 Local Business Finder

Search Google Maps by **location + category** and get back a clean, deduplicated list of
local businesses — names, addresses, phone numbers, websites, ratings, opening hours, and
Google Place IDs. Built for lead generation and local-business directories: the Place IDs
this Actor returns can be fed straight into review-scraping or contact-enrichment Actors
downstream.

This is a search-only Actor — it does not scrape reviews. For that, see the companion
Google Maps Reviews Actor.

### What it does

Give it a location (e.g. "Aurora, IL") and a search query (e.g. "dog park" or "coffee shop"),
and it will:

1. Geocode the location to a viewport (free, via OpenStreetMap Nominatim — no API key needed).
2. Lay a grid of search points across that viewport to cover the full area.
3. Query Google Maps' search API at each grid point and zoom level.
4. Parse, deduplicate by `place_id`, and return up to `maxResults` unique businesses.

### Input

| Field | Type | Description |
|---|---|---|
| `location` | string | Location name to search within (e.g. `"Aurora, IL"`). Either this or `viewport` is required. |
| `viewport` | object | Alternative to `location` — supply `{ northeast: { lat, lng }, southwest: { lat, lng } }` directly. |
| `searchQuery` | string | What to search for (e.g. `"coffee shop"`, `"restaurants"`, `"hotels"`). Required. |
| `gridLength` | integer | Grid density across the viewport. Higher = more coverage, more requests. Default `5`. |
| `zoomLevels` | array | Zoom levels to search at. Default covers a typical neighborhood-level search. |
| `maxResults` | integer | Maximum unique businesses to return. Default `100`. |
| `proxyConfiguration` | object | Proxy settings. Apify proxy recommended for reliability at scale. |

### Output

Each result in the dataset includes: `name`, `full_address`, `street_address`, `city`,
`state`, `zip`, `country_code`, `website`, `phone`, `place_id`, `avg_rating`,
`total_reviews`, `lat`, `long`, `tags` (categories), `hours`, and `notes`.

### Example

Input:

```json
{
  "searchQuery": "dog park",
  "location": "Aurora, IL",
  "maxResults": 20
}
````

This returns up to 20 unique dog parks around Aurora, IL with full address and place\_id
for each.

### Why use this instead of a generic Google Maps scraper

This Actor is purpose-built as a lead-gen / local-directory feed: fast, search-only, and
priced for high-volume listing pulls. If you need reviews, ratings breakdowns, or deep
profile enrichment for the businesses you find here, pass the returned `place_id`s into a
dedicated reviews or enrichment Actor rather than paying for that data on every search run.

### Pricing

This Actor uses the Pay-Per-Event model — you're charged per Actor run and per unique
business scraped. See the Actor's pricing tab on the Store page for current rates.

# Actor input Schema

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

Location name (e.g., 'new york city') to search within. Used to determine search area via geocoding. Either 'location' or 'viewport' must be provided.

## `viewport` (type: `object`):

Optional: Provide viewport bounds directly instead of location name. Format: {northeast: {lat, lng}, southwest: {lat, lng}}. If provided, location and API key are not needed. Either 'location' or 'viewport' must be provided.

## `searchQuery` (type: `string`):

What to search for on Google Maps (e.g., 'coffee shop', 'restaurants', 'hotels').

## `gridLength` (type: `integer`):

Size of the grid to divide the location area into. Larger values = more coverage but more requests. Recommended: 3-10.

## `zoomLevels` (type: `array`):

Array of zoom levels to use for searching. Each zoom level searches at different detail levels. Lower values = wider area coverage.

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

Maximum number of unique results to fetch across all grid points and zoom levels.

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

Proxy settings for anti-bot protection. Uses Apify proxy by default.

## Actor input object example

```json
{
  "searchQuery": "coffee shop",
  "gridLength": 5,
  "zoomLevels": [
    13499.795714815926
  ],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gopalakrishnan/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 = {}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Local Business Finder",
        "description": "Search Google Maps by location and category to get a clean, deduplicated list of local businesses â names, addresses, phone numbers, ratings, websites, and place IDs. Built for lead generation; feed place IDs into review or enrichment Actors downstream.",
        "version": "0.1",
        "x-build-id": "mMDRNwRjU8WhaeULa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gopalakrishnan~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gopalakrishnan-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/gopalakrishnan~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-gopalakrishnan-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/gopalakrishnan~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-gopalakrishnan-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": [
                    "searchQuery"
                ],
                "properties": {
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location name (e.g., 'new york city') to search within. Used to determine search area via geocoding. Either 'location' or 'viewport' must be provided."
                    },
                    "viewport": {
                        "title": "Viewport Bounds (Alternative to Location)",
                        "type": "object",
                        "description": "Optional: Provide viewport bounds directly instead of location name. Format: {northeast: {lat, lng}, southwest: {lat, lng}}. If provided, location and API key are not needed. Either 'location' or 'viewport' must be provided.",
                        "properties": {
                            "northeast": {
                                "type": "object",
                                "title": "Northeast",
                                "description": "Northeast corner coordinates of the viewport",
                                "editor": "json",
                                "properties": {
                                    "lat": {
                                        "type": "number",
                                        "title": "Latitude",
                                        "description": "Northeast latitude"
                                    },
                                    "lng": {
                                        "type": "number",
                                        "title": "Longitude",
                                        "description": "Northeast longitude"
                                    }
                                },
                                "required": [
                                    "lat",
                                    "lng"
                                ]
                            },
                            "southwest": {
                                "type": "object",
                                "title": "Southwest",
                                "description": "Southwest corner coordinates of the viewport",
                                "editor": "json",
                                "properties": {
                                    "lat": {
                                        "type": "number",
                                        "title": "Latitude",
                                        "description": "Southwest latitude"
                                    },
                                    "lng": {
                                        "type": "number",
                                        "title": "Longitude",
                                        "description": "Southwest longitude"
                                    }
                                },
                                "required": [
                                    "lat",
                                    "lng"
                                ]
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "What to search for on Google Maps (e.g., 'coffee shop', 'restaurants', 'hotels').",
                        "default": "coffee shop"
                    },
                    "gridLength": {
                        "title": "Grid Length",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Size of the grid to divide the location area into. Larger values = more coverage but more requests. Recommended: 3-10.",
                        "default": 5
                    },
                    "zoomLevels": {
                        "title": "Zoom Levels",
                        "type": "array",
                        "description": "Array of zoom levels to use for searching. Each zoom level searches at different detail levels. Lower values = wider area coverage.",
                        "items": {
                            "type": "number"
                        },
                        "default": [
                            13499.795714815926
                        ]
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique results to fetch across all grid points and zoom levels.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for anti-bot protection. Uses Apify proxy by default.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
