# Google Maps Nearby Places (`crawlerbros/google-maps-nearby`) Actor

Find places near a coordinate. Lightweight alternative to area scanning - give a lat/lng + category + radius and get up to 120 matching places with details (name, rating, reviews, address, phone, website, coordinates, distance from center).

- **URL**: https://apify.com/crawlerbros/google-maps-nearby.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Travel, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 Nearby Places

Find places near a coordinate - a lightweight alternative to full area scanning.

Give it a latitude/longitude, a category (e.g. *coffee shop*, *pharmacy*, *gas station*) and a search radius, and it returns up to 120 nearby places with all the details you'd expect from Google Maps: name, category, rating, review count, address, phone, website, price level, coordinates, plus code, and distance from the centre point.

### When to use this actor

| Use this actor | Use Google Maps Area Scanner instead |
|---|---|
| "What's near this single point?" | "Map every business across a whole city / region" |
| You want a fast lookup (one search, up to 120 results) | You need to bypass Google's 120-result limit |
| Centre + radius is enough | You need polygon / bounding-box coverage |

This actor is purpose-built for **point-radius queries**. For large-area coverage, use `Google Maps Area Scanner`.

### How it works

1. Picks a Google Maps zoom level appropriate for your radius (smaller radius → tighter zoom, more local results).
2. Opens a single `/maps/search/<category>/@lat,lng,zoomz` URL.
3. Scrolls the result feed to load up to your `Max Results` cap.
4. Visits each place page and extracts the full details.
5. Filters by minimum rating and "open now" (best-effort) if requested.
6. Adds a `distanceFromCenter` field to each record, computed from the input centre.

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `category` | Yes | `coffee shop` | What to search for (any free-text query). |
| `location` | Yes | `{lat: 40.7484, lng: -73.9857}` | Centre point - Empire State Building by default. |
| `radiusKm` | No | `1` | Radius in km (0.1 - 10). Controls zoom level. |
| `maxResults` | No | `30` | Cap on places returned (1 - 120). |
| `minRating` | No | - | Only keep places with `totalScore ≥ minRating` (1.0 - 5.0). |
| `openNow` | No | `false` | Drop places explicitly closed right now (best-effort). |
| `language` | No | `en` | UI language (`en`, `es`, `fr`, `de`, `it`, `pt`, `ja`, `ko`, `zh`, `ar`, `ru`). |
| `proxyConfiguration` | No | - | Optional Apify Proxy. Datacenter IPs usually work; only enable if you see blocks. |

#### Radius → Zoom level

| Radius | Zoom |
|---|---|
| ≤ 0.3 km | 17 |
| 0.3 - 1 km | 16 |
| 1 - 2 km | 15 |
| 2 - 5 km | 14 |
| > 5 km | 13 |

### Output

Each record:

