# Google Maps Similar Places Scraper (`crawlerbros/google-maps-similar-places`) Actor

Extract 'People also search for' / similar / related places from any Google Maps business page - name, place ID, rating, reviews, category, image, and coordinates.

- **URL**: https://apify.com/crawlerbros/google-maps-similar-places.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **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 Similar Places Scraper

Extract the **"People also search for"** / similar / related places carousel from any Google Maps business page in seconds. Get the full list of competing or complementary nearby businesses that Google itself thinks travelers and locals consider when looking at your target place — including their ratings, review counts, categories, and clean place URLs ready for follow-up scraping.

Perfect for competitive intelligence, market research, hotel comparison shopping, restaurant discovery flows, and building "places like this" recommendation pipelines on top of Google Maps data.

### What it does

Point the actor at any Google Maps place URL (a restaurant, hotel, landmark, store, etc.) and it returns the related-places carousel that Google shows in the side panel — with every field that Google actually publishes for those related places:

- Related place **name** and **placeId** (the Google Maps feature ID, ready for re-scraping)
- A clean, CID-based **Google Maps URL** for each related place
- **Rating** (totalScore) and **review count**
- **Category** name and the full **categories** list
- **Latitude / longitude** coordinates
- A **max-resolution thumbnail image** URL
- Carousel **rank** (1 = first card shown)
- The carousel **section type** ("People also search for", "Similar places", etc.)
- Back-references to the **source business** (name, placeId, URL) so a dataset of multiple sources stays joinable

### Input

| Field | Type | Description |
| --- | --- | --- |
| `placeUrl` *(required)* | string | Any Google Maps place URL — `/maps/place/...` |
| `maxResults` | integer (1–50) | How many related places to extract. Default: 20 |
| `language` | enum | Maps interface language: `en`, `es`, `fr`, `de`, `it`, `pt`, `ja`, `ko`, `zh`, `ar`, `ru`. Default: `en` |
| `proxyConfiguration` | proxy | Optional. The scraper works without proxy by default; if a place fails to load, the actor automatically retries through the proxy you supply here |

Example input:

