# Google Maps Full Suite — Places, Reviews & Grid Search (`0x_learner/google-maps-full-suite`) Actor

Scrape Google Maps places, full details, reviews, People Also Search For and directions in one Actor. Grid search bypasses Google's ~120-result cap for complete area coverage.

- **URL**: https://apify.com/0x\_learner/google-maps-full-suite.md
- **Developed by:** [0xlearner](https://apify.com/0x_learner) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 places scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Maps Full Suite — Places, Reviews, Distance, Grid Search & Lead Gen

![Google Maps Full Suite: places, reviews, People Also Search For, grid search and directions, with pay-per-event pricing](https://api.apify.com/v2/key-value-stores/JTWg2dEUVspkbdnw1/records/banner.png?signature=1d6PUEJ7TIaTElqpsGYYB)

One Actor for Google Maps **lead generation and competitive intelligence**: keyword search, **grid search that goes past Google's ~120-result cap**, nearby search, full place details, **reviews with owner responses**, **People Also Search For** (competitors Google shows next to a place) and A→B **directions**. Plain HTTP requests (a browser starts only for People Also Search For), so it's fast and you only pay for results.

### What can it do?

| Mode | What you get |
|---|---|
| **Search** | Every place matching a query in an area: name, category, rating, phone, website, address, coordinates, opening hours, photos |
| **Search + grid** | Same as search, but the area is split into a grid so you get **all** matching businesses, not just the first ~120 |
| **Nearby** | Places matching a query around an anchor (e.g. `cafe` near `Eiffel Tower`), optionally expanded 1–2 levels outwards |
| **Place details** | Full record for a list of places (Maps URLs, place IDs or names): review count, full weekly hours, price level, plus code, reviews, People Also Search For |
| **Directions** | Distance, duration, turn-by-turn steps and alternative routes for driving, walking or bicycling, plus a quick ETA for every mode |

#### Use cases

- **Lead generation**: every dentist, plumber or restaurant in a city, with phone and website
- **Competitor research**: ratings, review volume and review sentiment for every competitor in an area
- **Reputation monitoring**: newest or lowest-rated reviews, and whether the owner replied
- **Logistics**: distance and travel time between addresses

### Why use this Actor?

- **One Actor instead of five.** Search, grid search, nearby, place details, reviews, People Also Search For and directions share one input and one output format. There's no chaining of separate scrapers and no joining of mismatched outputs.
- **Complete coverage.** Grid search keeps going after Google stops at ~120 results, and deduplicates by place ID so each business appears once.
- **Data other scrapers don't return.** People Also Search For (the competitors Google itself links to a place) resolved to full place records; reviews with owner responses, Google's translations and structured dining attributes (food, service and atmosphere scores, price per person, wait time).
- **Stable IDs for joining.** Every place carries Google's place ID and knowledge-graph ID (`place_path`, `/g/…`), and every review has its own ID. Runs can be merged, deduplicated and linked across days, cities and datasets.
- **Fast and cheap.** Plain HTTP requests with browser-grade fingerprints. A browser starts only when you ask for People Also Search For.
- **Fair billing.** You pay per delivered result, never for results that didn't reach your dataset, and runs stop cleanly at your spending limit.

### AI and data use cases

The output is structured JSON with stable IDs, so it can go straight into AI pipelines:

- **Knowledge graphs.** Every People Also Search For list is a set of edges: *place A → people also search for → place B*. Collect them for a city or category and you get a graph of how customers see businesses as alternatives: competitor clusters, brand neighbourhoods, category boundaries. Load it into Neo4j, Memgraph or a graph library, and use it for **GraphRAG**, recommendations or market maps. A starter schema:
  - **Nodes:** places (`place_id`, `name`, `category`, `rating`, `coordinates`)
  - **Edges:** `PEOPLE_ALSO_SEARCH` (from each place to its `people_also_search` entries), `IN_CATEGORY`, `NEAR` (from coordinates), `REVIEWED_BY` (reviewer IDs)
- **Nexus and entity-resolution data.** Place IDs, knowledge-graph IDs, phone numbers, websites and addresses make good join keys. Use them to link Maps entities to your CRM, company registries or web data, and to build a clean nexus table of real-world locations.
- **Review intelligence with LLMs.** Feed reviews (with Google's translations for multilingual markets) to an LLM for sentiment and aspect analysis, complaint mining, or summaries of what customers praise. Structured dining attributes and owner responses give labelled signals for free.
- **RAG and AI agents.** Embed place descriptions and reviews into a vector database so an assistant can answer "best-rated late-night dentist near downtown" with real, cited data. Agents can also call the Actor on demand through Apify's MCP server and API.
- **Training and evaluation data.** Ratings, review text and attributes make datasets for classifiers, local-business models and evaluation sets.
- **Geospatial ML.** Coordinates, categories, opening hours, review volume and travel times (directions mode) become features for site selection, delivery-zone planning and footfall or demand models.
- **AI-powered lead generation.** Collect every business in a territory with grid search, then let an LLM score and personalise outreach using the place's reviews, rating trend and competitor set.

### Grid search: getting more than 120 results

Google Maps stops returning results after about **120 per search**, however large the map is. Zooming out doesn't help; only moving the map does. With **Enable grid search** the Actor:

1. Splits the circle around your location into square cells (`gridCellSizeKm`)
2. Searches each cell separately, **spiralling outwards from the centre** so dense downtown areas come first
3. Overlaps the cells so nothing between them is missed
4. **Deduplicates** by place ID across cells, and stops as soon as `maxResults` unique places are found

Example: *dentist in Austin, TX*, with 2 km cells over a 10 km radius and 25 cells, returned **211 unique dentists** where a single search stops at ~120.

| Area type | Suggested `gridCellSizeKm` |
|---|---|
| Dense city centre (Manhattan, central London) | 1 |
| Suburban metro area | 2 |
| Rural / sparse | 10 |

> ⚠️ **Grid search multiplies run cost.** 100 cells × up to 120 results = up to 12,000 raw results before deduplication, and each cell is billed as a `grid_cell_searched` event. Set `gridMaxCells` and `maxResults` deliberately.

### Reviews

With **Include reviews**, each place gets up to `maxReviewsPerPlace` reviews (up to 500), sorted by `newest`, `mostRelevant`, `highestRating` or `lowestRating`. Each review includes:

- rating, full text and **Google's translation** (with original language)
- exact publish date plus Google's relative date ("3 weeks ago"), and whether it was edited
- reviewer name, profile URL and ID, photo, review count, photo count, **Local Guide** status
- **owner response** and its date
- likes, review photos, review link
- structured dining attributes where the reviewer left them (price per person, food, service and atmosphere scores, wait time, parking, and so on)

### People Also Search For

With **Include People Also Search For**, each place gets the competitors and similar places Google lists under "People also search for": name, category, rating, review count, coordinates and thumbnail, resolved to full place IDs with address, phone and website (**Resolve every People Also Search For place**, on by default).

Signed-out visitors usually get a limited Google Maps view without this section. When the option is on, the Actor starts a real Chrome once per run and keeps opening fresh Google Maps sessions until Google grants the full view (typically a few tries, 30 s–2 min). That one session is then reused for every place. If no full-view session can be obtained, the run carries on and `people_also_search` comes back empty, with a warning in the log.

### Pricing (pay per event)

You pay only for what the Actor delivers:

| Event | Charged when | Price | Per 1,000 |
|---|---|---|---|
| `place_scraped` | each place in the dataset | $0.002 | $2.00 |
| `review_scraped` | each review attached to a place | $0.0005 | $0.50 |
| `pas_place_scraped` | each People Also Search For place attached to a place | $0.003 | $3.00 |
| `grid_cell_searched` | each grid cell searched | $0.003 | $3.00 |
| `route_scraped` | each directions result | $0.005 | $5.00 |

There's also a small start fee of **$0.001 per run** for each GB of run memory (Apify's standard Actor start event). A normal 1 GB run pays $0.001; a 2 GB run with People Also Search For pays $0.002.

The Actor stops cleanly when your spending limit is reached. Items are pushed and charged together, so you're never billed for an item that wasn't delivered.

### Input examples

**All dentists in Austin (grid)**

```json
{
  "mode": "search",
  "searchQuery": "dentist",
  "location": "Austin, TX",
  "enableGridSearch": true,
  "gridCellSizeKm": 2,
  "gridSearchRadiusKm": 10,
  "gridMaxCells": 25,
  "maxResults": 1000
}
```

**Details and newest reviews for specific places**

```json
{
  "mode": "placeDetails",
  "places": [
    "https://www.google.com/maps/place/...",
    "0x8644b5b434046875:0x644e6eb422388b7a",
    "Swish Dental Downtown Austin"
  ],
  "includeReviews": true,
  "maxReviewsPerPlace": 100,
  "reviewsSort": "newest"
}
```

**Walking directions**

```json
{ "mode": "directions", "origin": "Times Square, New York", "destination": "Central Park, New York", "travelMode": "walking" }
```

### Output example (search)

```json
{
  "place_id": "0x8644b5b434046875:0x644e6eb422388b7a",
  "name": "Swish Dental Downtown",
  "category": "Dentist",
  "categories": ["Dentist", "Cosmetic dentist", "Emergency dental service"],
  "address": "201 W 5th St Ste 175, Austin, TX 78701, United States",
  "coordinates": { "lat": 30.2674035, "lng": -97.7451433 },
  "rating": 4.5,
  "review_count": 983,
  "phone": "+1 512-713-1099",
  "website": "https://www.swishsmiles.com/location/downtown",
  "opening_hours": { "schedule": { "monday": ["9 AM-6 PM"], "saturday": ["Closed"] }, "complete": true },
  "maps_url": "https://www.google.com/maps/search/?api=1&query=Swish+Dental+Downtown&query_place_id=0x8644b5b434046875:0x644e6eb422388b7a",
  "sourceQuery": "dentist",
  "searchTaskLabel": "dentist | Austin, TX",
  "gridCell": "30.26715,-97.74306"
}
```

`gridCell` and `sourceQuery` show which grid cell and query found each place.

### Tips and limitations

- **Use residential proxies** (the default). Google rate-limits by IP, and the Actor switches IP and browser fingerprint automatically when it's blocked.
- **Review count and full weekly hours** come from Google's full place record. In search mode, turn on **Scrape full details for each result** to get them for every place (one extra request per place).
- **People Also Search For** adds a one-time browser warm-up to the run and one extra request per place (plus one per People Also Search For place when resolving). Give the run at least 2 GB of memory when using it.
- **Transit directions** aren't available yet. Driving, walking and bicycling are.
- The Actor only collects publicly visible data. You're responsible for using it in line with applicable laws and Google's terms.

# Actor input Schema

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

What to scrape. <b>search</b>: keyword search (optionally grid-split). <b>nearby</b>: places matching a query around an anchor place. <b>placeDetails</b>: full details for a list of places. <b>directions</b>: route from A to B.

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

Used in search and nearby modes, e.g. <code>dentist</code>.

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

Search area as text (<code>Austin, TX</code>) or <code>lat,lng</code>. Required for grid search.

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

Maximum number of places to output (after deduplication and filters).

## `nearbyAnchor` (type: `string`):

Nearby mode: the place to search around, e.g. <code>Eiffel Tower</code>.

## `nearbyDepth` (type: `integer`):

Nearby mode: 0 = around the anchor only. 1–2 = repeat the nearby search around every result (much wider coverage, more requests).

## `scrapePlaceDetails` (type: `boolean`):

Search/nearby modes: fetch the full place record for every result (full weekly hours, review count). One extra request per place.

## `enableGridSearch` (type: `boolean`):

Split the area into a grid and search each cell separately. Results are deduplicated by place ID across cells. <b>Multiplies run cost</b> — see gridMaxCells.

## `gridCellSizeKm` (type: `number`):

Smaller = more thorough but slower. ~1 km for dense city centres, 2 km for suburbs, 10 km for rural areas.

## `gridSearchRadiusKm` (type: `number`):

Radius around the location to cover with the grid.

## `gridMaxCells` (type: `integer`):

Hard cap on cells searched. 100 cells × up to 120 hits = up to 12,000 raw results before deduplication.

## `places` (type: `array`):

Place details mode: one per line — a Google Maps URL, a place ID (<code>0x…:0x…</code>) or a place name (<code>Kababjees Do Darya Karachi</code>).

## `placeId` (type: `string`):

Alternative to Places for a single place ID (<code>0x…:0x…</code>).

## `placeLat` (type: `number`):

Optional coordinates for Place ID.

## `placeLng` (type: `number`):

Optional coordinates for Place ID.

## `includeReviews` (type: `boolean`):

Attach reviews to each place (text, translation, rating, reviewer, photos, likes, dining attributes).

## `maxReviewsPerPlace` (type: `integer`):

Maximum reviews to attach to each place (10 per request).

## `reviewsSort` (type: `string`):

Order in which reviews are collected.

## `includePeopleAlsoSearch` (type: `boolean`):

Attach Google's 'People also search for' places (competitors / similar places). Starts a real Chrome once per run to open a Google Maps session that Google grants the full view (adds ~30 s–2 min to the run); the session is then reused for every place.

## `maxPeopleAlsoSearch` (type: `integer`):

Maximum 'People also search for' places per place.

## `resolvePeopleAlsoSearch` (type: `boolean`):

Google embeds only short IDs (and details for the first few). Resolve every PAS place to its full place ID, address, phone and website (one extra request per PAS place).

## `origin` (type: `string`):

Directions mode: start address or place.

## `destination` (type: `string`):

Directions mode: destination address or place.

## `travelMode` (type: `string`):

Directions mode: how to travel between origin and destination.

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

Only output places rated at least this value.

## `requirePhone` (type: `boolean`):

Only output places that list a phone number.

## `requireWebsite` (type: `boolean`):

Only output places that list a website.

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

Google interface language code, e.g. <code>en</code>, <code>de</code>.

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

Residential proxies are strongly recommended — Google rate-limits by IP.

## `debug` (type: `boolean`):

Save diagnostics (e.g. People Also Search For warm-up screenshots) to the run's key-value store.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "dentist",
  "location": "Austin, TX",
  "maxResults": 100,
  "nearbyDepth": 0,
  "scrapePlaceDetails": false,
  "enableGridSearch": false,
  "gridCellSizeKm": 2,
  "gridSearchRadiusKm": 20,
  "gridMaxCells": 100,
  "includeReviews": false,
  "maxReviewsPerPlace": 20,
  "reviewsSort": "newest",
  "includePeopleAlsoSearch": false,
  "maxPeopleAlsoSearch": 10,
  "resolvePeopleAlsoSearch": true,
  "travelMode": "driving",
  "requirePhone": false,
  "requireWebsite": false,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debug": false
}
```

# Actor output Schema

## `places` (type: `string`):

One row per place: name, category, rating, review count, address, phone, website, Google Maps URL, and the grid cell and query that found it.

## `contacts` (type: `string`):

Contact fields for lead generation: name, category, phone, website, address, rating, review count and place ID.

## `reviews` (type: `string`):

One row per review (when Include reviews is on): rating, text, translation, dates, reviewer, owner response, likes, photos and dining attributes.

## `directions` (type: `string`):

Directions mode: origin, destination, travel mode, distance, duration and route summary; steps and per-mode ETAs are in All fields.

## `allFields` (type: `string`):

Every field of every item, including opening hours, photos, full reviews, People Also Search For places and turn-by-turn steps.

# 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 = {
    "searchQuery": "dentist",
    "location": "Austin, TX",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("0x_learner/google-maps-full-suite").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 = {
    "searchQuery": "dentist",
    "location": "Austin, TX",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("0x_learner/google-maps-full-suite").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQuery": "dentist",
  "location": "Austin, TX",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call 0x_learner/google-maps-full-suite --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,0x_learner/google-maps-full-suite"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/uLQGJr6LCltEpRBmX/builds/ma19OoEyiiubsqXKB/openapi.json