# Google Maps Scraper - Phones, Websites & Ratings (`dataspace/google-maps-scraper`) Actor

Extract businesses from Google Maps: name, address, phone, website, rating, review count, opening hours, categories, coordinates and place ID. Big areas are split automatically to get past the 120-results limit. Free filters, no API key.

- **URL**: https://apify.com/dataspace/google-maps-scraper.md
- **Developed by:** [Dataspace](https://apify.com/dataspace) (community)
- **Categories:** Lead generation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.

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

Extract businesses from Google Maps in minutes: **name, category, address (street, city, postal code, state, country), phone, website, rating, review count, opening hours, coordinates, place ID** and more. Search any city, region or country — big areas are **split automatically**, so you are not stuck at the ~120 places Google shows for one search.

- ✅ **Gets past the 120-results limit** — enter a location and the area is searched piece by piece, center first
- ✅ **Free filters** — minimum rating, only places with / without a website, categories, skip closed places
- ✅ **Lead-friendly fields** — split address, international + plain phone number, website domain, "unclaimed on Google" flag
- ✅ **Fast and light** — no browser, results stream in from the first second
- ✅ **No duplicates** — a place found by several search terms is saved and charged once
- ✅ **Same input names as the popular Google Maps scrapers** — switching takes a minute
- ✅ **$1.50 per 1,000 places**, platform usage included

### What data do you get?

| Field | Example |
|---|---|
| `title`, `categoryName`, `categories` | Mozart's Coffee Roasters · Coffee shop · \[Coffee shop, Bakery, Cafe, …] |
| `address`, `street`, `city`, `postalCode`, `state`, `countryCode`, `neighborhood` | 3825 Lake Austin Blvd · Austin · 78703 · Texas · US |
| `phone`, `phoneUnformatted` | +1 512-477-2900 · +15124772900 |
| `website`, `domain` | https://mozartscoffee.com/ · mozartscoffee.com |
| `totalScore`, `reviewsCount` | 4.5 · 10946 |
| `priceLevel` | $10–20 — typical price per person, when Google shows one |
| `openingHours` | Monday 7 AM–12 AM, … |
| `location` | lat 30.2955, lng -97.7840 |
| `permanentlyClosed`, `temporarilyClosed` | false · false |
| `claimThisBusiness` | true when the owner has not claimed the listing on Google — a great sales signal |
| `description`, `additionalInfo` | Short Google description; accessibility, service options, amenities |
| `reserveTableUrl` | Booking link (restaurants), when Google shows one |
| `imageUrl`, `imagesCount` | Main photo and number of photos |
| `placeId`, `cid`, `fid`, `kgmid`, `url` | Stable IDs and a Google Maps link for every place |
| `searchString`, `rank`, `scrapedAt` | Which search found it, its position, and when |

The dataset has three ready-made views: **Places**, **Leads (contact info)** and **All fields**. Export to Excel, CSV, JSON, HTML or XML with one click.

### How to use

1. Enter one or more **search terms**, e.g. `dentist`, `coffee shop`, `car repair`.
2. Enter a **location**, e.g. `Austin, TX, USA`, `Berlin` or `Ontario, Canada`.
3. Set **Max places per search term** and, if you want, the free filters.
4. Click **Start**. Places appear in the table as they are found.

### Example input

```json
{
  "searchStringsArray": ["dentist", "orthodontist"],
  "locationQuery": "Chicago, IL, USA",
  "maxCrawledPlacesPerSearch": 500,
  "language": "en",
  "placeMinimumStars": "four",
  "website": "allPlaces",
  "skipClosedPlaces": true
}
```

### Example output (real result, shortened)

```json
{
  "title": "Mozart's Coffee Roasters",
  "categoryName": "Coffee shop",
  "categories": ["Coffee shop", "Bakery", "Cafe", "Event venue", "Tourist attraction"],
  "address": "3825 Lake Austin Blvd, Austin, TX 78703, United States",
  "street": "3825 Lake Austin Blvd",
  "city": "Austin",
  "postalCode": "78703",
  "state": "Texas",
  "countryCode": "US",
  "phone": "+1 512-477-2900",
  "phoneUnformatted": "+15124772900",
  "website": "https://mozartscoffee.com/",
  "domain": "mozartscoffee.com",
  "location": { "lat": 30.2954696, "lng": -97.7839512 },
  "totalScore": 4.5,
  "reviewsCount": 10946,
  "priceLevel": null,
  "permanentlyClosed": false,
  "temporarilyClosed": false,
  "claimThisBusiness": false,
  "openingHours": [{ "day": "Monday", "hours": "7 AM–12 AM" }, { "day": "Tuesday", "hours": "7 AM–12 AM" }],
  "additionalInfo": { "Accessibility": ["Wheelchair-accessible car park", "Wheelchair-accessible entrance"] },
  "placeId": "ChIJTWZhRFW1RIYRrdGa7DPzT7w",
  "cid": "13569331606629044653",
  "url": "https://www.google.com/maps/search/?api=1&query=Mozart%27s+Coffee+Roasters&query_place_id=ChIJTWZhRFW1RIYRrdGa7DPzT7w",
  "searchString": "coffee shop in Austin, TX, USA",
  "rank": 6
}
```

### Getting more than 120 places

Google Maps shows at most about 120 places for one search, however far you scroll. When you fill in **Location**, this scraper looks up the area on Google Maps and, whenever a part of the map still has more places, splits it into four smaller parts and searches each one. It starts in the center and works outwards, so a small limit gives you the most central places and a large limit covers the whole area.

If you put the place into the search term instead (`pizza in Chicago`) or use a Google Maps URL, you get the ~120 places Google shows for that search.

### Free filters

| Filter | What it does |
|---|---|
| Only these categories | Keeps places whose Google category contains one of your words, e.g. `dentist` |
| Minimum rating | 2 to 4.5 stars |
| Website | All places, only with a website, or **only without a website** (prospects for web agencies) |
| Skip closed places | Leaves out permanently and temporarily closed places |

Filters cost nothing extra: you only pay for places that are saved.

### Pricing

Pay per result: **$1.50 per 1,000 places**, plus a tiny start fee of $0.00005 per run. Platform usage (compute and proxies) is included — you are not charged anything else. Filters are free.

| Example | Cost |
|---|---|
| 200 dentists in one city | $0.30 |
| 5,000 restaurants across a state | $7.50 |
| 20,000 leads per month | $30 |

Set a maximum cost for a run and the Actor stops when it is reached.

### Use it via API

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("dataspace/google-maps-scraper").call(run_input={
    "searchStringsArray": ["plumber"],
    "locationQuery": "Manchester, UK",
    "maxCrawledPlacesPerSearch": 300,
})
for place in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(place["title"], place["phone"], place["website"])
```

JavaScript:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('dataspace/google-maps-scraper').call({
    searchStringsArray: ['plumber'],
    locationQuery: 'Manchester, UK',
    maxCrawledPlacesPerSearch: 300,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'places');
```

### Integrations and AI agents

- **Google Sheets, Excel, CSV** — export from the dataset or connect the Google Sheets integration.
- **Make, Zapier, n8n, webhooks** — start runs and receive results in your workflows.
- **AI agents (MCP)** — add this Actor as a tool through the Apify MCP server and let your agent search Google Maps.
- **Schedules** — run it daily or weekly to track new businesses in an area.

### Switching from another Google Maps scraper

The main input fields have the same names as in the most popular Google Maps scrapers: `searchStringsArray`, `locationQuery`, `maxCrawledPlacesPerSearch`, `language`, `categoryFilterWords`, `placeMinimumStars`, `website`, `skipClosedPlaces`. Most existing inputs work as they are, and output fields such as `title`, `totalScore`, `reviewsCount`, `placeId`, `phone`, `website`, `street`, `city` and `postalCode` use familiar names too.

### Tips

- Use specific terms: `vegan restaurant` returns more relevant places than `food`.
- Several related terms (`dentist`, `dental clinic`, `orthodontist`) find more businesses; duplicates are removed automatically.
- For a whole country, use one run per region or state — results stay focused and you can follow progress.
- Set **Language** to get categories and opening hours in that language.

### FAQ

**Is it legal to scrape Google Maps?** The Actor only collects publicly visible business information (names, addresses, phone numbers, websites, ratings) without logging in and without bypassing any CAPTCHA. It does not collect reviews, reviewer names, owner names or e-mail addresses. You are responsible for using the data in line with laws such as GDPR and with Google's terms — see the Disclaimer.

**Why did I get fewer places than my limit?** Google has fewer matching places in that area, or your filters removed some. Try more search terms or a larger area.

**Does it get e-mails or reviews?** No. It returns business data that Google Maps shows publicly. It does not collect reviews or personal data.

**How fast is it?** Usually a few hundred places per minute, depending on the area and Google's response time.

**Missing a feature?** Open an issue on the Issues tab — feedback is welcome.

### More scrapers by dataspace

- [Google Trends Scraper](https://apify.com/dataspace/google-trends-scraper) — interest over time, regions, related queries
- [Google News Scraper](https://apify.com/dataspace/google-news-scraper) — headlines by keyword, topic and country
- [Google Ads Transparency Scraper](https://apify.com/dataspace/google-ads-transparency-scraper) — competitors' Google ads
- [Google Hotels Scraper](https://apify.com/dataspace/google-hotels-scraper) — hotel prices and ratings
- [Google Flights Scraper](https://apify.com/dataspace/google-flights-scraper) — flight prices and schedules
- [AliExpress Search Scraper](https://apify.com/dataspace/aliexpress-search-scraper) — products, prices and sales

**Like it?** If this Actor saves you time, please leave a review on the Reviews tab — it helps others find it. Found a problem? Open an issue and it will be fixed quickly.

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google LLC. Google and Google Maps are trademarks of Google LLC and are mentioned only to describe the publicly available data source. It collects only publicly visible business information from Google Maps — without logging in, without solving CAPTCHAs and without collecting reviews, reviewer names, owner names or e-mail addresses. You are responsible for making sure that your use of the data complies with applicable laws (including data protection laws such as GDPR and anti-spam rules for marketing) and with Google's terms.

# Actor input Schema

## `searchStringsArray` (type: `array`):

What to search on Google Maps, one term per line, e.g. <code>restaurant</code>, <code>dentist</code>, <code>coffee shop</code>. You can also write the place into the term (<code>pizza in Chicago</code>), but then Google shows at most ~120 places — use the <b>Location</b> field below to get more.

## `locationQuery` (type: `string`):

City, region or country to search in, e.g. <code>Austin, TX, USA</code>, <code>Berlin</code>, <code>Manhattan, New York</code>. Big areas are split into smaller parts automatically, so you can get far more than the 120 places Google shows for one search.

## `maxCrawledPlacesPerSearch` (type: `integer`):

How many places to return for each search term. The same place is saved (and charged) only once per run, even if several terms find it.

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

Language of the results (categories, opening hours, descriptions) as a two-letter code, e.g. <code>en</code>, <code>de</code>, <code>es</code>, <code>fr</code>, <code>tr</code>.

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

Two-letter country code to search as a user from that country, e.g. <code>us</code>, <code>gb</code>, <code>de</code>. Usually not needed when you set a Location.

## `startUrls` (type: `array`):

Paste Google Maps search URLs, e.g. <code>https://www.google.com/maps/search/bakery/@51.5072,-0.1276,14z</code>. Each URL returns up to ~120 places from that map view.

## `categoryFilterWords` (type: `array`):

Keep only places whose Google category contains one of these words, e.g. <code>dentist</code> or <code>Italian restaurant</code>. Free filter — no extra charge.

## `placeMinimumStars` (type: `string`):

Keep only places with at least this Google rating. Free filter.

## `website` (type: `string`):

Keep all places, only places with a website, or only places without one (useful for web design and marketing agencies). Free filter.

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

Leave out places marked on Google Maps as permanently or temporarily closed. Free filter.

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

The scraper connects directly first and switches to a new proxy IP only if Google slows it down. The default works for most runs.

## Actor input object example

```json
{
  "searchStringsArray": [
    "coffee shop"
  ],
  "locationQuery": "Austin, TX, USA",
  "maxCrawledPlacesPerSearch": 20,
  "language": "en",
  "placeMinimumStars": "",
  "website": "allPlaces",
  "skipClosedPlaces": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per place: name, category, rating, review count, address, phone, website and Google Maps link.

## `leads` (type: `string`):

Contact-focused view: phone, website, address parts and whether the business is unclaimed on Google.

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

Every place with all fields, including opening hours, additional info, coordinates, place ID and CID.

# 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 = {
    "searchStringsArray": [
        "coffee shop"
    ],
    "locationQuery": "Austin, TX, USA",
    "maxCrawledPlacesPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspace/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 = {
    "searchStringsArray": ["coffee shop"],
    "locationQuery": "Austin, TX, USA",
    "maxCrawledPlacesPerSearch": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("dataspace/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 '{
  "searchStringsArray": [
    "coffee shop"
  ],
  "locationQuery": "Austin, TX, USA",
  "maxCrawledPlacesPerSearch": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call dataspace/google-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspace/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/MNOvpkV4L76SAA5CX/builds/vX2f0UAwMVegcvuva/openapi.json