# Google Maps Scraper: Places, Hours, Popular Times & Leads (`parseforge/google-maps-scraper`) Actor

Scrape Google Maps places by search, area, URL or place ID: phone, website, rating, reviews, hours, popular times and emails. Export CSV, Excel, JSON or XML.

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

## Pricing

from $0.89 / 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/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### Google Maps Scraper: Places, Hours, Popular Times & Leads

**Scrape Google Maps places by search term, map area, Maps URL or place ID: 375 coffee shops across Seattle came back in 45 seconds in our last deep-search test.** Every place carries 43 fields, including the phone, website, rating, review count, price range, the full week of opening hours, attributes, coordinates, plus code and photo count. Popular times, the 1 to 5 star distribution and website emails are optional extras. No login, no Google API key. Export to CSV, JSON, Excel, or XML.

The Google Places API bills every field group separately, caps a text search at 60 results, and never returns popular times. This Actor reads the same public data the Google Maps web app shows, pages past 60 results, splits big areas to go past Google's per-view limit, and hands back one flat schema you can load anywhere.

| Who uses it | What they scrape Google Maps for |
|---|---|
| Sales and lead generation teams | Local business lists with phone, website and, with the contacts extra, emails and social profiles |
| Marketing and local SEO agencies | Ratings, review counts, categories and claimed status of every competitor in a city |
| Market researchers | Store counts, price ranges and category mixes by neighborhood, city or country |
| Data teams | Google Maps datasets with coordinates, place IDs and hours for maps, models and dashboards |
| Operations and site selection | Popular times by hour to compare foot traffic between locations |

### What it does

The Actor takes search terms with a location, map coordinates, Google Maps URLs and place IDs, alone or together, and returns one row per place.

- 📌 **Identity:** name, place ID, CID, feature ID, Knowledge Graph ID and a working Google Maps link.
- 📍 **Location:** full address, street, neighborhood, city, postal code, state, country, latitude, longitude, plus code and time zone.
- ☎️ **Contact:** phone in display and international format, website and domain, booking links.
- ⭐ **Reputation:** rating, review count, price range, main and secondary categories, editorial summary.
- 🕒 **Hours:** the full week of opening hours and the live open status ("Open · Closes 9 PM").
- 🧾 **Profile:** attributes (service options, accessibility, amenities, payments), highlights, claimed status, closed flags and photo count.
- ➕ **Optional extras**, each off by default: place details (popular times, star distribution, menu link, owner description, typical time spent, review topics, related places, photo gallery) and website contacts (emails and social profiles from the business site).

### What you can do with Google Maps data

**🎯 Build local lead lists.**

Search "plumbers" in every city you sell to, keep places with a website and at least 20 reviews, and turn on website contacts to get the emails and social profiles each business publishes.

**📊 Benchmark competitors.**

Pull every place in a category for an area and compare ratings, review counts, price ranges and claimed status in one sheet, refreshed on a schedule.

**🏙 Map a market.**

Turn on deep search with map coordinates to cover a whole metro area, then count places by neighborhood, category and price range.

**👥 Compare foot traffic.**

Turn on place details to get popular times for each hour of the week and the typical time people spend there, ready to chart.

### Why choose this scraper

| | What you get |
|---|---|
| **No browser, fast runs** | It reads the Maps web app's own data over plain HTTP. A 5-place run took 5 seconds in our last cloud test. |
| **Past the per-view limit** | Google Maps lists about 180 places per map view. Deep search splits the area and keeps going. |
| **Every input style** | Search terms with a location, coordinates and zoom, Maps search or place URLs, short links, place IDs, CIDs and feature IDs. |
| **Free filters** | Minimum rating, minimum reviews, category words, open now, has a website, has a phone, skip closed places. A filtered-out place is never charged. |
| **Pay only for the extras you use** | Place details are charged only when the full place card comes back; website contacts only when an email or social profile is found. |
| **43 languages** | Categories, weekdays, open status and descriptions in the language you pick. |

### How it compares

All five scrapers below read public Google Maps places. This one returns the full place profile from the results list itself, never charges for a filter, and bills its extras only when they return data. The comparison uses each rival's public input options and Store price on September 24, 2026.

