# 📍 Google Maps Leads Scraper (`data_minds/google-maps-leads-scraper`) Actor

Scrape Google Maps into ready-to-use business leads: name, address, phone, website, rating, reviews, hours, categories and socials. Search by term and location or paste Maps URLs. Rich filters, no API key, results streamed live.

- **URL**: https://apify.com/data_minds/google-maps-leads-scraper.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Categories:** Lead generation, SEO tools, Travel
- **Features:** Limited permissions
- **Stats:** 24 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.90 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### What is Google Maps Leads Scraper?

**Google Maps Leads Scraper** turns Google Maps searches into ready-to-use business lead lists. Enter a search term and a location, or paste Maps links, and get names, addresses, phone numbers, websites, ratings, emails and social profiles. No API key is needed. From **$0.0049 per lead on the Gold plan**.

Just add a search term such as `coffee shop`, add a place such as `Austin, Texas`, and click **Start**. No coding is needed. Typical ways to use it:

- **Lead generation for agencies:** Google Maps lead generation for agencies and local businesses starts with a lead list by category and city, imported into your CRM. Extract business leads from Google Maps by niche, then generate B2B leads from Google Maps for each client.
- **B2B prospecting:** use it as a prospecting tool for B2B lead generation on Google Maps. Build a lead list for sales prospecting with websites, phones and emails, and find local business phone numbers in one run. It shows how to scrape Google Maps for B2B leads without manual copying.
- **Cold email lead list:** build a cold email lead list for local businesses, or Google Maps leads for cold email outreach, by keeping places with a website and checking each email.
- **Find businesses without a website:** the Website filter returns businesses without websites as leads. It works as a Google Maps missing website finder. Google Maps no website leads make good web design prospects.
- **Local market research:** compare ratings, categories and opening status across a city, county or postal code.
- **Scheduled list building:** run the same search on a schedule so your lead data stays fresh.

Because it runs on Apify, you also get the API, scheduling, webhooks, integrations and export of Google Maps data to CSV, Excel, JSON, XML or HTML. It works as a Google Maps scraper without an API key.

#### What can Google Maps Leads Scraper do?

- 🔍 **Google Maps extractor for bulk search:** run many search terms in one run, with places de-duplicated across the whole run.
- 📧 **Google Maps email extractor:** add emails, phone numbers and eight kinds of social profile links for businesses that have a website.
- 🎯 **Google Maps lead finder with filters:** category keywords, minimum rating, name matching, with or without a website, skip closed places.
- 📞 **Google Maps contact extractor:** each lead can carry a listing phone, website phones and social media links in one row.
- 📍 **Scraper by city or zip code:** use a free-text location, or city, county, state and postal (zip) code, plus country and language. Get Google Maps leads by category and city.
- 🔗 **Start from Maps links:** paste place links instead of search terms.
- ✅ **Check emails:** optionally flag disposable, free-mail and role addresses and whether each email looks deliverable.

***

### What data can Google Maps Leads Scraper extract?

Every lead is one dataset item. These are the exact field names.

| Data | Fields |
|---|---|
| 🏪 Business | `title`, `description`, `categoryName`, `categories` |
| 📍 Address | `address`, `street`, `neighborhood`, `city`, `state`, `postalCode`, `countryCode` |
| 🧭 Location | `location` (`lat`, `lng`), `timeZone` |
| 📞 Phone from the listing | `phone`, `phoneUnformatted` |
| 🌐 Website | `website` |
| ⭐ Rating | `totalScore` |
| 🕒 Status and hours | `todayHours`, `openStatusText`, `permanentlyClosed`, `temporarilyClosed` |
| 📝 Attributes and photo | `additionalInfo`, `imageUrl` |
| 🔑 Identifiers and link | `placeId`, `cid`, `googleKgId`, `url` |
| 🔎 Search context | `rank`, `searchString` |
| 📧 Website contacts | `emails`, `phones`, `phonesUncertain` |
| 🔗 Social profiles | `linkedIns`, `twitters`, `instagrams`, `facebooks`, `youtubes`, `tiktoks`, `pinterests`, `discords` |
| ✅ Email checks | `emailsVerification` |
| 🚫 Always empty | `price`, `reviewsCount`, `claimThisBusiness` |

