# Google Maps Scraper (`scrapingdino/google-maps-scraper`) Actor

Scrape data from thousands of Google Maps businesses and places, including reviews, reviewer profiles, photos, contact details, names, emails, job titles, business hours, pricing, and more. Export results, automate via API, schedule runs, monitor progress, or connect with your favorite tools.

- **URL**: https://apify.com/scrapingdino/google-maps-scraper.md
- **Developed by:** [Scraping Dino](https://apify.com/scrapingdino) (community)
- **Categories:** Automation, 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 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper

**Find Google Maps businesses and export structured place data — contacts, hours, photos, reviews, and posts — in one run.**

This actor turns Google Maps discovery into clean dataset records. Search by keyword, location, coordinates, or place ID; optionally enrich each business with full details, photo galleries, customer reviews, and Google Business Profile posts. Every place is emitted once, with enrichments merged into a single object ready for CRM import, research, or automation.

- Discover places with keyword, nearby, radius, bounding-box, area, or bulk search
- Enrich each business with phone, website, address, hours, categories, and more
- Pull photo/video galleries, reviews (with sort and caps), and owner posts
- Filter by rating, category, and closed status before you pay for enrichment
- Deduplicate automatically and stream results into the Apify dataset as they finish

***

### Why use this actor?

Google Maps is where local demand lives. This actor is built for teams that need that data in a pipeline — not a spreadsheet copy-paste.

**Lead generation**\
Build lists of restaurants, clinics, contractors, or retailers in a city or radius. Export phone, website, address, and Maps URL into your CRM or outreach tool.

**Competitor analysis**\
Pull ratings, review text, star distributions, and owner replies for businesses in your category. Compare review volume and sentiment across neighborhoods.

**Market research**\
Map density of a category across bounding boxes or named areas. Track price levels, categories, and open/closed status at scale.

**Brand and reputation monitoring**\
Watch reviews and Google posts for specific place IDs or Maps URLs on a schedule. Catch new complaints and owner responses early.

**Local SEO and listing audits**\
Verify NAP consistency (name, address, phone), websites, categories, and hours across many listings in one export.

**Growth and territory planning**\
Use nearby/radius search around store locations to size markets and spot gaps before you expand.

***

### Features

#### Search

- **Keyword search** — one or many terms plus an optional location (`"pizza"` in `"Manhattan"`)
- **Nearby search** — keyword around a lat/lng point
- **Radius search** — keyword within a meter radius of coordinates
- **Bounding box** — constrain results to north/south/east/west bounds
- **Area search** — keyword inside a named area
- **Bulk search** — submit multiple queries in one request
- **Language and country** — control response locale for keyword/bulk modes
- **Direct targets** — skip search and enrich known `placeIds` or Google Maps URLs

#### Place details

- Full business profile fields: name, description, categories, rating, review count
- Contact: phone, website, domain, Maps URL
- Location: street, neighborhood, city, state, country, postal code, lat/lng
- Hours, holiday hours, opening status
- Amenities, accessibility, parking, payments, service options (when present)
- Booking, order, menu, and reservation links when Google exposes them
- Owner metadata and star rating distribution

#### Photos

- Paginated photo/video gallery per place
- Cap with `maxPhotosPerPlace` / `maxImages` (up to 500)
- Structured media fields: URLs, type, upload time, coordinates when available
- Attached as `photos` without overwriting details sample images

#### Reviews

- Paginated reviews per place (up to 5,000 per business via `maxReviewsPerPlace`)
- Sort: newest, highest rating, lowest rating, most relevant
- Optional reviews language (falls back to actor language)
- Author profile, Local Guide flags, ratings, text, photos, likes
- Owner replies and detailed review form scores when available
- Deduplicated by review ID

#### Posts

- Google Business Profile posts (owner updates)
- Cap with `maxPosts` (up to 500)
- Post text, images, publish time, and post URL
- Empty galleries are valid (many places simply have no posts)

#### Filtering

- Minimum star rating (`placeMinimumStars`)
- Skip closed / permanently closed places
- Category substring filter during search (`businessCategory`)
- Post-search category keyword filters (`categoryFilterWords`)

#### Pagination and reliability

- Cursor pagination for search, photos, and reviews until your caps are hit
- API-level retries with backoff on 429 and 5xx
- Per-business enrichment retries (`maxRequestRetries`)
- Parallel enrichment (`maxConcurrency`, default 5)
- Search continues if one term fails; enrichment failures land in `enrichmentErrors` without dropping the place

#### Export

- One dataset item per business
- Download as JSON, CSV, Excel, or XML from Apify
- Access via Apify API, webhooks, or integrations (Make, Zapier, n8n, etc.)

***

### What can it scrape?

Each dataset item is **one business**. Search fields form the base; optional enrichments merge into the same record.

#### Identity and discovery

Place ID, business/Google ID, CID, name, categories, Maps URL, thumbnail/cover image, open/closed status.

#### Contact and location

Phone, website, domain, full address broken into street / city / state / country / postal code, plus latitude and longitude.

#### Reputation

Overall rating, total review count, and star distribution (1–5). With reviews enabled: full review objects including author, text, rating, photos, and owner replies.

#### Operations

Weekly opening hours, current opening status, price level, amenities and related “about” sections when the details API returns them.

#### Media and updates

- **Photos** — gallery array (`photos`, `photosCount`)
- **Posts** — owner update array (`posts`, `postsCount`)
- Search/details still keep sample image fields (`photosSample`, `imagesCount`) separately

#### Diagnostics

If an enrichment step fails after retries, the place is still saved and the error is listed under `enrichmentErrors`.

**Note:** Fields such as Popular Times may appear as `null`. They are reserved for schema compatibility and are not populated by the current data source.

***

### Input Options

#### How to discover places

| Goal | Use |
|---|---|
| “Coffee shops in Austin” style lists | `searchStringsArray` + `locationQuery` |
| Several categories in one city | Multiple `searchStringsArray` terms |
| Around a pin / store | `searchMode: "nearby"` or `"radius"` + lat/lng |
| A map rectangle | `searchMode: "boundingBox"` + north/south/east/west |
| Named district | `searchMode: "area"` + `area` or `locationQuery` |
| Many free-form queries | `searchMode: "bulk"` + `queries` |
| You already have IDs | `placeIds` (and optional enrichment toggles) |
| You have Maps links | `startUrls` (prefer Place IDs for full gallery enrichment) |

#### Caps and quality

- `maxResults` / `maxCrawledPlacesPerSearch` — how many places per search (1–500, default 50)
- `placeMinimumStars` — drop low-rated listings before enrichment
- `skipClosedPlaces` — keep only operating businesses
- `businessCategory` / `categoryFilterWords` — tighten category match

#### Enrichment toggles

| Toggle | Effect |
|---|---|
| `scrapePlaceDetailPage` | Merge full business details into each place |
| `scrapePhotos` or `maxPhotosPerPlace` > 0 | Attach gallery under `photos` |
| `scrapeReviews` or `maxReviewsPerPlace` > 0 | Attach reviews under `reviews` |
| `scrapePosts` | Attach posts under `posts` |

Photos and reviews can be enabled by setting their max values above zero. Posts require `scrapePosts: true`.

#### Runtime

- `maxConcurrency` (1–50, default 5) — parallel enrichment workers; search terms still run one after another
- `maxRequestRetries` (default 3) — retries per enrichment step per business

***

### Example Input

#### Keyword search (list building)

```json
{
  "searchStringsArray": ["dentist", "dental clinic"],
  "locationQuery": "Austin, TX",
  "maxResults": "50",
  "country": "US",
  "language": "en",
  "placeMinimumStars": "4.0",
  "skipClosedPlaces": true
}
```

#### Search + full enrichment

```json
{
  "searchStringsArray": ["pizza"],
  "locationQuery": "Manhattan, New York",
  "maxResults": "20",
  "country": "US",
  "scrapePlaceDetailPage": true,
  "scrapePhotos": true,
  "maxPhotosPerPlace": 15,
  "scrapeReviews": true,
  "maxReviewsPerPlace": 50,
  "reviewsSort": "newest",
  "scrapePosts": true,
  "maxPosts": 10,
  "maxConcurrency": 5
}
```

#### Nearby / radius (around a point)

```json
{
  "searchMode": "nearby",
  "query": "coffee",
  "latitude": 40.758,
  "longitude": -73.9855,
  "radius": 1500,
  "maxResults": "40",
  "scrapePlaceDetailPage": true
}
```

#### Bounding box

```json
{
  "searchMode": "boundingBox",
  "query": "gym",
  "north": 40.78,
  "south": 40.74,
  "east": -73.96,
  "west": -74.01,
  "maxResults": "30"
}
```

#### Bulk queries

```json
{
  "searchMode": "bulk",
  "queries": [
    "plumbers in Denver",
    "electricians in Denver",
    "HVAC in Denver"
  ],
  "maxResults": "25",
  "country": "US",
  "scrapePlaceDetailPage": true
}
```

#### Place IDs only (enrich known businesses)

```json
{
  "placeIds": [
    "ChIJifIePKtZwokRVZ-UdRGkZzs",
    "0x89c259ab3c1ef289:0x3b67a41175949f55"
  ],
  "scrapePlaceDetailPage": true,
  "scrapeReviews": true,
  "maxReviewsPerPlace": 100,
  "reviewsSort": "highest_rating",
  "scrapePhotos": true,
  "maxPhotosPerPlace": 30,
  "scrapePosts": true
}
```

***

### Example Output

One dataset item (fields truncated for readability):

```json
{
  "name": "Joe's Pizza Broadway",
  "placeId": "ChIJifIePKtZwokRVZ-UdRGkZzs",
  "businessId": "0x89c259ab3c1ef289:0x3b67a41175949f55",
  "category": "Pizza restaurant",
  "categories": ["Pizza restaurant", "Pizza delivery", "Restaurant"],
  "rating": 4.4,
  "reviewCount": 26343,
  "reviewsDistribution": {
    "oneStar": 812,
    "twoStar": 541,
    "threeStar": 1488,
    "fourStar": 5900,
    "fiveStar": 17602
  },
  "phone": "+16465594878",
  "website": "https://www.joespizzanyc.com/",
  "address": "1435 Broadway, New York, NY 10018",
  "city": "New York",
  "postalCode": "10018",
  "latitude": 40.7546795,
  "longitude": -73.9870291,
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "businessStatus": "OPEN",
  "openingHours": {
    "Monday": ["10 AM–3 AM"],
    "Friday": ["10 AM–5 AM"]
  },
  "detailsFetched": true,
  "photosFetched": true,
  "photosCount": 15,
  "photos": [
    {
      "photoId": "CIABIhBrIKF-fvEFDBYqhnU28VTF",
      "mediaType": "photo",
      "imageUrl": "https://lh3.googleusercontent.com/...",
      "imageUrlLarge": "https://lh3.googleusercontent.com/..."
    }
  ],
  "reviewsCountFetched": 50,
  "reviews": [
    {
      "reviewId": "Ci9DQUlRQUNvZENodHljRjlv...",
      "authorName": "Amartya Ghosal",
      "rating": 4,
      "reviewText": "We tried this iconic NY pizza spot...",
      "publishedAt": "2026-07-02T21:16:46.819Z",
      "authorIsLocalGuide": true
    }
  ],
  "postsCount": 0,
  "posts": []
}
```

***

### Common Workflows

#### Build a lead list for a city

1. Set `searchStringsArray` to your niche and `locationQuery` to the city.
2. Enable `skipClosedPlaces` and a minimum star rating.
3. Turn on `scrapePlaceDetailPage` for phone and website.
4. Export CSV into your CRM.

#### Monitor competitors’ reputation

1. Feed known `placeIds`.
2. Enable reviews with `reviewsSort: "newest"` and a weekly schedule.
3. Diff new `reviewId`s in your warehouse.

#### Map a trade area around a store

1. Use `searchMode: "radius"` with store coordinates.
2. Collect categories and ratings only (search or light details).
3. Visualize density in your BI tool.

#### Content and listing QA

1. Search or use place IDs.
2. Enable photos + posts to audit visual freshness and owner updates.
3. Flag listings with missing website, phone, or hours.

#### Multi-category market scan

1. Use bulk mode with several “{category} in {city}” queries.
2. Deduplication collapses overlapping hits into one row per business.
3. Segment the export by `category`.

***

### Performance

| Concern | Behavior |
|---|---|
| **Pagination** | Search, photos, and reviews follow API cursors until your max counts |
| **Concurrency** | Enrichment runs in parallel (`maxConcurrency`); search terms are sequential |
| **Retries** | HTTP client retries 429/5xx with backoff; enrichment steps retry per business |
| **Reliability** | Failed enrichment does not drop the place; errors go to `enrichmentErrors` |
| **Rate limits** | Upstream API may throttle; retries handle transient limits |

**Typical latency (live validation, small caps):** about 2–3s per search page, ~2s details, ~1.5–2s for a short photos or reviews page, ~1.5s posts. A single place with search + details + photos + reviews + posts often completes in under ~10 seconds wall time.

**Rough full-enrichment estimates** (`maxConcurrency: 5`, modest photo/review caps):

| Places | Typical wall time |
|---|---|
| 10 | ~20–30 seconds |
| 100 | ~4–6 minutes |
| 1,000 | ~35–50 minutes |

Higher `maxReviewsPerPlace` / `maxPhotosPerPlace` increases runtime roughly with extra pages. Search-only runs are much faster.

***

### Output

Results are stored in the **default Apify dataset**:

- View and filter in the Apify Console
- Download **JSON**, **CSV**, **Excel**, or **XML**
- Read via the **Apify API** (`dataset` endpoints) or client SDKs
- Connect to **integrations** (Make, Zapier, n8n, webhooks, Google Sheets, warehouses)

Each successful place is one item. There is no second “reviews-only” dataset — reviews and posts live on the same business object when enabled.

***

### Limitations

Be aware of these constraints before you run production jobs:

- **No browser automation** — this actor uses HTTP APIs, not a headless Maps browser. Features that only exist in the Maps UI (for example Popular Times histograms, Q\&A, mall directories, sponsored/ad flags, hotel-only modules) are not scraped.
- **Popular Times** — field may be present as `null`; it is not filled by the current provider.
- **Photo authors** — gallery items do not include uploader/author identity.
- **Posts availability** — many businesses have zero posts; an empty `posts` array is normal.
- **Direct Google Maps URLs** — details enrichment can work from URLs, but photo/review/post galleries resolve best when a place ID or business ID is already known. Prefer `placeIds` for ID-based enrichment.
- **Bulk search** — single-response mode without cursor pagination; use keyword mode with multiple terms when you need deep paging.
- **Closed or missing places** — invalid IDs may produce enrichment errors; the row can still appear with `enrichmentErrors` populated.
- **Upstream rate limits** — heavy concurrency or large review caps may slow runs; lower concurrency or batch by city if you see repeated retries.
- **Not a leads/email-verification product** — you get Maps listing data (phone/website when public on the listing). There is no people-leads, email-verify, or AI competitor-report module.

***

### FAQ

**Can I scrape multiple search terms in one run?**\
Yes. Pass several values in `searchStringsArray`, or use bulk mode with `queries`.

**Can I enrich places I already know?**\
Yes. Provide `placeIds` (Place IDs or hex business IDs) and enable the enrichment toggles you need.

**Can I export to CSV or Excel?**\
Yes. Use the dataset export in Apify Console or the API. CSV works well for flat contact fields; nested `reviews` / `photos` arrays are richer in JSON.

**How many places can I collect?**\
Up to 500 per search term via `maxResults` / `maxCrawledPlacesPerSearch`. Run multiple terms or schedules for larger markets.

**How many reviews can I collect per place?**\
Up to 5,000 via `maxReviewsPerPlace` / `maxReviews`. Start lower for cost and speed, then raise for deep analysis.

**What happens if reviews or photos fail for one business?**\
The place is still saved. The failure is recorded in `enrichmentErrors`. Other businesses continue.

**What if a search term returns nothing?**\
That term contributes zero places. Other terms still run. An empty dataset means no matches after search and filters.

**Can I skip closed businesses?**\
Yes — set `skipClosedPlaces: true`.

**Can I sort reviews?**\
Yes — `reviewsSort`: `newest`, `highest_rating`, `lowest_rating`, or `most_relevant`.

**Do I get one row per review?**\
No. By design you get **one row per business**, with reviews nested under `reviews`. That keeps lead lists and CRM imports clean.

**Can I resume a failed run?**\
Apify may resurrect runs depending on platform settings; this actor does not implement custom checkpoint resume. Prefer smaller batches and schedules for very large jobs, and rely on place-ID dedupe across runs if you re-scrape.

**Is Popular Times included?**\
Not with live data today. The field stays null when the provider does not return it.

***

### Best Practices

1. **Filter early** — use `placeMinimumStars`, `skipClosedPlaces`, and category filters before enabling heavy review/photo caps.
2. **Start small** — validate with `maxResults: 10` and modest `maxReviewsPerPlace` / `maxPhotosPerPlace`, then scale.
3. **Use Place IDs for monitoring** — search once, store IDs, then enrich on a schedule without rediscovering.
4. **Tune concurrency** — default `5` is a solid balance. Raise carefully (up to 50) for large enrichment jobs; lower if you see throttling.
5. **Don’t over-fetch media** — photos and reviews dominate cost and time. Cap them to what your workflow actually needs.
6. **Prefer keyword + location for deep lists** — use bulk for breadth; use keyword pagination when you need more results per query.
7. **Plan large jobs by city** — split national coverage into regional runs for clearer cost control and easier retries.
8. **Keep JSON for nested data** — export CSV for outreach columns; keep JSON when you need full `reviews` and `photos`.

***

### Why choose this actor?

**One business, one record**\
Search, details, photos, reviews, and posts merge into a single structured object — ready for CRMs and warehouses without stitching multiple actors.

**Practical Maps coverage**\
The workflows teams actually run: find places, get contacts, pull reviews and media. No browser farm required.

**Controlled cost**\
Enrichment is opt-in. Search and filter first; only then pay for details, galleries, and review depth.

**Built for Apify**\
Incremental dataset writes, Console exports, API access, and scheduler-friendly inputs.

**Transparent limits**\
Clear about what the API can and cannot return — so you can design pipelines that hold up in production.

***

### Getting started

1. Open this actor on Apify and click **Try for free** (or run locally with your API key).
2. Paste a keyword + location example from above.
3. Enable the enrichments you need.
4. Run and open the **Dataset** tab.

For local development:

```bash
cd google-maps-scraper
cp .env.example .env   # set API_KEY
npm install
npm start
```

***

### Support

Questions, edge cases, or feature requests: open an issue on the actor’s Apify page or contact the developer through Apify.

If this actor saves you time, a rating on the Apify Store helps others find it.

# Actor input Schema

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

Paste Google Maps place links when you already know which businesses to scrape. Skips search — each URL is enriched with details, photos, reviews, and posts based on the toggles below. Prefer Place IDs when you have them for the most reliable gallery enrichment.

## `placeIds` (type: `array`):

Google Place IDs (ChIJ…) or hex business IDs. Best option when monitoring known listings on a schedule.

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

One or more search terms. Combined with Location as "{term} in {location}" for keyword mode.

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

Geographic focus for keyword searches (e.g. New York, USA).

## `searchMode` (type: `string`):

How places are discovered.

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

Single search query for nearby/radius/bbox/area/keyword modes. Prefer searchStringsArray for multi-term keyword search.

## `maxResults` (type: `string`):

Max places per search (alias of Max places per search).

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

Maximum businesses to collect per search term (same cap as maxResults).

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

Language code for API responses (e.g. en).

## `country` (type: `string`):

Country code for keyword or bulk search.

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

Alias of Country.

## `businessCategory` (type: `string`):

Optional substring filter on category/categories.

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

Optional post-search category keyword filters.

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

Drop places with rating below this threshold (e.g. "4.0").

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

Exclude places with closed businessStatus / closed flags.

## `area` (type: `string`):

Named area for area search mode.

## `radius` (type: `integer`):

Radius in meters for nearby/radius modes.

## `latitude` (type: `number`):

Latitude for nearby or radius search.

## `longitude` (type: `number`):

Longitude for nearby or radius search.

## `north` (type: `number`):

North latitude for bounding box search.

## `south` (type: `number`):

South latitude for bounding box search.

## `east` (type: `number`):

East longitude for bounding box search.

## `west` (type: `number`):

West longitude for bounding box search.

## `queries` (type: `array`):

Multiple search queries for bulk mode.

## `scrapePlaceDetailPage` (type: `boolean`):

Fetch full business details for each place and merge into the record (phone, website, hours, amenities, and more).

## `scrapePhotos` (type: `boolean`):

Fetch the business photo/video gallery and attach as `photos` on each place record.

## `maxPhotosPerPlace` (type: `integer`):

Maximum gallery items per business when scrapePhotos is enabled (also enables photos when > 0). Alias: maxImages.

## `maxImages` (type: `integer`):

Alias of Max photos per place.

## `scrapeReviews` (type: `boolean`):

Fetch business reviews and attach as `reviews` on each place record. Also enabled when maxReviewsPerPlace / maxReviews > 0.

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

Maximum reviews per business when reviews are enabled (also enables reviews when > 0). Alias: maxReviews.

## `maxReviews` (type: `integer`):

Alias of Max reviews per place.

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

Sort order sent as sort\_by to the Business Reviews API.

## `reviewsLanguage` (type: `string`):

Optional language for reviews requests. Falls back to the actor language input when unset.

## `scrapePosts` (type: `boolean`):

Fetch Google Business Profile posts and attach as `posts` on each place record.

## `maxPosts` (type: `integer`):

Maximum posts per business when scrapePosts is enabled.

## `maxConcurrency` (type: `integer`):

How many businesses to enrich in parallel. Search terms still run one after another.

## `maxRequestRetries` (type: `integer`):

Retries for enrichment steps (API client also retries 429/5xx).

## Actor input object example

```json
{
  "searchStringsArray": [
    "restaurant"
  ],
  "locationQuery": "New York, USA",
  "searchMode": "keyword",
  "query": "Restaurants in Manhattan",
  "maxResults": "50",
  "maxCrawledPlacesPerSearch": 50,
  "language": "en",
  "country": "US",
  "skipClosedPlaces": false,
  "radius": 1000,
  "scrapePlaceDetailPage": false,
  "scrapePhotos": false,
  "maxPhotosPerPlace": 0,
  "maxImages": 0,
  "scrapeReviews": false,
  "maxReviewsPerPlace": 0,
  "maxReviews": 0,
  "reviewsSort": "newest",
  "reviewsLanguage": "",
  "scrapePosts": false,
  "maxPosts": 20,
  "maxConcurrency": 5,
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

Default dataset items produced by this Actor.

# 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": [
        "restaurant"
    ],
    "locationQuery": "New York, USA",
    "searchMode": "keyword",
    "query": "Restaurants in Manhattan",
    "maxResults": "50",
    "maxCrawledPlacesPerSearch": 50,
    "language": "en",
    "country": "US",
    "skipClosedPlaces": false,
    "radius": 1000,
    "scrapePlaceDetailPage": false,
    "scrapePhotos": false,
    "maxPhotosPerPlace": 0,
    "maxImages": 0,
    "scrapeReviews": false,
    "maxReviewsPerPlace": 0,
    "maxReviews": 0,
    "reviewsSort": "newest",
    "reviewsLanguage": "",
    "scrapePosts": false,
    "maxPosts": 20,
    "maxConcurrency": 5,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapingdino/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": ["restaurant"],
    "locationQuery": "New York, USA",
    "searchMode": "keyword",
    "query": "Restaurants in Manhattan",
    "maxResults": "50",
    "maxCrawledPlacesPerSearch": 50,
    "language": "en",
    "country": "US",
    "skipClosedPlaces": False,
    "radius": 1000,
    "scrapePlaceDetailPage": False,
    "scrapePhotos": False,
    "maxPhotosPerPlace": 0,
    "maxImages": 0,
    "scrapeReviews": False,
    "maxReviewsPerPlace": 0,
    "maxReviews": 0,
    "reviewsSort": "newest",
    "reviewsLanguage": "",
    "scrapePosts": False,
    "maxPosts": 20,
    "maxConcurrency": 5,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapingdino/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": [
    "restaurant"
  ],
  "locationQuery": "New York, USA",
  "searchMode": "keyword",
  "query": "Restaurants in Manhattan",
  "maxResults": "50",
  "maxCrawledPlacesPerSearch": 50,
  "language": "en",
  "country": "US",
  "skipClosedPlaces": false,
  "radius": 1000,
  "scrapePlaceDetailPage": false,
  "scrapePhotos": false,
  "maxPhotosPerPlace": 0,
  "maxImages": 0,
  "scrapeReviews": false,
  "maxReviewsPerPlace": 0,
  "maxReviews": 0,
  "reviewsSort": "newest",
  "reviewsLanguage": "",
  "scrapePosts": false,
  "maxPosts": 20,
  "maxConcurrency": 5,
  "maxRequestRetries": 3
}' |
apify call scrapingdino/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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