# Google Maps Places Scraper (`miladamirzadeh/google-maps-places-scraper`) Actor

Fast HTTP-only Google Maps scraper for local business leads. Extract names, phones, websites, addresses, ratings, reviews, opening hours, GPS coordinates, photos, and Place IDs. Export to JSON, CSV, or Excel, no Google API key required.

- **URL**: https://apify.com/miladamirzadeh/google-maps-places-scraper.md
- **Developed by:** [Milad Amirzadeh](https://apify.com/miladamirzadeh) (community)
- **Categories:** Lead generation, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.90 / 1,000 place scrapeds

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

**Extract structured Google Maps place data for lead generation, local SEO, market research, directories, and point-of-interest datasets—without a Google Maps API key.**

Google Maps Places Scraper collects businesses, attractions, landmarks, public places, institutions, entertainment venues, and other Google Maps locations. Results can include names, categories, descriptions, phone numbers, websites, addresses, ratings, review counts, weekly opening hours, coordinates, images, highlighted reviews, Google Place IDs, and other place details.

Normal runs use an HTTP-based extraction pipeline instead of browser rendering. Avoiding browser startup supports faster processing and lower Compute Unit overhead, while normalized fields and two dataset views keep the output clean and ready for export, API access, schedules, and downstream systems.

> **Before your first run:** `hasPhoneOnly` defaults to `true`, and `imageMode` defaults to `all`. For general place or POI datasets, set `hasPhoneOnly` to `false`. For smaller contact-only runs, set `imageMode` to `none` or `cover`.

### Quick start

This input collects ten Paris attractions, including places that do not publish a phone number:

```json
{
  "searchQueries": [
    "Tourist attractions in Paris, France"
  ],
  "maxPlacesPerQuery": 10,
  "language": "en",
  "hasPhoneOnly": false,
  "hasWebsiteOnly": false,
  "minStarRating": 0,
  "hasLocationOnly": true,
  "skipClosed": false,
  "imageMode": "cover",
  "extractReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

1. Open the Actor's **Input** tab.
2. Add one or more keyword-and-location searches or Google Maps URLs.
3. Choose the maximum number of accepted records per query.
4. Adjust filters, images, reviews, and language.
5. Keep Apify Proxy enabled; residential proxies are recommended.
6. Click **Start** and open the default dataset when the run finishes.

<img src="./docs/images/google-maps-scraper-input.png" alt="Google Maps Places Scraper input with multiple Berlin search queries" width="760">

### What data can you extract?

Depending on what Google publishes for a place, each result can include:

- **Place identity:** name, category, description, Google Maps URL, `placeId`, and `featureId`
- **Contact details:** phone number and external website
- **Reputation:** star rating and total review count
- **Location:** formatted address, latitude, and longitude
- **Availability:** current business status, closed flag, and weekly opening hours
- **Place attributes:** amenities, offerings, accessibility, payments, parking, and other About data
- **Images:** no images, one cover image, or up to six preview images
- **Reviews:** up to ten highlighted reviews with author, rating, text, and relative time
- **Search provenance:** source query and organic search rank

Missing optional values are returned as `null`, `{}`, or `[]`. The Actor does not fabricate unavailable data.

### Why choose this Google Maps scraper?

- **Efficient HTTP-based processing.** Normal runs do not launch Chromium or Playwright, reducing browser overhead and helping control runtime and Compute Unit usage.
- **Clean structured output.** Normalized records are written to the default dataset, with **Essential Results** for a compact table and **Places Overview** for the complete field set.
- **No Google Maps API key required.** Run it directly on Apify without setting up Google Places API credentials or quotas.
- **Accepted-result quotas.** `maxPlacesPerQuery` limits valid saved records; candidates rejected by filters do not consume the accepted-record quota.
- **Practical filters.** Require a phone number, external website, coordinates, or minimum rating, and exclude clearly closed places when needed.
- **Direct URL support.** Process full Google Maps place URLs and supported search URLs in addition to text queries.
- **Multilingual output.** Use one of 79 supported interface languages for localized categories, status text, hours, About labels, and review labels.
- **Organic result handling.** Sponsored candidates are excluded from organic ranking and the saved-place quota.
- **Transparent identity fields.** `placeId` and `featureId` are included for matching, updates, and downstream record management.

### Common use cases

#### Lead generation and sales prospecting

Build phone and website lists for dentists, contractors, agencies, clinics, retailers, restaurants, and other local businesses. Combine `hasPhoneOnly` and `hasWebsiteOnly` when both contact channels are required.

#### Local SEO and competitor research

Compare categories, ratings, review volume, locations, websites, and opening hours across a city or region. Export the results for audits, outreach, reporting, or territory planning.

#### POI, travel, and location datasets

Collect attractions, museums, parks, landmarks, public facilities, universities, hospitals, entertainment venues, and other points of interest. Set `hasPhoneOnly` to `false` because many non-business locations do not publish phone numbers.

#### Directories and data enrichment

Create or refresh structured place directories and enrich existing records with stable identity fields, coordinates, public contact details, ratings, and Google Maps links.

### Input reference

At least one non-empty `searchQueries` or `startUrls` entry is required.

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQueries` | array of strings | — | Natural searches such as `Dentists in New York, NY` or `Museums in Paris, France`. Each query has its own accepted-result ceiling. |
| `startUrls` | array | `[]` | Full Google Maps `/maps/place/...` or supported `/maps/search/...` URLs. A direct place URL targets one place. Viewport-only `/maps/@lat,lng,zoom` URLs are not supported. |
| `maxPlacesPerQuery` | integer, 1–5000 | `3` | Maximum accepted records per text query or search URL. It is a ceiling, not a guarantee. |
| `language` | string | `en` | Result language used for localized fields. The input supports 79 interface languages. |
| `hasPhoneOnly` | boolean | `true` | Keep only places with a usable public phone number. Disable it for general POI collection. |
| `hasWebsiteOnly` | boolean | `false` | Keep only places with an external website rather than a Google-owned, social, or unusable URL. |
| `minStarRating` | integer, 0–5 | `0` | Minimum Google rating. `0` disables the filter. Unrated places are rejected when a positive minimum is set. |
| `hasLocationOnly` | boolean | `false` | Keep only places with latitude and longitude. |
| `skipClosed` | boolean | `false` | Exclude places Google clearly identifies as closed. Unknown status is not treated as closed. |
| `imageMode` | `none`, `cover`, or `all` | `all` | Return no images, one cover image, or up to six preview image URLs. |
| `extractReviews` | boolean | `false` | Return up to ten highlighted reviews from the place detail response. This is not a full review-history crawl. |
| `proxyConfiguration` | object | Apify Proxy enabled | Proxy configuration for Google requests. Residential proxies are recommended. |

Filters are evaluated from place data already being processed. When many candidates fail strict filters, the Actor may inspect more candidates before reaching the accepted-result ceiling.

### Example inputs

#### Find dentists with phone numbers in New York

```json
{
  "searchQueries": [
    "Dentists in New York, NY"
  ],
  "maxPlacesPerQuery": 10,
  "language": "en",
  "hasPhoneOnly": true,
  "hasWebsiteOnly": false,
  "minStarRating": 0,
  "hasLocationOnly": false,
  "skipClosed": false,
  "imageMode": "none",
  "extractReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

#### Build a Paris attractions and POI dataset

```json
{
  "searchQueries": [
    "Tourist attractions in Paris, France"
  ],
  "maxPlacesPerQuery": 10,
  "language": "en",
  "hasPhoneOnly": false,
  "hasWebsiteOnly": false,
  "minStarRating": 0,
  "hasLocationOnly": true,
  "skipClosed": false,
  "imageMode": "cover",
  "extractReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

#### Extract one place from a Google Maps URL

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/BK/@47.9946787,10.1791317,17z/data=!4m6!3m5!1s0x479bf25b04099115:0xd7db0d8989fc3f6f!8m2!3d47.9946787!4d10.1791317"
    }
  ],
  "maxPlacesPerQuery": 1,
  "language": "en",
  "hasPhoneOnly": false,
  "imageMode": "cover",
  "extractReviews": true
}
```

Use a full `/maps/place/` URL that contains place identity information. Short redirect links and map-viewport URLs may not contain enough information for direct extraction.

### Output

Every accepted place is written as one object to the default Apify Dataset. The Output tab provides two views:

- **Essential Results:** a compact table for contact, rating, address, location, opening-hours, and Google Maps URL fields
- **Places Overview:** the complete output, including descriptions, images, About data, and reviews

<img src="./docs/images/google-maps-scraper-essential-results.png" alt="Essential Results dataset view with Berlin businesses and museums, including contact details, ratings, addresses, locations, and opening hours" width="1000">

A shortened output record looks like this:

```json
{
  "title": "Musée Rodin",
  "category": "Sculpture museum",
  "description": "18th-century mansion and sculpture garden displaying Rodin's influential works.",
  "phone": "+33 1 44 18 61 10",
  "website": "https://www.musee-rodin.fr/",
  "rating": 4.7,
  "reviewCount": 20727,
  "address": "Musée Rodin, 77 Rue de Varenne, 75007 Paris, France",
  "location": {
    "lat": 48.8553072,
    "lng": 2.3158354
  },
  "businessStatus": "Closed · Opens 10 AM Tue",
  "openingHours": [
    {
      "day": "Monday",
      "hours": "Closed"
    },
    {
      "day": "Tuesday",
      "hours": "10 AM–6:30 PM"
    }
  ],
  "images": [
    "https://lh3.googleusercontent.com/...=s0"
  ],
  "aboutInfo": {
    "Accessibility": [
      "Wheelchair-accessible entrance"
    ]
  },
  "reviews": [],
  "url": "https://www.google.com/maps/place/...",
  "featureId": "0x...",
  "placeId": "ChIJ...",
  "searchQuery": "Tourist attractions in Paris, France",
  "searchRank": 1
}
```

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `title` | string | Business, attraction, institution, or place name. |
| `category` | string or `null` | Primary localized Google Maps category. |
| `description` | string or `null` | Place-specific editorial description when Google provides one. |
| `phone` | string or `null` | Public phone number. |
| `website` | string or `null` | External website when available. |
| `rating` | number or `null` | Google star rating from 1.0 to 5.0. |
| `reviewCount` | integer or `null` | Total Google review count when present. |
| `address` | string or `null` | Display address. |
| `location` | object or `null` | Geographic coordinates as `{ "lat": number, "lng": number }`. |
| `isClosed` | boolean or `null` | Closed flag when detectable; `null` when unknown. |
| `businessStatus` | string or `null` | Localized current status or next opening/closing time. |
| `openingHours` | array or `null` | Weekly hours as `{ "day", "hours" }` entries when Google publishes them. |
| `images` | array | Zero, one, or up to six preview image URLs, depending on `imageMode`. |
| `aboutInfo` | object | Structured place attributes such as amenities, accessibility, offerings, payments, or parking. |
| `reviews` | array | Up to ten highlighted reviews when `extractReviews` is enabled. |
| `url` | string | Canonical Google Maps place URL. |
| `featureId` | string or `null` | Google's CID-style feature identifier. |
| `placeId` | string or `null` | Google Place ID, commonly beginning with `ChIJ`. |
| `searchQuery` | string | Query or search URL that produced the record. |
| `searchRank` | integer or `null` | Organic rank within the source query. |

### Export, automate, and integrate

You can:

- Export datasets as JSON, CSV, Excel, XML, RSS, or HTML
- Fetch results through the Apify Dataset API
- Schedule recurring runs in Apify Console
- Trigger workflows with webhooks
- Connect results to Make, Zapier, n8n, CRMs, spreadsheets, databases, and data warehouses

#### Run with curl

This synchronous endpoint waits for the Actor and returns default-dataset items:

```bash
curl --request POST \
  --url "https://api.apify.com/v2/actors/miladamirzadeh~google-maps-places-scraper/run-sync-get-dataset-items?format=json" \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "searchQueries": ["Museums in Paris, France"],
    "maxPlacesPerQuery": 10,
    "language": "en",
    "hasPhoneOnly": false,
    "imageMode": "none",
    "extractReviews": false
  }'
