# Google Maps Place List Scraper (`crawlerbros/google-maps-place-list`) Actor

Extract ranked places from Google's curated Top lists ('Top hotels in Paris', 'Best coffee in Brooklyn', 'Things to do in Tokyo') or any Google Maps list URL.

- **URL**: https://apify.com/crawlerbros/google-maps-place-list.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, SEO tools, Automation
- **Stats:** 1 total users, 0 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 Place List Scraper

Extract ranked places from Google's curated **Top lists** on Google Maps - e.g. *Top hotels in Paris*, *Best coffee in Brooklyn*, *Things to do in Tokyo* - or from a direct Google Maps list / search URL.

### Features

- **Top list query mode** - type a curated query and get the ranked feed Google shows
- **Direct list URL mode** - paste any Google Maps list or search URL
- **Rank preserved** - each record carries the position it had in the feed
- **Highlights / amenities** - Pool, Spa, Free parking, etc. (when shown on the card)
- **Optional full enrichment** - fetches phone, website, full address, coordinates, place ID via the place page
- **No proxy required** - works from Apify free plan datacenter IPs
- **No cookies, no login**

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | enum (`topList` / `listUrl`) | Choose how to drive the run. Default `topList`. |
| `query` | string | The curated list query (required when `mode=topList`). |
| `listUrl` | string | A Google Maps list / search URL (required when `mode=listUrl`). |
| `maxResults` | integer (1-120) | Cap on number of records. Default 30. |
| `enrichDetails` | boolean | Visit each place page for full details. Default `true`. |
| `language` | enum | Interface language. Default `en`. |
| `proxyConfiguration` | proxy | Optional. Not required from Apify cloud. |

#### Example input

```json
{
  "mode": "topList",
  "query": "Top hotels in Paris",
  "maxResults": 10,
  "language": "en"
}
````

### Output (one record per place)

```json
{
  "listSource": "Top hotels in Paris",
  "rank": 1,
  "name": "Hôtel Le Bristol Paris",
  "categoryName": "5-star hotel",
  "totalScore": 4.7,
  "reviewsCount": 2891,
  "address": "112 Rue du Faubourg Saint-Honoré, 75008 Paris, France",
  "phone": "+33 1 53 43 43 00",
  "website": "https://www.oetkercollection.com/...",
  "priceLevel": "$$$$",
  "placeId": "0x...:0x...",
  "location": {"lat": 48.8718, "lng": 2.3163},
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "highlights": ["Pool", "Spa", "Restaurant"],
  "scrapedAt": "2026-06-16T08:00:00+00:00"
}
```

Empty / unavailable fields are omitted entirely - no `null` or `""` values appear in the dataset.

### Use cases

- Travel & hospitality research (top hotels, top restaurants per city)
- Local SEO competitor analysis
- Lead generation for hospitality / F\&B services
- Tourism content (things-to-do compilations)
- Market research for new locations

### FAQ

**Does it need cookies or an API key?** No. The scraper is fully self-contained.

**Will it work on the Apify free plan?** Yes - no proxy or paid feature is required.

**How many results can I get?** Up to ~120 per query (Google's own limit on a single search feed).

**Will the highlights match for every place?** No. Google only shows amenity pills on certain card types (notably hotels). Restaurants, cafés, and attractions usually have a short description instead.

**Does it support non-English Maps interfaces?** Yes - pick a `language` from the dropdown.

### 🗺️ 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 Nearby Scraper](https://apify.com/crawlerbros/google-maps-nearby) | Find places near a coordinate point - lightweight POI search by category |
| 🌍 [Google Maps Timezone Scraper](https://apify.com/crawlerbros/google-maps-timezone) | IANA timezone + current local time from coordinates |

# Actor input Schema

## `mode` (type: `string`):

Use 'topList' for a query like 'Top hotels in Paris' or 'Best coffee in Brooklyn'. Use 'listUrl' to scrape a specific Google Maps list/search URL.

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

Curated list query — e.g. 'Top hotels in Paris', 'Best Italian restaurants in Rome', 'Things to do in Tokyo'. Required when mode is 'topList'.

## `listUrl` (type: `string`):

A Google Maps list / search URL (e.g. https://www.google.com/maps/search/Top+hotels+in+Paris or a shareable list URL with !3e3). Required when mode is 'listUrl'.

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

Maximum number of places to return. Google Maps typically returns up to 120 results per query.

## `enrichDetails` (type: `boolean`):

If enabled, visits each place page to populate full details (placeId, phone, website, exact address, coordinates). Disables for faster runs that rely only on list-card data.

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

Language for Google Maps interface and results.

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

Optional proxy settings. The actor works reliably without a proxy from Apify cloud; enable proxy only if you hit rate limits.

## Actor input object example

```json
{
  "mode": "topList",
  "query": "Top hotels in Paris",
  "maxResults": 10,
  "enrichDetails": true,
  "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 = {
    "query": "Top hotels in Paris",
    "maxResults": 10,
    "enrichDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/google-maps-place-list").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "Top hotels in Paris",
    "maxResults": 10,
    "enrichDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-maps-place-list").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "Top hotels in Paris",
  "maxResults": 10,
  "enrichDetails": true
}' |
apify call crawlerbros/google-maps-place-list --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Place List Scraper",
        "description": "Extract ranked places from Google's curated Top lists ('Top hotels in Paris', 'Best coffee in Brooklyn', 'Things to do in Tokyo') or any Google Maps list URL.",
        "version": "0.2",
        "x-build-id": "CWgjgk0u3FbRkKjRg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~google-maps-place-list/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-google-maps-place-list",
                "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-place-list/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-google-maps-place-list",
                "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-place-list/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-google-maps-place-list",
                "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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "topList",
                            "listUrl"
                        ],
                        "type": "string",
                        "description": "Use 'topList' for a query like 'Top hotels in Paris' or 'Best coffee in Brooklyn'. Use 'listUrl' to scrape a specific Google Maps list/search URL.",
                        "default": "topList"
                    },
                    "query": {
                        "title": "Query (top list)",
                        "type": "string",
                        "description": "Curated list query — e.g. 'Top hotels in Paris', 'Best Italian restaurants in Rome', 'Things to do in Tokyo'. Required when mode is 'topList'."
                    },
                    "listUrl": {
                        "title": "List URL",
                        "type": "string",
                        "description": "A Google Maps list / search URL (e.g. https://www.google.com/maps/search/Top+hotels+in+Paris or a shareable list URL with !3e3). Required when mode is 'listUrl'."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum number of places to return. Google Maps typically returns up to 120 results per query.",
                        "default": 30
                    },
                    "enrichDetails": {
                        "title": "Fetch full place details",
                        "type": "boolean",
                        "description": "If enabled, visits each place page to populate full details (placeId, phone, website, exact address, coordinates). Disables for faster runs that rely only on list-card data.",
                        "default": true
                    },
                    "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. The actor works reliably without a proxy from Apify cloud; enable proxy only if you hit rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```