# Google Maps Scraper: Business Leads by City, No 120-Place Limit (`alexmorain/google-maps-leads-scraper`) Actor

Business leads from Google Maps for a whole city in one run, past the 120-result limit: phone, website, address, rating, reviews, hours. Filter by rating, reviews, claimed status and businesses with no website. Optional same-day check of each place and a watch that delivers only new places.

- **URL**: https://apify.com/alexmorain/google-maps-leads-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 86.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 places

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Google Maps Leads Scraper: every business of a city, no 120-result limit

Google Maps Leads Scraper returns **every business of a category in a city** as one row per place: **name, phone, website, address, GPS position, rating, number of reviews, opening hours, claimed or not**. Filter by minimum rating, number of reviews, claimed or unclaimed listings, and **businesses with no website**. On demand, each place is checked again **on the day of the run** (fresh review count, verified website, contact and booking links). Schedule it and get **only the places that are new since the last run**.

The data is public Google Maps listing data, collected and supplied by a third-party data provider, [DataForSEO](https://dataforseo.com). It does not come from Google's official Places API. On your side: no browser, no scrolling of Google Maps, no proxies, no login. Results land in a dataset you can export as CSV, Excel, JSON, HTML or XML, or read through the Apify API from Python, JavaScript or cURL.

> **Read this first.** This actor reads a **database of Google Maps places**, refreshed by the provider, not the live Maps page. We compared it with what Google Maps shows on 9 November 2026: it found **131 of 132** pizzerias of Paris 2nd district, **200 of 200** dentists in Lyon and **143 of 166** plumbers in Brooklyn (86 %; the missing ones were mostly "Emergency Plumber 24 7" listings with no reviews). Most places were last updated by the provider in September or October 2026. If you need the exact page Maps shows at this minute, use a browser-based Maps scraper. If you need every place of a city, filtered, cheaply, use this one. This actor is an independent project and is **not affiliated with, endorsed by or sponsored by Google**.

### Why use this Google Maps scraper

- **No 120-result wall.** A Google Maps search stops at about 120 places, so browser scrapers split a city into many small searches. Here one call returns up to 1,000 places, and the actor pages on until your limit. The database holds **10,712 restaurants in Paris**: our test run delivered **2,000 Paris restaurants in 13 seconds**, all distinct (run `L8Fc3rxXfveWC6Yie`).
- **Cheap.** 1,000 places cost **$1.52, or $0.82 on the Gold plan**. With the check of the day on every place: **$4.02** ($3.02 on Gold).
- **Filters that find leads.** Businesses **with no website** (prospects for a web agency), **unclaimed** listings (prospects for local SEO), places with **fewer than 20 reviews** (prospects for a review tool), or the best rated only.
- **Only the new places.** Schedule the same search every week and receive only the places that appeared since the last run. A place already delivered is **never delivered or charged again**.
- **Clean rows.** One row per place, deduplicated, invisible characters removed from names, a direct `googleMapsUrl` on every row.
- **On the Apify platform:** schedule it, call it by API, send the result to Google Sheets, a CRM, Make, Zapier, n8n or a **webhook** when the run ends.

Use it to build a prospect list for a city, find local businesses without a website, map competitors, feed a sales team every Monday with the places that just opened, or enrich a market study.

### How to scrape Google Maps businesses by city

1. Click **Try for free**.
2. Enter one or more **categories** (`Plumber`, `Dentist`, `Pizza restaurant`) or a **keyword in the name**.
3. Enter the **cities** and their **country**, or a point and a radius in km, or a country alone.
4. Add filters if you want: minimum rating, number of reviews, claimed or not, no website, phone only.
5. Set **Maximum places**. It is also your cost cap.
6. Press **Start**, then download the dataset as CSV, Excel or JSON.

**City names are in English, as Google Maps writes them, and the case matters.** `Munich` returns 263 plumbers, `München` returns none, and `munich` returns none either. When a city gives no result, check its spelling on Google Maps in English.

#### Input fields

| Field | What it does |
|---|---|
| `categories` | Google Maps categories, as ids (`plumber`) or names (`Pizza restaurant`). 5,316 categories are known; an unknown one is skipped with a warning and the closest names. Over 10 categories are searched in groups of 10 and places found twice are delivered once |
| `titleKeyword` | Keep places whose name contains this text, case ignored (`emergency` finds "24-Hour Emergency Plumbers") |
| `cities`, `countryCode` | Cities in English, as Google Maps writes them, with their country |
| `latitude`, `longitude`, `radiusKm` | A point and a radius, instead of cities |
| `minRating`, `minReviews`, `maxReviews` | Rating and review filters |
| `claimed` | `any`, `claimed` or `unclaimed` |
| `withoutWebsite`, `withPhoneOnly` | Places with no website, places with a phone |
| `sortBy` | Most reviews first (default), best rating first, or no order |
| `maxItems` | Maximum places delivered in the run |
| `fullDetails`, `language` | Full details (every place checked today), and the language of the check |
| `monitor`, `watchName` | Deliver only new places, and the name of the watch |
| `webhookUrl` | Receives a JSON summary when the run ends |
| `cacheMaxAgeHours` | Reuse identical searches made from your account for this many hours (72 by default, 0 = always fresh) |

### What data does the Google Maps scraper extract?

One row per place. Every field is always present, `null` when the place does not have it. The full list, from the dataset schema:

| Field | Type | Description |
|---|---|---|
| `cid` | string | Google Maps customer id of the place; unique key of a row. |
| `placeId` | string | Google place id. |
| `title` | string | Name of the business, invisible characters removed. |
| `category` | string | Main Google Maps category. |
| `categoryIds` | array | Category ids, usable in the categories input. |
| `additionalCategories` | array | Other categories of the place. |
| `phone` | string | Phone number in international format. |
| `website` | string | Website of the place. Null when the database has none. |
| `domain` | string | Domain of the website. |
| `hasWebsite` | boolean | True when the place has a website in the database. |
| `address` | string | Full address. |
| `street` | string | Street address. |
| `city` | string | City. |
| `postalCode` | string | Postal code. |
| `region` | string | Region or state. |
| `borough` | string | Borough or district. |
| `countryCode` | string | ISO two-letter country code. |
| `latitude` | number | Latitude. |
| `longitude` | number | Longitude. |
| `rating` | number | Average rating, 1 to 5. |
| `reviewsCount` | number | Number of reviews. |
| `ratingDistribution` | object | Number of reviews per star, keys 1 to 5. |
| `isClaimed` | boolean | True when the owner has claimed the listing. |
| `priceLevel` | string | Price level when Google shows one. |
| `totalPhotos` | number | Number of photos. |
| `mainImage` | string | URL of the main photo. |
| `logo` | string | URL of the logo. |
| `description` | string | Description written by the owner. |
| `openingHours` | object | Opening hours per weekday (open and close hour and minute). |
| `currentStatus` | string | Open or closed at the time of the database snapshot. |
| `placeTopics` | object | Topics reviewers mention, with counts. |
| `attributes` | object | Google attributes grouped by theme (available and unavailable). |
| `googleMapsUrl` | string | Link to the place on Google Maps. |
| `lastUpdated` | string | When the data provider last refreshed the place. |
| `firstSeen` | string | When the data provider first saw the place. |
| `dataSource` | string | Always DataForSEO. |
| `scrapedAt` | string | Time of the run, ISO 8601. |
| `details` | object | Today's listing, only with Full details on; null when it did not come back. |
| `websiteVerified` | boolean | With Only places without a website and Full details: true when the place still has no website today, false when one appeared. Null otherwise. |
| `detailsStatus` | string | With Full details: ok, or failed when the details did not come back (the place is then charged as a plain place). Null otherwise. |

#### Example row

A place, from a real run on 10 November 2026:

```json
{
  "title": "Le Malakoff",
  "category": "French restaurant",
  "categoryIds": ["french_restaurant", "bar", "cafe", "restaurant", "restaurant_brasserie"],
  "phone": "+33145537527",
  "website": "http://www.le-malakoff.com/",
  "domain": "www.le-malakoff.com",
  "hasWebsite": true,
  "address": "6 Pl. du Trocadéro et du 11 Novembre, 75116 Paris",
  "city": "Paris",
  "postalCode": "75116",
  "countryCode": "FR",
  "latitude": 48.863694,
  "longitude": 2.287059,
  "rating": 3.5,
  "reviewsCount": 1999,
  "isClaimed": true,
  "priceLevel": "moderate",
  "cid": "13535977408867547673",
  "googleMapsUrl": "https://www.google.com/maps?cid=13535977408867547673",
  "lastUpdated": "2026-10-07 12:29:09 +00:00",
  "firstSeen": "2024-07-15 17:23:44 +00:00",
  "details": null,
  "websiteVerified": null,
  "detailsStatus": null,
  "dataSource": "DataForSEO",
  "scrapedAt": "2026-11-10T00:19:12+00:00"
}
```

A SUMMARY record in the key-value store gives the number of places, the events charged, the checks that failed and, in watch mode, how many known places were skipped.

### Find Google Maps businesses without a website

This is the classic web agency and local SEO lead list. Tick **Only places without a website** and the actor keeps places that have no website in the database. The database is refreshed every few weeks, so some of those places have a site today: in a first test, **7 of 142 places (5 %)** listed without a website had one on Maps on the day; in a second one (run `uJQrCBkg74ZsjmoM3`), 0 of 30. Combine the filter with **Full details**: each place is looked up again on the day of the run, and `websiteVerified: true` tells you the place still has no website today. Add `claimed: unclaimed`, `maxReviews` or `minRating` to narrow the list further.

### Full details: every place checked today (option)

Tick **Full details** and each place is looked up again on Google Maps during the run. The row then gets a `details` object:

- `website`, `phone`: as shown today.
- `rating`, `reviewsCount`: the counters of the day (example: 324 reviews today against 318 in the database).
- `contactUrl`, `bookOnlineUrl`: the contact and booking links of the listing, when it has them.
- `checkedAt`: the time of the check.

The check runs as a queued task at the provider, which is about **3 times cheaper** than an instant lookup, and that is why the option costs what it costs. The price is time: each check comes back in 1 to 2 minutes. The actor first sends 3 places as a test, then the rest, so **a run with this option takes 3 to 5 minutes** (5 minutes for 30 places in our test), whatever its size. A check that has not come back in time, or fails, leaves the row with `detailsStatus: failed` and the plain place price. In the 30-place test, 30 of 30 checks came back and the review count had changed on 11 of them.

### Get only the new places: Google Maps new business alerts

Tick **Watch for new places**, give the watch a name, and schedule the run (every week, for example). The first run delivers everything that matches. Each later run asks the provider only for places first seen since the previous run (minus 2 days, to allow for indexing delay), and skips any place already delivered. A run that stops early (Maximum places reached, spending limit, timeout) saves where it stopped: the next run carries on from that point instead of starting over, so you never pay to read places you already have. Once the whole list has been read, the watch moves forward to the date the reading started. The memory is a named key-value store, `google-maps-leads-watch`, in your account, and keeps delivered places for 365 days.

In a test on plumbers in Paris, three runs of 300 places returned 300, then 279 (no overlap, no re-read), then 0.

### How much does it cost to scrape Google Maps leads?

You pay per place, plus a small fee per search page and per run. Prices fall with your Apify plan: **Free and Bronze** pay the first price, **Silver** the middle one, **Gold** and above the last one.

| Event | Free / Bronze | Silver | Gold+ | When |
|---|---|---|---|---|
| Run start | $0.002 per GB of memory | same | same | Once per run, $0.002 with the default 1 GB |
| Search page | $0.02 | same | same | Per page of up to 1,000 places read |
| **Place** | **$0.0015** | $0.0012 | **$0.0008** | One row per delivered place |
| **Place checked today** | **$0.004** | $0.0035 | **$0.003** | One row per place with the check of the day |

A place that was already delivered in a watch is **never charged**. A place whose check of the day fails is delivered and charged as a plain **Place**, with `detailsStatus: failed`.

**Examples** (Free or Bronze plan, then Gold in brackets, start fee aside):

- **100 dentists in Lyon**: $0.02 + 100 x $0.0015 = **$0.17** (Gold: **$0.10**).
- **1,000 restaurants in a city**: $0.02 + 1,000 x $0.0015 = **$1.52** (Gold: **$0.82**).
- **1,000 places checked today**: $0.02 + 1,000 x $0.004 = **$4.02** (Gold: **$3.02**).
- **Weekly watch with 12 new places**: $0.02 + 12 x $0.0015 = **$0.038**.

The spending limit you set on a run stops it at the amount you choose, and **Maximum places** bounds the run. The actor never reads a page your limit cannot cover.

Free Apify plan: up to 0.15 USD of DataForSEO data per day; paid plans unlimited.

### Scrape Google Maps with Python, JavaScript or cURL

These examples use the actor `alexmorain/google-maps-leads-scraper`. Replace the token with your own and keep it in an environment variable.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/google-maps-leads-scraper").call(run_input={
    "categories": ["plumber"],
    "cities": ["Brooklyn"],
    "countryCode": "US",
    "withoutWebsite": True,
    "maxItems": 200,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["title"], row["phone"], row["reviewsCount"])
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('alexmorain/google-maps-leads-scraper').call({
    categories: ['dentist'],
    cities: ['Lyon'],
    countryCode: 'FR',
    minRating: 4,
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((r) => `${r.title} ${r.phone}`));
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~google-maps-leads-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories": ["pizza_restaurant"], "cities": ["Paris"], "countryCode": "FR", "maxItems": 50}'
```

### Tips

- **Start small.** Run with **Maximum places** at 20, read the rows, then raise it.
- **Write the city as Google Maps does, in English.** `Munich`, `Cologne`, `Milan`, `Brussels`.
- **No-website leads:** add **Full details** before you send a cold email, or 1 in 20 prospects will already have a site.
- **Rerun without waiting.** A search identical to one already made from your account in the last 3 days is answered from a cache kept in your account (named key-value store `google-maps-leads-cache`), instantly and with the same places. The cache is yours: nothing is shared between accounts. Set **Reuse identical searches for (hours)** to `0` to always ask the provider again. Watch runs never use it.
- **Set a spending limit.** The actor stops cleanly when the next page does not fit under it, and says so in the run status.

### Google Maps scraper FAQ

#### Is this the same as scraping Google Maps?

Not directly. The rows come from a database of public Google Maps listings that a third-party data provider collects and refreshes. That is why there is no 120-result limit and no proxy cost. The trade-off is freshness: a place that opened last week may not be there yet, and a counter may be a few weeks old. The **Full details** option fixes the counters and the website for the places you get.

#### Is this a Google Maps API alternative?

It is an alternative to the official Places API for lists, not an official API: the rows do not come from Google, and Google has not licensed them. You send a category and a city, you get every place in a dataset, with no API key of your own and no per-request quota to manage.

#### How fresh is the data?

Each row has `lastUpdated`, the date the provider last refreshed the place. On 9 November 2026 most places were updated in September or October 2026.

#### Why does my city return nothing?

The city name must be the English name used by Google Maps, with the right case. `München` and `munich` return nothing, `Munich` returns the places. A misspelled category returns a warning with the closest known names.

#### Why are some places on Maps missing?

The provider does not hold every listing. In our tests the database had 131 of 132 pizzerias in Paris 2nd district, 200 of 200 dentists in Lyon and 143 of 166 plumbers in Brooklyn, where the missing listings were mostly lead-generation pages with no reviews.

#### Can I get emails or reviews?

No. You get the phone, the website, the rating, the number of reviews, the count per star and the topics people mention. There is no email field and no review text.

#### Is it legal?

The rows are public Google Maps listing data, collected by a third-party data provider, DataForSEO. They do not come from Google's official Places API, and Google has not licensed them. This actor is not affiliated with Google.

Some of the data is personal data. The name of a sole trader, a phone number or an address that points to one person are personal data under the GDPR and similar laws. When you use the rows, you are the data controller, and these rules are yours to follow:

- **Legal basis.** In Europe, B2B prospecting usually relies on legitimate interest. Write down why your interest outweighs the person's, and only keep the fields you need.
- **Inform and let people object.** Say where you got the data at your first contact, and honour any objection at once. Keep a do-not-contact list and check every new list against it.
- **Unsubscribe.** Every email needs a working way to opt out.
- **Channel rules.** Email and SMS to individuals and sole traders often need prior consent under the ePrivacy rules in Europe. In France, do not cold-call numbers registered on Bloctel. In the US, follow CAN-SPAM for email and the TCPA and Do Not Call rules for calls and texts.
- **Retention.** Delete the rows you no longer use.

This is general information, not legal advice. Check the rules of the countries you contact with a lawyer.

#### Something is missing or broken

Open an issue on the **Issues** tab with the run link. Include the run id and the input.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Google Maps Scraper page](https://alexis.morain.fr/en/scrapers/google-maps-leads-scraper/) of my site. The [Lead generation family page](https://alexis.morain.fr/en/scrapers/families/lead-generation/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

## `categories` (type: `array`):

Google Maps categories, one per line: an id (<code>plumber</code>) or a label (<code>Pizza restaurant</code>). Over 5,000 categories are known; an unknown one is ignored with a warning that suggests the closest ones. More than 10 are searched in groups of 10 and places found twice are delivered once. Give at least one category or a title keyword.

## `titleKeyword` (type: `string`):

Keeps places whose name contains this text, case-insensitive (<code>emergency</code> finds <b>24-Hour Emergency Plumbers</b>). Up to 200 characters. Can replace the categories.

## `cities` (type: `array`):

One city per line, written as Google Maps shows it: <b>English name, case-sensitive</b> (<code>Munich</code> finds 263 places, <code>München</code> finds none). Needs a country code. Cannot be combined with coordinates.

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

Country of the places (ISO two-letter code). Required with cities; on its own it searches the whole country.

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

Centre of a circular search area, with longitude and radius. Example: <code>40.7128</code>. Cannot be combined with cities.

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

Example: <code>-74.006</code>.

## `radiusKm` (type: `number`):

Radius of the search area in kilometres, from 1 to 100,000.

## `minRating` (type: `number`):

Keep places rated at least this (1 to 5).

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

Keep places with at least this many reviews.

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

Keep places with at most this many reviews, to find businesses that are still small.

## `claimed` (type: `string`):

<b>Claimed</b>: the owner manages the listing. <b>Unclaimed</b>: nobody does, a common sales angle.

## `withoutWebsite` (type: `boolean`):

Keeps places that have no website in the database: the classic web design and local SEO lead list. Turn on <b>Full details</b> to check each one against today's listing (<code>websiteVerified</code>).

## `withPhoneOnly` (type: `boolean`):

Drops places without a phone number.

## `sortBy` (type: `string`):

Order of the places. Matters when <b>Maximum places</b> is lower than the number found.

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

Upper limit of places delivered (and charged) in this run. Pages are read 1,000 places at a time.

## `fullDetails` (type: `boolean`):

Reads today's Google Maps listing of each place: current website, contact link, booking link, fresh rating and review count (<code>details</code>). Slower: details come back in about 2 minutes per batch. A place whose details do not come back in time is delivered at the plain place price with <code>detailsStatus</code> <b>failed</b>.

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

Language of the full details.

## `monitor` (type: `boolean`):

Delivers only places you have not received yet. The first run reads everything; later runs search only places first seen since the last complete check. Schedule it daily or weekly.

## `watchName` (type: `string`):

Names the memory of the watch, so you can keep several watches on the same search. Empty: derived from the search itself.

## `webhookUrl` (type: `string`):

Optional. A summary of the run is posted here when it ends (Slack, Discord, Zapier, Make). The URL is never written to the log.

## `cacheMaxAgeHours` (type: `integer`):

The business database is refreshed over several days. A search identical to one already made <b>from your account</b> within this many hours is answered from a cache stored in your account (named key-value store <code>google-maps-leads-cache</code>), with the same places. Set to <code>0</code> to always fetch fresh data. Watch runs always fetch fresh data.

## Actor input object example

```json
{
  "categories": [
    "plumber"
  ],
  "cities": [
    "Brooklyn"
  ],
  "countryCode": "US",
  "claimed": "any",
  "withoutWebsite": false,
  "withPhoneOnly": false,
  "sortBy": "reviews",
  "maxItems": 1,
  "fullDetails": false,
  "language": "en",
  "monitor": false,
  "cacheMaxAgeHours": 72
}
```

# Actor output Schema

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

All places in the default dataset.

## `summary` (type: `string`):

Places delivered, search pages read, events charged, why the run stopped, watch counters.

# 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 = {
    "categories": [
        "plumber"
    ],
    "cities": [
        "Brooklyn"
    ],
    "countryCode": "US",
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/google-maps-leads-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 = {
    "categories": ["plumber"],
    "cities": ["Brooklyn"],
    "countryCode": "US",
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/google-maps-leads-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 '{
  "categories": [
    "plumber"
  ],
  "cities": [
    "Brooklyn"
  ],
  "countryCode": "US",
  "maxItems": 1
}' |
apify call alexmorain/google-maps-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/google-maps-leads-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/WWB0inbTXgEgfQaKX/builds/r6Owkfl2uopn1UeCC/openapi.json