```

#### Run with JavaScript

Install the official client:

```bash
npm install apify-client
```

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  searchQueries: ['Museums in Paris, France'],
  maxPlacesPerQuery: 10,
  language: 'en',
  hasPhoneOnly: false,
  imageMode: 'none',
  extractReviews: false,
};

const run = await client
  .actor('miladamirzadeh/google-maps-places-scraper')
  .call(input);

const { items } = await client
  .dataset(run.defaultDatasetId)
  .listItems();

console.log(items);
```

#### Run with Python

Install the official client:

```bash
pip install apify-client
```

```python
import os

from apify_client import ApifyClient

client = ApifyClient(token=os.environ['APIFY_TOKEN'])

run_input = {
    'searchQueries': ['Museums in Paris, France'],
    'maxPlacesPerQuery': 10,
    'language': 'en',
    'hasPhoneOnly': False,
    'imageMode': 'none',
    'extractReviews': False,
}

run = client.actor(
    'miladamirzadeh/google-maps-places-scraper'
).call(run_input=run_input)

items = client.dataset(
    run.default_dataset_id
).list_items().items

print(items)
```

### Pricing

This Actor uses **pay-per-event** pricing. Billing is tied to a run start and successfully saved records in the default dataset.

| Charged event | Free | Starter | Scale | Business |
| --- | ---: | ---: | ---: | ---: |
| Actor start | $0.005 per run | $0.005 per run | $0.005 per run | $0.005 per run |
| Saved place record | $0.00120 | $0.00120 | $0.00105 | $0.00090 |