```json
{
  "placeUrl": "https://www.google.com/maps/place/The+Ritz+London/@51.5070782,-0.1416273,17z/data=!3m1!4b1!4m6!3m5!1s0x48760529d30fc857:0x596135811e044014",
  "maxResults": 10,
  "language": "en"
}
````

### Output

One dataset record per related place:

```json
{
  "sourceBusinessName": "The Ritz London",
  "sourcePlaceId": "0x48760529d30fc857:0x596135811e044014",
  "sourcePlaceUrl": "https://www.google.com/maps/place/The+Ritz+London/...",
  "relatedSectionType": "People also search for",
  "rank": 1,
  "name": "The Savoy",
  "placeId": "0x0:0x...",
  "googleMapsUrl": "https://www.google.com/maps?cid=...",
  "categoryName": "5-star hotel",
  "categories": ["5-star hotel", "Hotel"],
  "totalScore": 4.6,
  "reviewsCount": 12453,
  "latitude": 51.5101,
  "longitude": -0.1208,
  "image": "https://lh3.googleusercontent.com/p/...=s512",
  "scrapedAt": "2026-06-16T08:50:12.345678+00:00"
}
```

Empty / unknown fields are omitted entirely — every record only contains the keys Google actually publishes for that place. No `null` values, no sentinels.

### How it works (without the implementation noise)

Google ships the related-places carousel pre-baked inside the Maps HTML payload as a structured data block. This scraper reads that block directly — no flaky DOM walking, no fragile XPath — which is why the output is so clean and the actor is so fast.

A DOM fallback exists for the rare case where the structured block is shaped differently, so you never get an empty dataset on a normal place page.

### Use cases

- **Hotel competitive analysis**: feed in a hotel URL, get the 10 hotels Google says travelers also looked at
- **Restaurant discovery flows**: build "if you liked X, you might like..." recommenders backed by Google's own signals
- **Landmark itineraries**: turn one landmark URL into a list of related landmarks (museums adjacent to a famous one, e.g.)
- **Market mapping**: chain this actor with the regular Google Maps scraper to expand from a small seed list to a full neighborhood map in two passes
- **SEO & local marketing**: see which competitors Google associates with your business listing

### FAQ

**Does it need cookies / login / an API key?**\
No. The actor runs against the public Google Maps web UI.

**Does it need a proxy?**\
No — by default it runs without any proxy and works fine from Apify datacenter IPs. A proxy field is exposed for fallback only.

**Will every place have related places?**\
Restaurants, cafes, bars and dining venues return the most reliable data — these consistently surface a "People also search for" carousel that the actor extracts in full (place ID, rating, reviews, coordinates, image). Hotels, large landmarks and tourist attractions sometimes show a lazy-loaded carousel that doesn't populate on every request; for those, output may be partial or empty. A retry pass through the optional `proxyConfiguration` field usually helps when the no-proxy attempt comes up empty.

**How many results per page?**\
Google itself shows 5–8 cards per carousel; the actor's `maxResults` caps that — and if Google ever increases the carousel size, the actor automatically picks up the extra cards.

**Does it work in non-English markets?**\
Yes. The `language` input controls the Maps locale. The actor recognises section headers in several languages, and the extracted data fields (placeIds, ratings, coordinates, images) are language-agnostic.

**Can I run it on multiple URLs at once?**\
Yes — point it at one URL per run. To process many URLs in a batch, run the actor multiple times (e.g., from the Apify Scheduler or a parent actor); each run's output goes to its own dataset and includes the `sourcePlaceId` field so you can join them downstream.

### Data Source

Public Google Maps web UI. No login, no API key, no paid third-party service required.

### 🗺️ 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 Menu Scraper](https://apify.com/crawlerbros/google-maps-menu) | Restaurant menu items, prices, descriptions, photos |
| 📌 [Google Maps Nearby Scraper](https://apify.com/crawlerbros/google-maps-nearby) | Find places near a coordinate point — lightweight POI search by category |
| 📋 [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

## `placeUrl` (type: `string`):

Google Maps URL of the business page to extract similar places from.

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

Maximum number of similar places to extract (1-50).

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

Language for the Google Maps interface (affects names/categories in some markets).

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

Optional proxy. Leave default; the scraper works from datacenter IPs without proxy. Used as fallback only.

## Actor input object example

```json
{
  "placeUrl": "https://www.google.com/maps/place/Le+Bernardin/@40.7614218,-73.9817558,17z/data=!3m1!4b1!4m6!3m5!1s0x89c258ff8fb87b41:0x6548e99cd73a1e6b",
  "maxResults": 10,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "placeUrl": "https://www.google.com/maps/place/Le+Bernardin/@40.7614218,-73.9817558,17z/data=!3m1!4b1!4m6!3m5!1s0x89c258ff8fb87b41:0x6548e99cd73a1e6b",
    "maxResults": 10,
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/google-maps-similar-places").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 = {
    "placeUrl": "https://www.google.com/maps/place/Le+Bernardin/@40.7614218,-73.9817558,17z/data=!3m1!4b1!4m6!3m5!1s0x89c258ff8fb87b41:0x6548e99cd73a1e6b",
    "maxResults": 10,
    "language": "en",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-maps-similar-places").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 '{
  "placeUrl": "https://www.google.com/maps/place/Le+Bernardin/@40.7614218,-73.9817558,17z/data=!3m1!4b1!4m6!3m5!1s0x89c258ff8fb87b41:0x6548e99cd73a1e6b",
  "maxResults": 10,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/google-maps-similar-places --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Similar Places Scraper",
        "description": "Extract 'People also search for' / similar / related places from any Google Maps business page - name, place ID, rating, reviews, category, image, and coordinates.",
        "version": "1.2",
        "x-build-id": "vv1ZRUqwxAaDGTr5b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~google-maps-similar-places/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-google-maps-similar-places",
                "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-similar-places/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-google-maps-similar-places",
                "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-similar-places/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-google-maps-similar-places",
                "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": [
                    "placeUrl"
                ],
                "properties": {
                    "placeUrl": {
                        "title": "Place URL",
                        "type": "string",
                        "description": "Google Maps URL of the business page to extract similar places from."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of similar places to extract (1-50).",
                        "default": 20
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ja",
                            "ko",
                            "zh",
                            "ar",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Language for the Google Maps interface (affects names/categories in some markets).",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy. Leave default; the scraper works from datacenter IPs without proxy. Used as fallback only."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```