| Feature | ParseForge | compass/crawler-google-places | compass/google-maps-extractor | vortex\_data/google-maps | kaix/google-maps-places-scraper |
|---|---|---|---|---|---|
| Price per 1,000 places | $1.00 | $4.00 | $5.00 | $1.00 | $0.08 |
| Filters | Free | $1.00 per 1,000 per filter | $1.00 per 1,000 per filter | Free | Free |
| Popular times and star distribution | $5 per 1,000 extra | $2 per 1,000 extra | $2 per 1,000 extra | $1 per 1,000 extra | Included |
| Emails and social profiles | $5 per 1,000, only when found | $2 per 1,000 | $4 per 1,000 | $1.50 per 1,000, only when found | No |

**Honest limits.** One map view of Google Maps lists about 180 places; beyond that, deep search splits the area. Review texts are not included (see the Recommended Actors below for reviews). The contacts extra reads only what a business publishes on its own site.

### What a Google Maps place looks like

One row from a verified run on September 24, 2026, with both extras on. Long arrays are shortened here; a real row carries the full week of hours, every attribute, 126 popular-times slots and up to 20 photos.

```json
{
  "imageUrl": "https://lh3.googleusercontent.com/gps-proxy/ALd4DhG9U9R1ij39uSEuWIxesOW7O9-g2XeiijqwI0W2Aya8cKpHvyaD0GskpHwx-HQjMj196EZB7edacAJnfoiy8gOume8YnQv2BmZK_9YWNnT8LCLSOh8d1JKYUM-YHgI43GiWwGgQAbq9_f1NFgCUbd0-KmuJjc6mImpD0DS9Ty4pCR6LdK5xbNKM=w800-h600-k-no",
  "title": "Kizuki Ramen & Izakaya (Uptown)",
  "placeId": "ChIJi-MkXEEJlVQRg1GlIpHiNpI",
  "cid": "10535857491259249027",
  "fid": "0x549509415c24e38b:0x9236e29122a55183",
  "kgmid": "/g/11vbst1qzr",
  "url": "https://www.google.com/maps/place/?q=place_id:ChIJi-MkXEEJlVQRg1GlIpHiNpI",
  "categoryName": "Ramen restaurant",
  "categories": [
    "Ramen restaurant",
    "Izakaya restaurant",
    "Japanese restaurant"
  ],
  "description": "Hip venue serving Japanese noodle soups & small plates, plus whiskey, sake & beer amid artful decor.",
  "address": "33 NW 23rd Pl, Portland, OR 97210",
  "street": "33 NW 23rd Pl",
  "neighborhood": "Hillside",
  "city": "Portland",
  "postalCode": "97210",
  "state": "Oregon",
  "countryCode": "US",
  "plusCode": "84QVG8F2+R3",
  "latitude": 45.524507,
  "longitude": -122.699832,
  "timezone": "America/Los_Angeles",
  "phone": "(877) 839-5498",
  "phoneUnformatted": "+18778395498",
  "website": "https://www.kizuki.com/",
  "websiteDomain": "kizuki.com",
  "rating": 4.8,
  "reviewsCount": 668,
  "priceRange": "$20–30",
  "openStatus": "Open · Closes 9 PM",
  "permanentlyClosed": "No",
  "temporarilyClosed": "No",
  "ownerClaimed": "Yes",
  "ownerId": "117812527284682176552",
  "photosCount": 541,
  "language": "en",
  "searchString": "ramen in Portland, OR",
  "rank": 4,
  "menuUrl": "https://a04b2bd6-2548-4028-bb8b-552c12767296.filesusr.com/ugd/23c62c_eb130c1050b1432c8ea2994ead2127a6.pdf",
  "ownerDescription": "Welcome to Kizuki Ramen & Izakaya – Where Ramen Excellence Awaits!\nIndulge in the authentic taste of Japan at our 18 locations, proudly named Yelp's Top Ramen S...",
  "typicalTimeSpent": "People typically spend 30 min to 1 hr here",
  "locatedIn": "Uptown Shopping Center",
  "reviewsDistribution": {
    "oneStar": 13,
    "twoStar": 8,
    "threeStar": 19,
    "fourStar": 52,
    "fiveStar": 576
  },
  "primaryEmail": "contactus@kizuki.com",
  "emailCount": 2,
  "linkedinUrl": "Not Disclosed",
  "facebookUrl": "https://www.facebook.com/KizukiRamenUSA/",
  "instagramUrl": "https://www.instagram.com/kizukiramen",
  "twitterUrl": "https://twitter.com/kizukiramen",
  "youtubeUrl": "Not Disclosed",
  "tiktokUrl": "Not Disclosed",
  "socialProfilesFound": 3,
  "openingHours": [
    {
      "day": "Monday",
      "hours": "11 AM–9 PM"
    },
    {
      "day": "Tuesday",
      "hours": "11 AM–9 PM"
    }
  ],
  "attributes": [
    {
      "section": "Service options",
      "name": "No-contact delivery",
      "value": "Yes"
    },
    {
      "section": "Service options",
      "name": "Delivery",
      "value": "Yes"
    },
    {
      "section": "Service options",
      "name": "Onsite services",
      "value": "Yes"
    }
  ],
  "highlights": [
    "LGBTQ+ friendly"
  ],
  "bookingLinks": [],
  "popularTimes": [
    {
      "day": "Monday",
      "hour": 11,
      "occupancyPercent": 28,
      "label": "Usually not too busy"
    },
    {
      "day": "Monday",
      "hour": 12,
      "occupancyPercent": 37,
      "label": "Usually not too busy"
    }
  ],
  "reviewTags": [
    {
      "tag": "garlic ramen",
      "count": 6
    },
    {
      "tag": "garlic tonkotsu",
      "count": 14
    }
  ],
  "peopleAlsoSearch": [
    {
      "title": "Baka Umai Ramen Den",
      "fid": "0x0:0x7426ebe098cf0126",
      "rating": 4.8,
      "reviewsCount": 73,
      "categoryName": "Ramen"
    }
  ],
  "imageUrls": [
    "https://lh3.googleusercontent.com/gps-cs-s/AHRPTWkJha4CRklTyEfx0no68wLHBxKW8lnJGzXP9qmrDj8tUWdwBnPgMR10G16Kc0qmfHhl8W8J7xdxfxEFJTjpuwlTMM2-mAPnNiDrMBetd5JPRXpE-jGTM8EvUDhPGxPjR8eeWiGC=w1200-h900-k-no"
  ],
  "emails": [
    "carmel@kizuki.com",
    "contactus@kizuki.com"
  ],
  "sitePhones": [
    "4252141088"
  ],
  "scrapedAt": "2026-09-24T20:51:42.310Z",
  "error": null
}
```