```json
{
  "name": "Stumptown Coffee Roasters",
  "categoryName": "Coffee shop",
  "totalScore": 4.5,
  "reviewsCount": 2891,
  "address": "30 W 8th St, New York, NY 10011",
  "phone": "(347) 414-7805",
  "website": "https://www.stumptowncoffee.com/",
  "priceLevel": "$$",
  "placeId": "0x89c25:0x70fba2…",
  "plusCode": "PXR4+QM New York",
  "location": {"lat": 40.7325, "lng": -73.9974},
  "distanceFromCenter": "1.8 km",
  "distanceFromCenterMeters": 1843,
  "googleMapsUrl": "https://www.google.com/maps/place/…",
  "scrapedAt": "2026-06-16T12:34:56+00:00"
}
````

Empty fields are omitted, never returned as `null`.

### FAQ

**How many places can I get per run?**
Up to 120 - that's the cap Google Maps enforces on a single search. For larger coverage, switch to **Google Maps Area Scanner**.

**Do I need a proxy?**
No. Google Maps generally serves results to datacenter IPs without challenge. The `proxyConfiguration` input is left blank by default and only needed if you start seeing blocks on heavy use.

**Why is the zoom level tied to my radius?**
Google Maps biases search results toward the visible map area at the chosen zoom. A tight zoom (17) over a 5 km radius would miss everything far from centre; a loose zoom (13) over 0.3 km would pull in too many irrelevant distant places. The mapping in the table above is the sweet spot.

**Does `openNow` always work?**
It's best-effort. Google Maps shows "Open" / "Closed" / "Opens at X" on most place pages, but not all. When we can't read the state we keep the place (rather than silently dropping it).

**Why are some fields missing on some records?**
Not every business on Google Maps has a phone number, website, price level, or plus code. We omit empty fields rather than emitting `null`, so the output JSON stays clean.

**How accurate is `distanceFromCenter`?**
It's computed with the haversine formula from your input centre to the place's extracted lat/lng - accurate to a few metres for typical urban queries.

### 🗺️ Complete Google Maps Scraper Suite

This actor is part of a comprehensive Google Maps data extraction toolkit by **crawlerbros**. All actors run on the free Apify plan, use no proxy by default, and return clean, structured data.

| Actor | What it does |
|---|---|
| 🏢 [Google Maps Business Scraper](https://apify.com/crawlerbros/google-maps-scraper) | Extract business data - name, address, phone, website, rating, reviews, hours, amenities |
| ⭐ [Google Maps Reviews Scraper](https://apify.com/crawlerbros/google-maps-reviews-scraper) | Scrape reviews with reviewer Local Guide level, photos, mentioned items, owner replies |
| 📸 [Google Maps Photos Scraper](https://apify.com/crawlerbros/google-maps-photos) | Extract all photos from any place - max-resolution URLs, contributor info, categories |
| 🕐 [Google Maps Business Hours Scraper](https://apify.com/crawlerbros/google-maps-business-hours) | Full 7-day hours, timezone, current local time, next open/close, holiday hours |
| 📊 [Google Maps Popular Times Scraper](https://apify.com/crawlerbros/google-maps-popular-times) | Busy hours histogram for all 7 days + current busyness + typical visit time |
| 📧 [Google Maps Email Extractor](https://apify.com/crawlerbros/google-maps-email-extractor) | Find business emails + social media links by crawling websites |
| 🗺️ [Google Maps Area Scanner](https://apify.com/crawlerbros/google-maps-area-scanner) | Geographic grid scanning - bypass the 120-place limit with bounding box / circle / polygon |
| 💼 [Google Maps Leads Scraper](https://apify.com/crawlerbros/google-maps-leads) | B2B lead generation with email + phone enrichment, US states + global countries |
| 🤖 [Google Maps MCP Server](https://apify.com/crawlerbros/google-maps-mcp) | Unified MCP server combining search + reviews for AI assistants |
| 🧭 [Google Maps Directions Scraper](https://apify.com/crawlerbros/google-maps-directions) | A→B routing - distance, duration, traffic, route alternatives for driving/walking/transit |
| 📍 [Google Maps Geocoding Scraper](https://apify.com/crawlerbros/google-maps-geocoding) | Bidirectional geocoding - address ↔ coordinates, with address components |
| 🔗 [Google Maps Similar Places Scraper](https://apify.com/crawlerbros/google-maps-similar-places) | "People also search for" / related place discovery - competitor & alternative finder |
| 🍽️ [Google Maps Menu Scraper](https://apify.com/crawlerbros/google-maps-menu) | Restaurant menu items, prices, descriptions, photos |
| 📋 [Google Maps Place List Scraper](https://apify.com/crawlerbros/google-maps-place-list) | Extract Google's curated "Top X in Y" lists - best hotels/restaurants/things to do |
| 🌍 [Google Maps Timezone Scraper](https://apify.com/crawlerbros/google-maps-timezone) | IANA timezone + current local time from coordinates |

# Actor input Schema

## `category` (type: `string`):

Type of place to search for near the given location (e.g., 'coffee shop', 'pharmacy', 'restaurant', 'gas station', 'hotel').

## `location` (type: `object`):

Latitude / longitude center point. Object with 'lat' and 'lng' numeric fields.

## `radiusKm` (type: `number`):

Search radius in kilometers. Used to pick the Google Maps zoom level (smaller radius = tighter zoom = more local results).

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

Maximum number of places to extract. Google Maps returns at most 120 results per query.

## `minRating` (type: `number`):

Only include places rated at or above this value (1.0–5.0). Leave blank to include all.

## `openNow` (type: `boolean`):

Filter to currently-open places only (best-effort — Google Maps doesn't always expose hours reliably).

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

Language for Google Maps interface and results.

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

Optional proxy settings. Datacenter IPs usually work fine for Google Maps; only enable if your runs are getting blocked.

## Actor input object example

```json
{
  "category": "coffee shop",
  "location": {
    "lat": 40.7484,
    "lng": -73.9857
  },
  "radiusKm": 1,
  "maxResults": 8,
  "openNow": false,
  "language": "en"
}
```

# 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 = {
    "category": "coffee shop",
    "location": {
        "lat": 40.7484,
        "lng": -73.9857
    },
    "radiusKm": 1,
    "maxResults": 8
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/google-maps-nearby").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 = {
    "category": "coffee shop",
    "location": {
        "lat": 40.7484,
        "lng": -73.9857,
    },
    "radiusKm": 1,
    "maxResults": 8,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-maps-nearby").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 '{
  "category": "coffee shop",
  "location": {
    "lat": 40.7484,
    "lng": -73.9857
  },
  "radiusKm": 1,
  "maxResults": 8
}' |
apify call crawlerbros/google-maps-nearby --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Nearby Places",
        "description": "Find places near a coordinate. Lightweight alternative to area scanning - give a lat/lng + category + radius and get up to 120 matching places with details (name, rating, reviews, address, phone, website, coordinates, distance from center).",
        "version": "0.4",
        "x-build-id": "MX5tIWwlKEviqm9FT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~google-maps-nearby/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-google-maps-nearby",
                "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/crawlerbros~google-maps-nearby/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-google-maps-nearby",
                "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/crawlerbros~google-maps-nearby/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-google-maps-nearby",
                "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": [
                    "category",
                    "location"
                ],
                "properties": {
                    "category": {
                        "title": "Category / Search Query",
                        "type": "string",
                        "description": "Type of place to search for near the given location (e.g., 'coffee shop', 'pharmacy', 'restaurant', 'gas station', 'hotel')."
                    },
                    "location": {
                        "title": "Center Location",
                        "type": "object",
                        "description": "Latitude / longitude center point. Object with 'lat' and 'lng' numeric fields."
                    },
                    "radiusKm": {
                        "title": "Radius (km)",
                        "minimum": 0.1,
                        "maximum": 10,
                        "type": "number",
                        "description": "Search radius in kilometers. Used to pick the Google Maps zoom level (smaller radius = tighter zoom = more local results).",
                        "default": 1
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum number of places to extract. Google Maps returns at most 120 results per query.",
                        "default": 30
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include places rated at or above this value (1.0–5.0). Leave blank to include all."
                    },
                    "openNow": {
                        "title": "Open Now Only",
                        "type": "boolean",
                        "description": "Filter to currently-open places only (best-effort — Google Maps doesn't always expose hours reliably).",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ja",
                            "ko",
                            "zh",
                            "ar",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Language for Google Maps interface and results.",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Datacenter IPs usually work fine for Google Maps; only enable if your runs are getting blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