Each lead carries Google Maps ratings and opening hours data, and coordinates as latitude and longitude data, in one record. Google Maps social media links appear in the social fields.

> **Note:** `website`, `phone` and `description` are empty when the place does not list them. `emails`, `phones`, `phonesUncertain` and the social fields are filled only when the place has a website and **Collect emails & social profiles** is on. `emailsVerification` is filled only when **Verify email addresses** is on.

#### What data can't Google Maps Leads Scraper extract?

- Review text and review counts: `reviewsCount` is always `null`.
- Price level and ownership status: `price` and `claimThisBusiness` are always `null`.
- The full weekly schedule: only `todayHours` and `openStatusText` are returned.

For a different lead workflow, see the [Google Maps Email And Phone Number Scraper](https://apify.com/data_minds/google-maps-email-and-phone-number-scraper).

***

### How to scrape Google Maps leads

This Actor is designed for an easy start, even if you have never extracted data from the web before.

1. [Create a free Apify account](https://console.apify.com/sign-up) with your email.
2. Open [Google Maps Leads Scraper](https://apify.com/data_minds/google-maps-leads-scraper).
3. Add one or more search terms in **Search terms** (`searchStringsArray`).
4. Enter a **Location** (`locationQuery`) and set **Places per search term** (`maxCrawledPlacesPerSearch`).
5. Switch filters on or off, such as **Website filter** or **Minimum rating**.
6. Click **Start** and wait for the run to finish.
7. Download your leads in JSON, CSV, Excel, XML or HTML from the **Output** tab.

***

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

This Actor uses **pay-per-event** pricing: you pay for each lead saved to the dataset, and Apify platform usage is billed in addition. The price per lead depends on your Apify plan.

| Plan | Price per lead | Price per 1,000 leads |
|---|---|---|
| Free | $0.007 | $7.00 |
| Bronze | $0.0054 | $5.40 |
| Silver | $0.0056 | $5.60 |
| Gold | $0.0049 | $4.90 |

A small start charge applies to every run: $0.00005 per GB of memory, minimum one event. The default memory is 4,096 MB (4 GB), so each run starts with 4 events, which is $0.0002.

**Worked example:** collecting 1,000 leads on the Gold plan costs $4.90 for results plus the $0.0002 start charge, with platform usage billed in addition. Collecting 500 leads on the Free plan costs $3.50.

#### Is scraping Google Maps free?

You can start for free. The [Apify Free plan](https://apify.com/pricing) includes $5 of monthly credit, which covers about 714 leads at the Free price of $0.007 per lead ($5 divided by $0.007), before platform usage. See the [pricing tab](https://apify.com/data_minds/google-maps-leads-scraper/pricing) for all events.

***

### Input

The only required input is **Search terms**. Set the input in the Actor interface or send it as JSON through the API. This example searches for coffee shops in Austin and collects 20 places:

```json
{
  "searchStringsArray": ["coffee shop"],
  "locationQuery": "Austin, Texas",
  "maxCrawledPlacesPerSearch": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

See the [input schema](https://apify.com/data_minds/google-maps-leads-scraper/input-schema) for the full description of every field.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchStringsArray` | array | Yes | none | What to look for, one term per line. Every term is searched separately. |
| `locationQuery` | string | No | empty | Free-text place such as `Berlin, Germany`. |
| `maxCrawledPlacesPerSearch` | integer | No | 20 | Places to collect per search term (1 to 5000). |
| `startUrls` | array | No | empty | Direct Google Maps place links. |
| `language` | string | No | `en` | Language of names, categories and descriptions. |
| `countryCode` | string | No | `us` | Country view to search from. |
| `city`, `state`, `county`, `postalCode` | string | No | empty | Precise area fields, combined into one search area. |
| `categoryFilterWords` | array | No | empty | Keep a business only if one word appears in its categories or description. |
| `searchMatching` | string | No | `all` | `all`, `only_includes` or `only_exact` name matching. |
| `placeMinimumStars` | string | No | empty | Minimum rating, from `two` to `fourAndHalf`. |
| `website` | string | No | `allPlaces` | `allPlaces`, `withWebsite` or `withoutWebsite`. |
| `skipClosedPlaces` | boolean | No | `false` | Leave out closed businesses. |
| `scrapeWebsiteContacts` | boolean | No | `true` | Collect emails, phones and social links from each business website. |
| `contactMaxSubpages` | integer | No | 3 | Extra contact or about pages per website (0 to 10). |
| `skipBigChains` | boolean | No | `true` | Skip contact collection for a short list of global chains. |
| `verifyEmails` | boolean | No | `false` | Check every email found. |
| `proxyConfiguration` | object | No | `{"useApifyProxy": false}` | Optional network settings. Leave the default unless you need your own. |
| `browserFallback` | boolean | No | `true` | Adds an extra retry step for difficult requests. |
| `maxConcurrency` | integer | No | 5 | Business websites opened at the same time (1 to 20). |
| `requestDelaySeconds` | number | No | 0.8 | Pause between requests (0 to 10). |
| `maxRetries` | integer | No | 3 | Retries per request (1 to 10). |

#### Location fields

Use either `locationQuery` or the precise fields. If `locationQuery` is filled, it is used and `city`, `county`, `state` and `postalCode` are ignored.

- ✅ Good: `"locationQuery": "Manhattan, NYC"`
- ✅ Good: `"city": "Miami", "state": "Florida"` with `locationQuery` empty
- ❌ Bad: `"locationQuery": "Austin"` together with `"postalCode": "78701"` (the postal code is ignored)

> **Warning:** Location is not applied to links in `startUrls`. With no location at all, the search is not limited to any area.

#### Places per search term and filters

`maxCrawledPlacesPerSearch` limits how many places are collected per term before your filters run. Filters such as `placeMinimumStars`, `website`, `categoryFilterWords` and `skipClosedPlaces` then remove places, so you can receive fewer leads than the limit.

- ✅ Good: raise the limit when you use strict filters.
- ❌ Bad: expect exactly 20 leads when `placeMinimumStars` is `four` and the limit is 20.

> **Warning:** Unrated places are dropped whenever a minimum rating is set.

#### Google Maps links

Paste place links into `startUrls` to collect specific businesses, one link per line. The business named in the link is looked up and the exact match is preferred in the results.

- ✅ Good: a link that opens one business on Google Maps.
- ❌ Bad: a link to your own saved list or to a page that is not a business.

***

### Output

Leads are saved to the run dataset and appear in the **Output** tab as they are found. Choose a table view (Lead Overview, Contacts, Social Profiles, Location & Map, Business Profile, Email Verification or Source & IDs), select only the fields you need, and download in JSON, CSV, Excel, XML or HTML.

#### JSON example

Results for the input example above, with one lead shown:

```json
{
  "rank": 1,
  "searchString": "coffee shop",
  "title": "Example Coffee Roasters",
  "description": "Neighborhood coffee shop.",
  "price": null,
  "categoryName": "Coffee shop",
  "categories": ["Coffee shop", "Cafe"],
  "address": "100 Example Street, Austin, TX 78701, United States",
  "neighborhood": "Downtown",
  "street": "100 Example Street",
  "city": "Austin",
  "postalCode": "78701",
  "state": "Texas",
  "countryCode": "US",
  "website": "https://www.example.com/",
  "phone": "(512) 555-0100",
  "phoneUnformatted": "+15125550100",
  "claimThisBusiness": null,
  "location": {"lat": 30.2672, "lng": -97.7431},
  "totalScore": 4.6,
  "permanentlyClosed": false,
  "temporarilyClosed": false,
  "placeId": "ChIJexample0000000001",
  "cid": "0x1111111111111111:0x2222222222222222",
  "googleKgId": "/g/example",
  "url": "https://www.google.com/maps?cid=1234567890",
  "imageUrl": "https://www.example.com/photo.jpg",
  "timeZone": "America/Chicago",
  "todayHours": "7 am to 6 pm",
  "openStatusText": "Open",
  "additionalInfo": {"Accessibility": [{"Wheelchair accessible entrance": true}]},
  "reviewsCount": null,
  "emails": ["hello@example.com"],
  "phones": ["+15125550101"],
  "phonesUncertain": [],
  "linkedIns": [],
  "twitters": [],
  "instagrams": ["https://www.instagram.com/example"],
  "facebooks": ["https://www.facebook.com/example"],
  "youtubes": [],
  "tiktoks": [],
  "pinterests": [],
  "discords": [],
  "emailsVerification": []
}
```

#### Email verification example

With `verifyEmails` set to `true`, `emailsVerification` contains one object per email:

```json
{
  "emailsVerification": [
    {
      "email": "hello@example.com",
      "free": false,
      "role": true,
      "error": "",
      "quality": "good",
      "result": "ok",
      "subResult": "accepted_email"
    }
  ]
}
```

#### Run summary example

Each run also saves a `run-summary` record in the key-value store:

```json
{
  "source": "google-maps",
  "scrapedAt": "2026-01-01T12:00:00+00:00",
  "leads": 20,
  "searches": 1,
  "placesFound": 20,
  "placesSkippedByFilters": 0,
  "leadsWithEmail": 12,
  "leadsWithPhone": 19,
  "leadsWithWebsite": 15,
  "leadsWithSocialProfile": 10,
  "emailsCollected": 18,
  "durationSeconds": 45.2,
  "perSearch": [{"search": "coffee shop Austin, Texas", "found": 20, "kept": 20}]
}
```

#### Notes and limitations

- Only today's opening hours are returned, not the full week.
- `price`, `reviewsCount` and `claimThisBusiness` are present in every row but always `null`.
- A phone number from the listing is in `phone`. Numbers found on websites are in `phones`, and less certain ones are in `phonesUncertain`.
- Not every business publishes an email, so some leads have an empty `emails` list.

***

### Tips and advanced usage

#### How many results can you scrape with Google Maps Leads Scraper?

The number of leads depends on how many places match your search, your filters, and the limit you set. A single search term returns at most about 600 places in one run, even if the limit is higher. The best way to know for your use case is a quick test run with 10 to 20 places.

#### How to get faster or cheaper results

- Lower `maxCrawledPlacesPerSearch` for a sample before a full run.
- Set `contactMaxSubpages` to 0 or 1 to finish faster when you only need the homepage contacts.
- Turn off `scrapeWebsiteContacts` if you only need listing data.
- Split a large city into several searches by postal code to reach more places.
- Keep `verifyEmails` off unless you need the extra checks.

#### Known issues

- While `skipBigChains` is on, contact collection is skipped for a short list of global chains, so those leads have empty contact lists.
- Businesses that publish no website or no email return empty contact lists.

***

### Integrations and API

#### Can I use Google Maps Leads Scraper as an API?

Yes. The [Apify API](https://docs.apify.com/api/v2) gives you programmatic access to this Actor: start runs, schedule them and fetch results. Use the `apify-client` package for Node.js or Python. See the [API tab](https://apify.com/data_minds/google-maps-leads-scraper/api) for ready-to-use code.

#### How to scrape Google Maps with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("data_minds/google-maps-leads-scraper").call(run_input={
    "searchStringsArray": ["coffee shop"],
    "locationQuery": "Austin, Texas",
    "maxCrawledPlacesPerSearch": 20,
    "proxyConfiguration": {"useApifyProxy": False},
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["emails"])
```

#### Can I integrate Google Maps Leads Scraper with other apps?

Yes. Extract leads from Google Maps to Google Sheets, Make, Zapier, Slack and more through [Apify integrations](https://apify.com/integrations). Use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger an action when a run finishes, and use Apify schedules to rerun a search daily, weekly or monthly.

#### Can I use Google Maps Leads Scraper with AI agents (MCP)?

Yes. Connect it to Claude and other AI assistants through the Apify MCP server. Open the [MCP tab](https://apify.com/data_minds/google-maps-leads-scraper/api/mcp) for setup steps.

***

### Other Google Maps scrapers

| Actor | What it does |
|---|---|
| 📧 [Google Maps Email And Phone Number Scraper](https://apify.com/data_minds/google-maps-email-and-phone-number-scraper) | Finds business emails and phone numbers behind Google Maps places, with email verification and generic-address filters. |
| 🔗 [Dubai Real Estate Scraper — Unit Number & DLD Permit Checker](https://apify.com/data_minds/uae-dubai-property-leads-scraper) | Scrape Dubai real estate listings and get the DLD-verified unit number, RERA permit status, price, size and agent contacts. |
| 🎯 [Website Lead Intelligence](https://apify.com/data_minds/website-lead-intelligence-find-the-right-person-verified) | Turns a list of company websites into a scored outreach list with verified emails and named decision-makers. |
| 🔗 [Podcast Directory Scraper — Host Contacts & Emails](https://apify.com/data_minds/podcast-directory-scraper) | Search the Apple Podcasts directory by keyword, chart or link and get host emails, owner names, websites, social profiles, ratings, publishing... |

***

### FAQ

#### Is it legal to scrape Google Maps?

Web scraping is generally legal when you extract publicly available data, but respect personal data rules such as GDPR and the site's terms. Collect personal data only for a legitimate reason. Read [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) for background. This is not legal advice; consult a lawyer.

#### How does Google Maps Leads Scraper work?

You give it search terms and a location, or Maps links. The run collects the matching businesses, applies your filters, adds contact details from each business website if you enabled that option, and saves one lead per business to the dataset. You then export the results or fetch them through the API.

#### Why scrape Google Maps leads?

Google Maps lists local businesses with their category, address and rating. Collecting that data into a spreadsheet lets you build prospect lists for sales, find businesses without a website for web design offers, compare competitors in a city, and prepare cold email outreach, instead of copying details by hand one listing at a time.

#### Can I get emails from Google Maps?

Yes, when the business has a website. Keep Collect emails & social profiles on, and the Actor adds any emails, phone numbers and social links it finds on that website to the lead. Businesses that publish no email return an empty list. You can also turn on email verification to flag weak addresses.

#### Why am I getting fewer results than expected?

The limit applies to places collected before your filters. Minimum rating, website filter, category keywords, name matching and closed-place filters remove places afterwards. Duplicate places across search terms are also removed. Raise the places limit, loosen the filters, widen the location, or split a large area into several searches.

#### How do I find businesses without a website?

Set the Website filter to `withoutWebsite` and run your search. Only places that list no website are saved. You can combine it with a minimum rating and a category word to focus on well-rated businesses in one niche, which makes a useful prospect list for web design or marketing services.

#### Can I export Google Maps leads to CSV or Excel?

Yes. Every run stores results in a dataset that you can download as JSON, CSV, Excel, XML or HTML. Pick a table view or select only the fields you need first. You can also send the results to Google Sheets with an integration or read them through the Apify API.

#### Google Maps Leads Scraper not working?

First, check the run log and the input. Make sure Search terms is filled, the location is spelled correctly, and your filters are not too strict. Then try a smaller test run. If the problem continues, open an issue on the Issues tab with your run link so the team can look into it.

***

### Support and feedback

Found a bug or have a feature request? Please create an issue on the [Issues tab](https://apify.com/data_minds/google-maps-leads-scraper/issues/open).

Need a custom solution or more data? Contact us at hello.dataminds@gmail.com.

Built and maintained by the [data_minds](https://apify.com/data_minds) team on Apify. This Actor is an independent tool, is not affiliated with or endorsed by [Google Maps](https://www.google.com/maps), and you are responsible for using the data in line with applicable laws and terms.

# Changelog

This Actor's version history is a separate document: https://apify.com/data_minds/google-maps-leads-scraper/changelog.md

# Actor input Schema

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

🗺️ What to look for — for example `restaurant`, `dentist`, `plumber near me`, `marketing agency`. Every term is searched separately.

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

📌 Free-text place to search in — `Austin, Texas`, `Berlin, Germany`, `Manhattan, NYC`. Leave empty to search worldwide (or use the precise fields below).

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

🎁 How many businesses to collect for each search term. Start with 10–20 for a quick sample, raise it for a full harvest.

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

📎 Paste direct Google Maps place links to collect specific businesses. Bulk input supported — one URL per line, or upload a file.

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

🌐 Language for names, categories and descriptions.

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

🧭 Which country's Google Maps view to search from.

## `city` (type: `string`):

🏙️ City name — for example `Miami`.

## `state` (type: `string`):

🗺️ State, province or region — for example `Florida`.

## `county` (type: `string`):

📐 County or district, when you need to narrow it further.

## `postalCode` (type: `string`):

📮 ZIP / postal code — the tightest area filter.

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

🏷️ Keep a business only when one of these words appears in its Google categories or description — for example `bakery`, `law firm`, `gym`.

## `searchMatching` (type: `string`):

🔍 How strictly the business name must match your search term.

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

⭐ Drop businesses rated below this. Unrated places are dropped too when a minimum is set.

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

🌐 Businesses with a website give you emails and socials. Businesses without one are perfect web-design prospects.

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

🚪 Leave out anything marked permanently or temporarily closed.

## `scrapeWebsiteContacts` (type: `boolean`):

📬 Visit each business website and pull out email addresses, phone numbers, LinkedIn, Instagram, Facebook, X, YouTube, TikTok, Pinterest and Discord links.

## `contactMaxSubpages` (type: `integer`):

🔍 How many extra contact/about pages to open per website. More pages find more emails and take a little longer.

## `skipBigChains` (type: `boolean`):

🏬 Global chains rarely publish a useful contact email. Keep this on to spend the time on real local prospects.

## `verifyEmails` (type: `boolean`):

🧪 Check every email found for disposable, free-mail and role addresses and whether it looks deliverable. No third-party key needed.

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

🚦 By default the run manages its network settings automatically. Choose your own settings here only if you need them.

## `browserFallback` (type: `boolean`):

🧭 Adds an extra retry step for difficult requests when normal retries do not work.

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

🏎️ How many business websites to open at the same time.

## `requestDelaySeconds` (type: `number`):

🕰️ A small pause keeps the run polite and stable.

## `maxRetries` (type: `integer`):

🛡️ How many times a failed request is retried.

## Actor input object example

```json
{
  "searchStringsArray": [
    "coffee shop"
  ],
  "locationQuery": "Austin, Texas",
  "maxCrawledPlacesPerSearch": 20,
  "startUrls": [],
  "language": "en",
  "countryCode": "us",
  "city": "",
  "state": "",
  "county": "",
  "postalCode": "",
  "categoryFilterWords": [],
  "searchMatching": "all",
  "placeMinimumStars": "",
  "website": "allPlaces",
  "skipClosedPlaces": false,
  "scrapeWebsiteContacts": true,
  "contactMaxSubpages": 3,
  "skipBigChains": true,
  "verifyEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "browserFallback": true,
  "maxConcurrency": 5,
  "requestDelaySeconds": 0.8,
  "maxRetries": 3
}
```

# Actor output Schema

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

All items collected in this run, as stored in the default dataset.

## `runSummary` (type: `string`):

Run summary JSON: totals and counts.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchStringsArray": [
        "coffee shop"
    ],
    "locationQuery": "Austin, Texas",
    "maxCrawledPlacesPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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