On the Free or Starter plan, typical charges are:

- 10 saved places: **$0.017**
- 100 saved places: **$0.125**
- 1,000 saved places: **$1.205**

Candidates rejected by your filters are not written as results and therefore are not charged as saved-place records. Images and highlighted reviews do not use separate paid events. The Actor does not pass through a separate platform-usage charge.

### Example benchmark

A development benchmark was run with:

- Five Berlin searches: restaurants, museums, hospitals, libraries, and tourist attractions
- Ten accepted places per query
- English language
- Residential proxy
- Images disabled
- Reviews disabled
- 1 GB memory

Observed result:

- **50 saved places**
- **43 seconds**
- **$0.022 development platform usage**

<img src="./docs/images/google-maps-scraper-benchmark-summary.png" alt="Apify benchmark showing 50 results, 0.022 dollars platform usage, and 43 seconds runtime" width="770">

This measured run illustrates the speed and resource profile of the HTTP-based pipeline under one configuration; it is not a performance guarantee. Runtime and availability vary with query breadth, location, filters, proxy conditions, and changes in Google Maps responses. Store billing follows the pay-per-event prices above; the displayed `$0.022` is the underlying platform usage recorded during the development benchmark.

### Tips for reliable results

- Include the city, region, or country in each query, for example `Veterinarians in Munich, Germany`.
- Use a residential proxy country that matches the target market when localization matters.
- Set `language` to the language required for categories, hours, status, About attributes, and relative review times.
- Disable `hasPhoneOnly` for public places, landmarks, attractions, and broad POI datasets.
- Use `imageMode: "none"` for contact exports, `"cover"` for a thumbnail, and `"all"` only when the complete preview set is useful.
- Leave `extractReviews` disabled when sample reviews are not needed.
- Start with a small run before requesting hundreds or thousands of places.
- Treat `maxPlacesPerQuery` as a ceiling. Google may return fewer useful matches than requested.
- Split substantially different countries or languages into separate runs.