Without extras, a row has the fields above from `imageUrl` through `rank`, plus `openingHours`, `attributes`, `highlights`, `bookingLinks`, `scrapedAt` and `error`: 43 fields in all, 63 with both extras on. A value Google does not publish reads `"Not Disclosed"`, never an empty cell.

### Configure the run

Mix search terms, coordinates, URLs and place IDs in one run. The Input tab lists every option.

Find well-reviewed dentists in Austin that list a website:

```json
{ "searchTerms": ["dentist"], "location": "Austin, TX", "minRating": "4.5", "minReviews": 50, "requireWebsite": true, "maxItems": 500 }
```

Cover a whole city past the per-view limit, with popular times:

```json
{ "searchTerms": ["coffee"], "latitude": "47.6062", "longitude": "-122.3321", "zoom": 12, "deepSearch": true, "maxPlacesPerSearch": 1000, "includePlaceDetails": true }
```

Refresh known places by ID or URL, with website emails:

```json
{ "placeIds": ["ChIJb5gBC-u0RIYRHkntaUcdJGs", "8582500234709843288"], "startUrls": [{ "url": "https://www.google.com/maps/search/tacos/@34.0522,-118.2437,14z" }], "includeContacts": true }
```

### Pricing

Pay-per-event: **$1.00 per 1,000 places**, dropping to $0.89 per 1,000 at higher Apify plans. You pay only for places written to your dataset; places your filters leave out are free.

| Places collected | Approximate cost |
|---|---|
| 100 | $0.10 |
| 1,000 | $1.00 |
| 10,000 | $10.00 |

