# Google Maps Scraper: Every Place in an Area (`famed_bonobo/google-maps-scraper`) Actor

Google Maps places with phone, website, rating, hours, address and claim status, without a browser. Every place of a city or radius, not only the first 150, at about 10 requests a second.

- **URL**: https://apify.com/famed_bonobo/google-maps-scraper.md
- **Developed by:** [Axel Zúñiga](https://apify.com/famed_bonobo) (community)
- **Categories:** Lead generation, Marketing, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.28 / 1,000 places

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper

Get the places of [Google Maps](https://www.google.com/maps) as clean data: name, address split into parts, phone in international format, website, rating, reviews count, categories, opening hours in 24-hour time, coordinates, attributes and more. No browser, no login, no API key.

Two things set it apart:

- **Every place in an area, not only the first 150.** Google Maps shows only the most prominent places of a search and hides the rest. In *Every place in the area* mode the Actor cuts the area into cells, searches each one, and splits the busy ones again, until nothing new turns up. In a test on 3 km of central Chicago for "pizza" (about 100 places), one search found 41 of them, balanced depth found 96 and exhaustive depth found 100.
- **Fast and cheap.** The Actor talks to Google Maps' own search directly instead of driving a browser, at about 10 requests a second without being blocked. A top-results search returns 50 places in 3 requests. Covering a whole town takes minutes (300 restaurants of Golden, CO in 3 minutes). The price is $0.40 per 1,000 places.

### What you can use it for

- **Lead generation**: every dentist, plumber or restaurant of a city with phone and website, and a flag for the businesses nobody has claimed on Google (good prospects for local marketing and SEO services).
- **Market and competitor research**: how many pizzerias are in a neighborhood, how they rate, how many reviews they have, when they open.
- **Location analysis**: coordinates, distance from a point and opening hours for site selection, delivery areas and maps.
- **Directories and data products**: structured, deduplicated business listings by category and area.
- **AI agents and workflows**: fresh local business data on demand through the Apify API.

### What data you get

| Group | Fields |
|---|---|
| Identity | `name`, `placeId`, `fid`, `cid`, `kgmid`, `googleMapsUrl`, `categories`, `category`, `summary`, `description` |
| Address | `address`, `street`, `neighborhood`, `city`, `state`, `postalCode`, `countryCode`, `latitude`, `longitude`, `timezone` |
| Contact | `phone` (E.164), `phoneFormatted`, `website`, `domain`, `bookingUrls` |
| Reputation | `rating`, `reviewsCount` |
| Hours | `openingHours` with each weekday as text and 24-hour intervals, and `openStatusText` ("Closed · Opens 11 AM") |
| Status | `businessStatus` (`OPERATIONAL`, `CLOSED_PERMANENTLY`, `CLOSED_TEMPORARILY`), `isClaimed` |
| Attributes | `attributes` by group (accessibility and others) with a yes or no for each |
| Hotels | `hotel` with the nightly price Google shows, official star class, amenities and highlights |
| Details (optional) | `ratingDistribution` (reviews for each star), `reviewTopics` (what reviews mention most, with counts), `aboutText` (the business's own description), `popularTimes` (how busy each hour usually is) and `serviceHours` |
| Search | `searchString`, `searchLocation`, `searchRank`, `distanceKm` (circle areas), `scrapedAt` |

No personal data is collected: the Actor does not store reviewers, review authors or owner profiles.

### How to use it

1. Enter your **search terms**, such as `dentist` or `coffee shop`.
2. Enter the **places** to search, such as `Austin, TX`, or draw a **custom area** (a circle or a GeoJSON polygon).
3. Pick **How many places**: *Top results* for the first ~150 of each search in seconds, or *Every place in the area* for all of them.
4. Optionally filter by rating, reviews, website, phone, category, closed places and claim status.
5. Run it and download JSON, CSV, Excel or HTML, or read the results through the Apify API.

#### Input example: the best-rated pizzerias of a city

```json
{
  "searchTerms": ["pizza"],
  "locations": ["Austin, TX"],
  "maxPlacesPerSearch": 100,
  "minimumRating": 4.5,
  "onlyWithWebsite": true
}
```

#### Input example: every dentist within 5 km, unclaimed listings only

```json
{
  "searchTerms": ["dentist"],
  "coverage": "all",
  "searchDepth": "thorough",
  "maxPlacesPerSearch": 5000,
  "customGeolocation": {"type": "Point", "coordinates": [-97.7431, 30.2672], "radiusKm": 5},
  "claimStatus": "unclaimed"
}
```

### Output example

```json
{
  "name": "Giordano's",
  "placeId": "ChIJh3i0BqYsDogR6yp0y6TFlOQ",
  "category": "Pizza restaurant",
  "address": "130 E Randolph St, Chicago, IL 60601",
  "street": "130 E Randolph St",
  "neighborhood": "Chicago Loop",
  "city": "Chicago",
  "state": "Illinois",
  "postalCode": "60601",
  "countryCode": "US",
  "latitude": 41.8851301,
  "longitude": -87.6237612,
  "phone": "+13126161200",
  "website": "https://giordanos.com/locations/prudential-plaza-millennium-park/",
  "rating": 4.5,
  "reviewsCount": 26964,
  "businessStatus": "OPERATIONAL",
  "isClaimed": true,
  "openStatusText": "Closed · Opens 10:30 AM",
  "openingHours": [
    {"day": "Saturday", "weekday": 6, "isOpen": true, "hours": "10:30 AM–11 PM", "intervals": [{"opens": "10:30", "closes": "23:00"}]}
  ],
  "attributes": {"Accessibility": [{"name": "Wheelchair accessible entrance", "available": true}]},
  "searchString": "pizza",
  "searchRank": 1
}
```

### Search depth

*Every place in the area* needs a rule for when to search a cell again. **Search depth** sets it: a cell that returns at least 10 (quick), 5 (balanced), 3 (thorough) or 2 (exhaustive) places inside itself is split into four. Deeper finds more places and uses more requests; the price per place does not change. On 3 km of central Chicago for "pizza" the four depths found 91, 96, 99 and 100 of about 100 places, using 214, 547, 1,075 and 1,923 requests. In a 1.7 km circle of downtown Chicago, balanced and exhaustive both found the same 105 places, so balanced is the right default; raise the depth for dense areas or rare categories.

### Pricing

You pay per place stored ($0.40 per 1,000), with the Apify platform cost of the run included. Places that fail your filters are not stored and not charged. If you turn on **Add place details**, each place that gets its details costs $0.30 per 1,000 more; a place whose details cannot be fetched is stored and not charged for them. Volume discounts apply automatically with your Apify plan. See the pricing table above for the current prices.

### What to know

- **Relevance decides what Google returns.** A term such as "pizza" finds places Google considers matches, which may include a restaurant with pizza on its menu. Use the category filter to keep only the categories you want.
- **A place name finds the area Google shows for it.** In *Every place in the area* mode, "Chicago, IL" means the map view Google shows for Chicago, which reaches into the suburbs. For an exact boundary give a custom area.
- **Speed.** Top results take seconds. Covering an area runs at roughly 30 to 100 places a minute, depending on how dense the area is, with the default 1 GB of memory. The Actor needs that memory: the answers are large and parsing them is what limits speed.
- **Closed places** are skipped by default; turn the option off to keep them.
- **Place details** need one more call per place, so they take longer: a few places a second.
- **Not included:** review texts, photos and emails. Reviewer names and profiles are personal data and are never collected. The review topics and the star histogram give you what people say without any of them.
- **Opening hours** are the current week as Google shows it, in the language you choose.
- **Public data only.** This Actor collects business information that Google Maps shows to anyone.

### Legal

This Actor collects publicly available business data. You are responsible for using it in line with Google's terms and the laws that apply to you, including rules on contacting businesses.

# Actor input Schema

## `searchTerms` (type: `array`):

What to look for, as you would type it on Google Maps: "pizza", "dentist", "coffee shop", "hotel". Each term is searched in each place below. Up to 500 terms.

## `locations` (type: `array`):

Cities, regions or countries, written as on Google Maps: "Austin, TX", "Madrid, Spain", "Costa Rica". Leave empty to search without a place, or to use only the custom area below.

## `coverage` (type: `string`):

Top results gives the places Google ranks first for each search, about 150 at most, in seconds. Every place in the area cuts the area into cells and searches each one, so it finds every place the area holds, not only the most prominent (for example, every dentist in a city, not the first 150). Every place needs a place or a custom area.

## `maxPlacesPerSearch` (type: `integer`):

The search of one term in one place stops once it has this many places that pass your filters. You pay per place stored.

## `searchDepth` (type: `string`):

Only for "Every place in the area". Google hides the less prominent places of a busy cell, so the Actor splits busy cells into four and searches them again. Deeper finds more places and uses more requests: on 3 km of central Chicago, "quick" found 91 of about 100 pizzerias and "exhaustive" found all 100. Price per place stays the same.

## `includeDetails` (type: `boolean`):

For each place, one more call adds: the number of reviews for each star (1 to 5), what reviews talk about most (such as "deep dish pizza" with its mentions), the own description of the business, popular times by weekday and hour when Google shows them, and the hours of services such as an emergency room. Charged per place with details on top of the place price. Review texts and their authors are never collected.

## `customGeolocation` (type: `object`):

Search a precise area instead of, or besides, the places above. A GeoJSON Point with a radius in kilometres, {"type": "Point", "coordinates": \[-97.74, 30.27], "radiusKm": 5} (longitude first), or a GeoJSON Polygon or MultiPolygon. Only places inside the area are kept, and a circle adds each place's distance to its center.

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

Language of the texts Google writes, such as "en", "es" or "pt-BR": categories, descriptions and opening hours.

## `countryCode` (type: `string`):

Two-letter country code Google uses to rank results and to write local formats, such as "us", "gb" or "cr".

## `minimumRating` (type: `number`):

Keep only places rated at least this, from 0 to 5. Places with no rating fail a minimum above 0.

## `minimumReviews` (type: `integer`):

Keep only places with at least this many reviews.

## `onlyWithWebsite` (type: `boolean`):

Keep only places that list a website.

## `onlyWithPhone` (type: `boolean`):

Keep only places that list a phone number.

## `skipClosedPlaces` (type: `boolean`):

Leave out places Google marks as permanently or temporarily closed.

## `categoryFilter` (type: `array`):

Keep only places with a category that contains one of these words, such as "pizza" or "dentist". Case does not matter.

## `claimStatus` (type: `string`):

Unclaimed places are businesses nobody has taken over on Google Maps, which makes them good sales prospects for local marketing services. Any keeps both.

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

Leave Apify Proxy off for most runs: the Actor reaches Google Maps from the platform's own address at about ten requests a second. For very large area searches, proxies add addresses to spread the requests over.

## Actor input object example

```json
{
  "searchTerms": [
    "pizza"
  ],
  "locations": [
    "Austin, TX"
  ],
  "coverage": "top",
  "maxPlacesPerSearch": 20,
  "searchDepth": "balanced",
  "includeDetails": false,
  "language": "en",
  "countryCode": "us",
  "minimumRating": 0,
  "minimumReviews": 0,
  "onlyWithWebsite": false,
  "onlyWithPhone": false,
  "skipClosedPlaces": true,
  "categoryFilter": [],
  "claimStatus": "any",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "pizza"
    ],
    "locations": [
        "Austin, TX"
    ],
    "maxPlacesPerSearch": 20,
    "language": "en",
    "countryCode": "us",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchTerms": ["pizza"],
    "locations": ["Austin, TX"],
    "maxPlacesPerSearch": 20,
    "language": "en",
    "countryCode": "us",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("famed_bonobo/google-maps-scraper").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 '{
  "searchTerms": [
    "pizza"
  ],
  "locations": [
    "Austin, TX"
  ],
  "maxPlacesPerSearch": 20,
  "language": "en",
  "countryCode": "us",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call famed_bonobo/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

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/62wPG1jUoed2HSoES/builds/eZbfGbFy7p74srnpH/openapi.json