### Limitations and responsible use

- Data coverage depends on what Google Maps exposes for a specific place, category, language, and region.
- Images are limited to up to six preview URLs; this is not a full Photos-gallery crawl.
- Reviews are limited to up to ten highlighted reviews; this is not a paginated review-history scraper.
- The Actor does not visit external business websites, so it does not collect emails or social and messaging profiles.
- Popular times, menus, price ranges, and full hotel inventory are not currently included.
- Some parks, squares, landmarks, hotels, and public places do not publish weekly opening hours or phone numbers.
- Google Maps response structures can change. Report reproducible extraction issues through the Actor's **Issues** tab.
- This Actor is not affiliated with, endorsed by, or sponsored by Google. Google Maps and Google Business Profile are trademarks of Google LLC.

You are responsible for using extracted data lawfully and for complying with applicable privacy, database, copyright, marketing, and data-protection rules, as well as relevant terms. Do not use the Actor for spam, harassment, unlawful profiling, or other abuse.

### FAQ

#### Do I need a Google Maps API key?

No. The Actor does not use the official Google Places API. It runs on Apify using HTTP extraction and your configured proxy.

#### Can I use it without coding?

Yes. Configure the Actor in Apify Console, click **Start**, then preview or export the dataset. Developers can run the same workflow through curl, JavaScript, Python, schedules, webhooks, and integrations.

#### Can I search several cities or categories in one run?

Yes. Add multiple strings to `searchQueries`. `maxPlacesPerQuery` applies separately to each query.

#### Why did I get fewer records than requested?

`maxPlacesPerQuery` is an upper limit. A run can save fewer records when Google returns limited matches, filters reject many candidates, a query is narrow, or access ends before the ceiling is reached.

#### How do I keep places without phone numbers?

Set `hasPhoneOnly` to `false`. This is important for attractions, landmarks, parks, institutions, and other POIs.