Optional extras, billed only when you turn them on:

| Extra | Price |
|---|---|
| Place details (popular times, star distribution, menu, photos) | $5 per 1,000 places whose full place card came back |
| Website contacts (emails and social profiles) | $5 per 1,000 places where at least one was found |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 places as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 places per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Google Maps Scraper](https://apify.com/parseforge/google-maps-scraper?fpr=vmoqkp).
3. Enter `searchTerms` and a `location`, or paste Google Maps URLs or place IDs, add any filters, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab, or schedule the run to keep a list fresh.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2?fpr=vmoqkp) or the [ApifyClient](https://docs.apify.com/api/client/js?fpr=vmoqkp) for JavaScript and Python. It also connects to Make, Zapier, Slack, Airbyte, GitHub and Google Drive through Apify integrations.

### Use with AI agents (MCP)

Give an AI agent live Google Maps search through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/google-maps-scraper"
```

Then prompt it in plain language:

- *"List the 50 best-rated Italian restaurants in Chicago with their phone numbers and websites."*
- *"Find every gym within the map around 40.7128, -74.0060 at zoom 14 and tell me which ones are open now."*
- *"Compare the popular times of these three coffee shops and tell me the quietest hour on Saturday."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/google-maps-scraper" to collect Google Maps places. Input: { "searchTerms": ["<what>"], "location": "<city or area>", "maxItems": <n>, "minRating": "<0|3|3.5|4|4.5>", "includePlaceDetails": <true|false>, "includeContacts": <true|false> }. Places come back with title, placeId, categoryName, address, city, latitude, longitude, phone, website, rating, reviewsCount, priceRange, openingHours and attributes. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no places?**

The search term may be too narrow for the area, or the filters remove everything. Try a broader term ("restaurants" instead of a dish), a larger area, or fewer filters. The run log says how many places each filter left out.

**Why fewer places than I asked for?**

One map view lists about 180 places. Turn on deep search, or add more search terms or locations. Filters also remove places, and those are not charged.

**Why is a field "Not Disclosed"?**

Google did not publish it for that place: many places have no price range, no website, or no editorial summary. That is the place's real state on Google Maps.

**Why are popular times empty for some places?**

Google shows popular times only for places with enough visits. Smaller places have the star distribution and photos but no hourly chart.

**Why is the run slower with extras on?**

Place details open one place card per place, and website contacts read one to three pages of each business site. Raise `maxConcurrency` to process more places at once.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Google API key? | No. It reads the public data the Google Maps web app shows, so there is no API key, billing account or quota to manage. |
| How is this different from the Google Places API and its pricing? | The Places API bills each field group, caps text search at 60 results and has no popular times. Here you pay per place with the full profile included. |
| How many places per search? | About 180 per map view. With deep search on, the area is split up to three levels deep, so a city returns many hundreds. |
| Can I search by coordinates? | Yes. Set `latitude`, `longitude` and `zoom`, or paste a Maps search URL with `@lat,lng,zoom`. |
| Can I scrape specific places? | Yes. Paste place URLs, `?cid=` links, short links, place IDs (ChIJ...), CIDs or feature IDs. |
| Does it get emails? | Yes, with the website contacts extra. It reads the business's own site and charges only when it finds an email or social profile. |
| Does it scrape reviews? | It returns the rating, review count, star distribution and review topics. For review texts, use a dedicated Google Maps reviews scraper. |
| Which languages are supported? | 43, from English and Spanish to Japanese and Arabic. Categories, weekdays and open status come back translated. |
| How many places per run? | Free plan: 10. Paid: up to 1,000,000, bounded by what Google Maps lists for your searches. |
| Is this an official Google product? | No. It is unofficial and reads only public Google Maps data. |

### Recommended Actors

- [Google Maps Contacts Scraper](https://apify.com/parseforge/google-maps-contacts-scraper?fpr=vmoqkp): local businesses with the email and phone their own website publishes.
- [Google Maps Shared List Scraper](https://apify.com/parseforge/google-maps-shared-list-scraper?fpr=vmoqkp): every place in a shared Google Maps list.
- [Google Search Scraper](https://apify.com/parseforge/google-search-scraper?fpr=vmoqkp): organic and paid Google results for any query.
- [Website Contact Leads Scraper](https://apify.com/parseforge/website-contact-leads-scraper?fpr=vmoqkp): emails, phones and social profiles from any list of websites.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** [Open our contact form](https://tally.so/r/BzdKgA) with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Google LLC. It collects only publicly available Google Maps data. You are responsible for using the data in compliance with Google's terms and applicable laws, including GDPR, CCPA, and PIPL. Do not use it to identify, profile, or target individuals.

# Actor input Schema

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

What you would type into Google Maps: a category ("dentists"), a cuisine ("ramen"), a brand or a business name. Each term is searched separately and combined with the location below.

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

City, neighborhood, postcode or region, in plain words (for example "Austin, TX", "Shibuya, Tokyo" or "10115 Berlin"). It is added to every search term. Leave it empty to put the place in the term itself or to use the coordinates below.

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

Google Maps search URLs (maps/search/...@lat,lng,zoom), place URLs (maps/place/...), ?cid= links or maps.app.goo.gl short links. A search URL keeps its map area; a place URL returns that one place.

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

Google place IDs (ChIJ...), CIDs (the long number in ?cid=) or feature IDs (0x...:0x...). Each returns one place.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Upper limit for each search term. One map view of Google Maps lists about 180 places at most; turn on Deep search below to go past that in a big area.

## `latitude` (type: `string`):

Center of the map, in decimal degrees (for example 47.6062).

## `longitude` (type: `string`):

Center of the map, in decimal degrees (for example -122.3321).

## `zoom` (type: `integer`):

Google Maps zoom level for the coordinates: 11 is a whole city, 14 a district, 17 a few streets.

## `deepSearch` (type: `boolean`):

When a search fills Google's per-view limit, split the area into smaller views and search each one, up to three levels deep. Finds many more places in a large city; takes longer.

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

Language of the text Google returns: category names, weekday names, opening status and descriptions.

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

The country Google biases results toward when a search is ambiguous (for example "pizza" with no location, or "Springfield city hall").

## `minRating` (type: `string`):

Keep only places with at least this star rating. Places without any rating are left out when this is set.

## `minReviews` (type: `integer`):

Keep only places with at least this many Google reviews.

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

Keep only places whose Google categories contain one of these words (for example "dentist" keeps "Cosmetic dentist" and "Pediatric dentist"). Use the same language as the Language field.

## `openNow` (type: `boolean`):

Keep only places that Google shows as open at the moment of the run, in their local time.

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

Keep only places that list a website.

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

Keep only places that list a phone number.

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

Leave out places Google marks as permanently or temporarily closed.

## `includePlaceDetails` (type: `boolean`):

Adds popular times by hour, the 1 to 5 star distribution, the menu link, the owner's description, typical time spent, the venue it is located in, review topics, "people also search for" and up to 20 photo URLs.

## `includeContacts` (type: `boolean`):

Adds the primary email, every email found, and LinkedIn, Facebook, Instagram, X, YouTube and TikTok profile links from the business website.

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

How many places are processed at once. Only matters with place details or website contacts on.

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

Apify Proxy without a group (datacenter) works for Google Maps. Residential is not needed; the run switches to it by itself only if Google keeps refusing.

## Actor input object example

```json
{
  "searchTerms": [
    "coffee shops"
  ],
  "location": "Seattle, WA",
  "maxItems": 10,
  "maxPlacesPerSearch": 120,
  "zoom": 13,
  "deepSearch": false,
  "language": "en",
  "countryCode": "us",
  "minRating": "0",
  "openNow": false,
  "requireWebsite": false,
  "requirePhone": false,
  "skipClosedPlaces": true,
  "includePlaceDetails": false,
  "includeContacts": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key place fields

## `details` (type: `string`):

Popular times, star distribution, menu, photos and website contacts

## `fullData` (type: `string`):

Complete dataset with every field

# 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": [
        "coffee shops"
    ],
    "location": "Seattle, WA",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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": ["coffee shops"],
    "location": "Seattle, WA",
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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": [
    "coffee shops"
  ],
  "location": "Seattle, WA",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parseforge/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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