#### Can I require both a phone number and a website?

Yes. Enable both `hasPhoneOnly` and `hasWebsiteOnly`. The filters use AND logic.

#### Why are hours, About data, images, or reviews empty?

These fields are optional and vary by place. Google may not publish them, and your `imageMode` or `extractReviews` settings may intentionally omit them.

#### Are sponsored listings included?

Sponsored candidates are excluded from organic ranking and do not count toward the accepted-place ceiling.

#### Can it extract emails or social media profiles?

No. The Actor deliberately does not visit external websites, so it does not collect emails, Facebook, Instagram, LinkedIn, TikTok, WhatsApp, Telegram, or similar profiles.

### Support

For a failed run, missing field, incorrect place match, or parsing issue, open the Actor's **Issues** tab and include:

- The run ID
- The input used, with secrets removed
- One or two affected Google Maps URLs or place names
- The expected result and the actual result

Clear, reproducible examples make Google-side changes faster to diagnose. Feature requests and custom extraction requirements can be submitted through the same channel.

# Actor input Schema

## `searchQueries` (type: `array`):

Enter one keyword, category, or place type together with a location, for example `Hotels in Berlin, Germany`. Each query has its own maximum accepted-result limit.

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

Optional full Google Maps place URLs or supported search URLs. They are processed in addition to the text queries.

## `maxPlacesPerQuery` (type: `integer`):

Maximum number of accepted records to save for each text query or supported search URL. This is a ceiling; the actual number can be lower when Google returns fewer matches or filters reject candidates.

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

Language used for localized Google Maps fields such as categories, status text, opening hours, About labels, and review labels.

## `hasPhoneOnly` (type: `boolean`):

Save only places with a public phone number. Disable this for attractions, landmarks, parks, institutions, and other POIs that may not publish one.

## `hasWebsiteOnly` (type: `boolean`):

Save only places with a usable external website.

## `minStarRating` (type: `integer`):

Save only places with a Google rating greater than or equal to this value. Set it to 0 to disable the rating filter.

## `hasLocationOnly` (type: `boolean`):

Save only places with latitude and longitude coordinates.

## `skipClosed` (type: `boolean`):

Exclude places that Google clearly identifies as permanently closed.

## `imageMode` (type: `string`):

Choose whether to return no images, one cover image, or all available preview image URLs.

## `extractReviews` (type: `boolean`):

Return up to ten highlighted reviews available in the place detail response. This is not a full review-history crawl.

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

Apify Proxy is enabled by default. Residential proxies are recommended because Google Maps may block datacenter IP addresses.

## Actor input object example

```json
{
  "searchQueries": [
    "Restaurants in New York",
    "Plumbers in Dubai"
  ],
  "startUrls": [],
  "maxPlacesPerQuery": 3,
  "language": "en",
  "hasPhoneOnly": true,
  "hasWebsiteOnly": false,
  "minStarRating": 0,
  "hasLocationOnly": false,
  "skipClosed": false,
  "imageMode": "all",
  "extractReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Structured place records stored in the default dataset.

# 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 = {
    "searchQueries": [
        "Restaurants in New York",
        "Plumbers in Dubai"
    ],
    "startUrls": [],
    "maxPlacesPerQuery": 3,
    "language": "en",
    "hasPhoneOnly": true,
    "hasWebsiteOnly": false,
    "minStarRating": 0,
    "hasLocationOnly": false,
    "skipClosed": false,
    "imageMode": "all",
    "extractReviews": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("miladamirzadeh/google-maps-places-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 = {
    "searchQueries": [
        "Restaurants in New York",
        "Plumbers in Dubai",
    ],
    "startUrls": [],
    "maxPlacesPerQuery": 3,
    "language": "en",
    "hasPhoneOnly": True,
    "hasWebsiteOnly": False,
    "minStarRating": 0,
    "hasLocationOnly": False,
    "skipClosed": False,
    "imageMode": "all",
    "extractReviews": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("miladamirzadeh/google-maps-places-scraper").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 '{
  "searchQueries": [
    "Restaurants in New York",
    "Plumbers in Dubai"
  ],
  "startUrls": [],
  "maxPlacesPerQuery": 3,
  "language": "en",
  "hasPhoneOnly": true,
  "hasWebsiteOnly": false,
  "minStarRating": 0,
  "hasLocationOnly": false,
  "skipClosed": false,
  "imageMode": "all",
  "extractReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call miladamirzadeh/google-maps-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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