# Google Maps Email Scraper (`scrapers-hub/google-maps-email-scraper`) Actor

Google Maps Email Scraper finds local businesses then crawls their websites for emails - returning name, full address, phone, website, rating, review count, coordinates, place ID and every email found. 📍 Local lead generation on autopilot.

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

## Pricing

from $2.99 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### 📍 Google Maps Email Scraper – Extract Business Emails, Phones & Contact Data

The **Google Maps email scraper** searches Google Maps for businesses matching a keyword and a location, then visits each business website to pull out email addresses, phone numbers and social media profiles, returning a single enriched record per business. It turns a plain local-search query such as "coffee shops in Miami, Florida" into a structured B2B lead list with verified contact data attached.

Google Maps itself rarely exposes an email address. It gives you a name, an address, a rating and — if you are lucky — a website URL. This Google Maps email scraper closes that gap: it takes the `website` value from each place listing, crawls the site's contact-bearing pages, harvests every email it finds, and then runs those addresses through a multi-stage validation pipeline covering syntax, DNS, MX records and SMTP reachability. The result is a lead record you can actually send to, not just a directory row.

Every field is returned flat and machine-readable, from `place_id` and geographic coordinates through to `confidence_score` and `is_role_based` flags, so the output drops straight into a CRM import, a cold-outreach sequence or a territory analysis spreadsheet.

***

### 📊 What Data Can You Extract with This Google Maps Email Scraper?

The Google Maps email scraper combines place data, website crawl results and email verification signals into one record per business.

| Category | Fields | What you get |
|---|---|---|
| 🏢 Business identity | `name`, `place_id`, `platform`, `url`, `website`, `domain` | The business name, its stable Google Maps place identifier, the source platform, and the website that was crawled for contact details |
| 📍 Location & geography | `street_address`, `city`, `state`, `zip`, `country_code`, `full_address`, `lat`, `long` | A fully decomposed postal address plus latitude and longitude for mapping and radius analysis |
| ⭐ Reputation signals | `avg_rating`, `total_reviews` | Average star rating and total review count, useful for qualifying and prioritising leads |
| 📧 Contact extraction | `email`, `emails`, `phone`, `scraped_emails`, `scraped_phones`, `scraped_social_media` | The primary email, all emails found, phone numbers and social profile links harvested from the business website |
| ✅ Email verification | `syntax_valid`, `dns_valid`, `mx_valid`, `smtp_valid`, `is_disposable`, `is_role_based`, `confidence_score`, `validation_errors` | A layered deliverability assessment for each address, from format checking to mail-server reachability |
| 🔍 Crawl diagnostics | `emails_found`, `pages_scraped`, `scrape_status`, `scrape_error`, `status`, `job_id`, `error` | How many pages were visited, how many addresses were recovered, and exactly what went wrong when a site could not be crawled |

The field that changes how you work with this data is `confidence_score`. Rather than forcing a binary valid/invalid decision, it lets you segment: send to high-confidence addresses immediately, route mid-range addresses through a warm-up sequence, and discard the rest. Combined with `is_role_based`, it separates a named contact from a generic `info@` inbox before you write a single line of outreach copy.

***

### 🌟 Key Features of the Google Maps Email Scraper

| Feature | Description |
|---|---|
| 🔎 Keyword and location search | Drive the whole run from two fields — a business type such as "dentists" and a geographic target such as "Miami, Florida" |
| 🌐 Website contact crawling | Each business website is crawled for contact pages so emails and phone numbers are recovered even when Google Maps shows none |
| ✅ Four-layer email validation | Every address is checked for syntax correctness, DNS resolution, MX record presence and SMTP reachability |
| 🚫 Disposable and role-based detection | `is_disposable` and `is_role_based` flags let you strip throwaway inboxes and generic aliases before import |
| 📊 Confidence scoring | A numeric `confidence_score` per address supports tiered outreach instead of a blunt keep-or-drop rule |
| 🧭 Full geographic decomposition | Street, city, state, ZIP, country code and coordinates are returned separately, ready for territory mapping |
| 🎯 Email-only filtering | Turn on `emailOnlyResults` to discard businesses where no email could be recovered, keeping the dataset lead-ready |
| 📱 Social profile harvesting | `scraped_social_media` collects social links found on the business site for multichannel prospecting |
| 🩺 Per-business diagnostics | `pages_scraped`, `scrape_status` and `scrape_error` make it obvious why a particular business yielded nothing |

***

### 🚀 Why Choose This Google Maps Email Scraper?

**Emails, not just listings.** The overwhelming majority of Google Maps tools stop at the place record. This Google Maps email scraper treats the `website` field as a starting point rather than an endpoint, crawling each site to recover `scraped_emails`, `scraped_phones` and `scraped_social_media` that are simply not present in map data.

**Verification is built in, not bolted on.** Running an unverified list through a sending platform damages your domain reputation fast. Because `syntax_valid`, `dns_valid`, `mx_valid` and `smtp_valid` arrive with every record, you can filter hard bounces out before the first campaign rather than after it.

**Transparent failure reporting.** When a business produces no contact data, you are told why. `scrape_status`, `scrape_error` and `pages_scraped` distinguish a site that blocked the crawler from one that genuinely publishes no address, which means you know whether a manual follow-up is worth the effort.

**Geographic precision for territory work.** Because `lat`, `long`, `zip`, `city` and `state` are separate fields, the output supports radius queries, postcode-level segmentation and sales-territory assignment without any post-processing or geocoding step.

***

### 📥 Input

The Google Maps email scraper is driven by a short input object. The search term and location are both required.

```json
{
  "googleMapsSearchTerm": "coffee shops",
  "googleMapsLocation": "Miami, Florida",
  "maxBusinesses": 20,
  "emailOnlyResults": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### 🔧 Google Maps Email Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `googleMapsSearchTerm` | string | ✅ Yes | `coffee shops` | The business type or niche to search for, for example "coffee shops" or "dentists". |
| `googleMapsLocation` | string | ✅ Yes | `Miami, Florida` | Target geographic location for the search, for example "Miami, Florida". |
| `maxBusinesses` | integer | No | `20` | Target number of businesses to find, between 1 and 1000. The scraper stops once this target is reached. |
| `emailOnlyResults` | boolean | No | `false` | Only include businesses where emails were successfully extracted from their websites. |
| `proxyConfiguration` | object | No | `{ "useApifyProxy": true }` | Proxy settings for scraping, recommended for large-scale runs. |

#### 💡 Input Examples

**Small qualifying sample**

```json
{
  "googleMapsSearchTerm": "dentists",
  "googleMapsLocation": "Austin, Texas",
  "maxBusinesses": 25
}
```

**Lead-ready list with emails only**

```json
{
  "googleMapsSearchTerm": "digital marketing agency",
  "googleMapsLocation": "London, United Kingdom",
  "maxBusinesses": 200,
  "emailOnlyResults": true
}
```

**Large territory sweep**

```json
{
  "googleMapsSearchTerm": "plumbers",
  "googleMapsLocation": "Phoenix, Arizona",
  "maxBusinesses": 800,
  "emailOnlyResults": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### 📤 Output

Each dataset item is one business, combining its Google Maps place data with everything recovered from its website. The example below uses the real output field names with representative values.

```json
{
  "job_id": "8c1f9d2e-4b17-4a90-9a2c-6f5d3b0e77a1",
  "status": "success",
  "name": "Brew & Bean Coffee Roasters",
  "place_id": "ChIJd8BlQ2BZwokRAFUEcm_qrcA",
  "platform": "google_maps",
  "website": "https://brewandbeanroasters.com",
  "domain": "brewandbeanroasters.com",
  "phone": "+1 305-555-0142",
  "full_address": "812 Biscayne Blvd, Miami, FL 33132, United States",
  "street_address": "812 Biscayne Blvd",
  "city": "Miami",
  "state": "FL",
  "zip": "33132",
  "country_code": "US",
  "lat": 25.782551,
  "long": -80.189567,
  "avg_rating": 4.6,
  "total_reviews": 318,
  "email": "hello@brewandbeanroasters.com",
  "emails": ["hello@brewandbeanroasters.com", "orders@brewandbeanroasters.com"],
  "emails_found": 2,
  "pages_scraped": 6,
  "syntax_valid": true,
  "dns_valid": true,
  "mx_valid": true,
  "smtp_valid": true,
  "is_disposable": false,
  "is_role_based": true,
  "confidence_score": 0.92,
  "validation_errors": [],
  "scraped_emails": ["hello@brewandbeanroasters.com", "orders@brewandbeanroasters.com"],
  "scraped_phones": ["+1 305-555-0142"],
  "scraped_social_media": ["https://instagram.com/brewandbeanroasters"],
  "scrape_status": "completed",
  "scrape_error": null,
  "url": "https://www.google.com/maps/place/?q=place_id:ChIJd8BlQ2BZwokRAFUEcm_qrcA",
  "error": null
}
```

#### 🧾 Google Maps Email Scraper Output Fields

| Field | Type | Description |
|---|---|---|
| `job_id` | string | null | Identifier of the job. |
| `status` | string | null | Status of the item. |
| `name` | string | null | Name of the business. |
| `place_id` | string | null | Identifier of the place on Google Maps. |
| `platform` | string | null | Platform the item came from. |
| `url` | string | null | Canonical URL of the scraped item. |
| `website` | string | null | Website address of the business. |
| `domain` | string | null | Domain name derived from the website. |
| `phone` | string | null | Phone number found for the business. |
| `full_address` | string | null | Full address of the business. |
| `street_address` | string | null | Street address of the business. |
| `city` | string | null | City. |
| `state` | string | null | State or region. |
| `zip` | string | null | ZIP or postal code. |
| `country_code` | string | null | ISO country code. |
| `lat` | number | null | Latitude coordinate. |
| `long` | number | null | Longitude coordinate. |
| `avg_rating` | number | null | Average review rating. |
| `total_reviews` | integer | null | Total number of reviews. |
| `email` | string | null | Primary email address found for the business. |
| `emails` | array | null | All email addresses found for the business. |
| `emails_found` | integer | null | Number of emails found. |
| `pages_scraped` | integer | null | Number of website pages scraped. |
| `syntax_valid` | boolean | null | Whether the email address is syntactically valid. |
| `dns_valid` | boolean | null | Whether the email domain resolves in DNS. |
| `mx_valid` | boolean | null | Whether the domain has valid MX records. |
| `smtp_valid` | boolean | null | Whether the mailbox responded over SMTP. |
| `is_disposable` | boolean | null | Whether the address belongs to a disposable email provider. |
| `is_role_based` | boolean | null | Whether the address is a role-based alias such as info@ or sales@. |
| `confidence_score` | number | null | Score expressing confidence in the address. |
| `validation_errors` | array | null | Validation errors collected for the item. |
| `scraped_emails` | array | null | Email addresses scraped from the business website. |
| `scraped_phones` | array | null | Phone numbers scraped from the business website. |
| `scraped_social_media` | array | null | Social media profile links scraped from the business website. |
| `scrape_status` | string | null | Status of the website crawl. |
| `scrape_error` | string | null | Error encountered during the website crawl. |
| `error` | string | null | Error message, if the item failed to process. |

***

### 💻 How to Use the Google Maps Email Scraper (Step by Step)

#### Step 1: Define Your Google Maps Search Term

`googleMapsSearchTerm` should describe the category of business you want, exactly as you would type it into Google Maps. Broad terms like "restaurants" return large volumes but mixed quality; specific terms like "orthodontist" or "commercial roofing contractor" return fewer results with much tighter intent. If you are building a niche B2B list, run several narrow terms as separate runs rather than one broad term — the aggregate list will be cleaner and easier to segment later.

#### Step 2: Set the Geographic Target

`googleMapsLocation` accepts a natural location string such as "Miami, Florida" or "Manchester, United Kingdom". Google Maps results are strongly geography-bound, so a city-level target usually returns a manageable, coherent set. For nationwide coverage, run the Google Maps email scraper once per metropolitan area and combine the datasets; this gives you far better coverage than a single country-level query, which tends to concentrate on a handful of major cities.

#### Step 3: Choose How Many Businesses to Collect

`maxBusinesses` accepts a value between 1 and 1000 and defaults to 20. The scraper stops once the target is reached. Start small — 20 to 50 — for a first pass. Because the crawl step visits multiple pages per business website, a run of several hundred businesses takes considerably longer than a plain place-listing scrape, so it pays to confirm your search term returns the right kind of business before committing to a large number.

#### Step 4: Decide Whether to Filter to Email-Only Results

`emailOnlyResults` defaults to `false`, meaning every matching business is returned regardless of whether an address was recovered. Keep it off when you want a complete market map including businesses with no web presence — the `phone` and `full_address` fields still make those rows useful for cold calling or direct mail. Turn it on when the dataset is destined straight for an email platform and rows without addresses are just noise.

#### Step 5: Run the Google Maps Email Scraper and Monitor Progress

Start the run from the Apify Console or trigger it through the API. The log reports which businesses are being processed and how the website crawl is going. Watch for a pattern of `scrape_error` values early on — if many sites are failing in the same way, it is usually faster to stop, adjust, and restart than to let a long run complete with sparse results.

#### Step 6: Filter and Grade the Extracted Emails

Once the dataset is ready, apply your own quality bar. A common approach is to keep records where `mx_valid` is `true` and `is_disposable` is `false`, then sort by `confidence_score`. Use `is_role_based` to split generic inboxes from personal-looking addresses and write different opening lines for each. `validation_errors` explains any address that failed, which is worth reviewing before you discard a batch wholesale.

#### Step 7: Export to Your CRM or Outreach Platform

Export the dataset as CSV or Excel for a straightforward spreadsheet import, or pull JSON through the API to feed a CRM directly. Map `name` to the company field, `email` to the primary contact, `full_address` or the decomposed address fields to location, and `website` to the company domain. Keep `place_id` as an external identifier so that repeat runs can be de-duplicated reliably rather than by fuzzy name matching.

***

### 🔌 API Access & Integrations

Trigger the Google Maps email scraper and receive results in one synchronous call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~google-maps-email-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "googleMapsSearchTerm": "coffee shops",
    "googleMapsLocation": "Miami, Florida",
    "maxBusinesses": 50,
    "emailOnlyResults": true
  }'
```

The same run in Python, with quality filtering applied to the results:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "googleMapsSearchTerm": "dentists",
    "googleMapsLocation": "Austin, Texas",
    "maxBusinesses": 200,
    "emailOnlyResults": True,
}

run = client.actor("scrapers-hub/google-maps-email-scraper").call(run_input=run_input)

leads = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("mx_valid") and not item.get("is_disposable"):
        leads.append({
            "company": item.get("name"),
            "email": item.get("email"),
            "phone": item.get("phone"),
            "city": item.get("city"),
            "rating": item.get("avg_rating"),
            "confidence": item.get("confidence_score"),
        })

print(f"{len(leads)} qualified leads")
```

The Actor also connects to Zapier, Make, Google Sheets, Slack and any custom endpoint through Apify webhooks, so a finished run can append rows to a spreadsheet, create CRM records or post a summary to your sales channel automatically.

***

### 💡 Best Use Cases for Google Maps Email Data

#### 🎯 Local B2B Lead Generation

Pair `googleMapsSearchTerm` with a city to build a targeted prospect list, then qualify it on `avg_rating` and `total_reviews` so you approach established businesses first. Because `email`, `phone` and `full_address` all arrive together, the same dataset supports email, phone and direct-mail outreach without a second data purchase.

#### 🗺️ Territory Planning and Field Sales Routing

`lat` and `long` turn the dataset into a mappable layer. Cluster businesses geographically, assign them to reps by `zip` or `city`, and plan efficient visit routes. `full_address` gives you a ready-to-use string for navigation apps and CRM address fields.

#### 📈 Competitive and Market Density Analysis

Running the Google Maps email scraper across several locations for the same search term reveals how densely a category is served in each market. Aggregating `total_reviews` and `avg_rating` by `city` shows where competition is entrenched and where a market looks underserved.

#### 🧹 Contact Database Enrichment and Cleaning

Already have a list of company names? Use the scraper's output to enrich it — `website`, `domain`, `phone` and validated `email` fill in the blanks, while `syntax_valid`, `dns_valid` and `mx_valid` let you retire dead addresses in an existing CRM before they generate bounces.

#### 📣 Multichannel Prospecting Campaigns

`scraped_social_media` captures social profile links found on business websites, so a single run supports coordinated email plus social touches. Combining that with `scraped_phones` gives sales development teams three independent channels per account.

#### 🏪 Franchise and Partner Recruitment

Businesses in adjacent categories are often the best partnership targets. Search for complementary business types in your operating areas, filter to those with a `website` and a recovered `email`, and use `avg_rating` as a proxy for operational quality when prioritising who to approach.

#### 📬 Deliverability-Safe Email List Building

Because `is_disposable`, `is_role_based`, `smtp_valid` and `confidence_score` accompany every address, you can construct a sending list that protects your domain reputation. Segment high-confidence, non-role addresses into your primary sequence and hold everything else for a slower, lower-volume warm-up.

***

### ⚙️ Tips for Better Google Maps Email Scraping Results

- **Run narrow search terms rather than broad ones.** "Italian restaurant" produces a far more coherent list than "food", and narrow terms are easier to write relevant outreach copy for.
- **Split large geographies into city-level runs.** A single country-wide `googleMapsLocation` tends to over-sample big cities. Several city runs give better coverage and let you track cost per market.
- **Start with a low `maxBusinesses` value.** Twenty results is enough to confirm the search term matches the businesses you intend to reach before scaling to hundreds.
- **Leave `emailOnlyResults` off for market research.** Businesses without recoverable emails still carry useful `phone`, `avg_rating` and address data; filter them out later rather than discarding them at collection time.
- **Always filter on `mx_valid` before sending.** An address that passes syntax checks but has no MX record will bounce. This one filter removes the majority of hard bounces.
- **De-duplicate on `place_id`, not on business name.** Names vary between listings and datasets; `place_id` is stable and unique per location, which matters when you merge runs from overlapping areas.

***

### 🛠️ Troubleshooting

**Why do some businesses have no email address?**
Not every business publishes one. Check `pages_scraped` and `scrape_status` — if pages were crawled successfully and `emails_found` is zero, the site genuinely has no visible address. If `scrape_error` is populated, the site blocked or failed the crawl and may be worth a manual look.

**Why did the run return fewer businesses than `maxBusinesses`?**
`maxBusinesses` is a target, not a guarantee. Google Maps returns a finite number of places for a given term and location, so a narrow niche in a small town will legitimately exhaust the available results early. Broaden the search term or widen the location.

**Some emails have `smtp_valid` set to false but look correct. Should I drop them?**
Not necessarily. Many mail servers deliberately refuse verification probes, so `smtp_valid` can be false for a perfectly deliverable address. Treat `mx_valid` as the reliable floor and use `smtp_valid` and `confidence_score` together as a ranking signal rather than a hard filter.

**Why are most of my results role-based addresses like info@ or contact@?**
That is normal for small local businesses, which typically publish a single shared inbox. `is_role_based` flags them so you can adjust tone and expectations. Role addresses often still reach a decision-maker at a small company, even though they perform poorly at larger organisations.

**The run is taking a long time. What is happening?**
Each business with a website triggers a multi-page crawl, so runtime scales with `maxBusinesses` rather than being fixed. Lower `maxBusinesses`, or split the work into several smaller runs by location so partial results are available sooner.

***

### ❓ Frequently Asked Questions About Google Maps Email Scraping

**What is a Google Maps email scraper?**
It is a tool that searches Google Maps for businesses matching a keyword and location, then visits each business website to extract email addresses, phone numbers and social profiles, returning one enriched record per business.

**Does Google Maps show business email addresses directly?**
Almost never. Google Maps listings carry a name, address, phone and sometimes a website, but not an email. This Actor recovers emails by crawling the linked website, which is why `website` and `domain` appear alongside the contact fields.

**How do I search a specific city or region?**
Set `googleMapsLocation` to a natural location string such as "Miami, Florida" or "Manchester, United Kingdom". For multi-region coverage, run the scraper once per area and merge the datasets.

**How many businesses can I scrape in one run?**
`maxBusinesses` accepts values from 1 to 1000, with a default of 20. The scraper stops as soon as the target is reached or the available results run out.

**Can I get only businesses that have an email address?**
Yes. Set `emailOnlyResults` to `true` and businesses where no email could be extracted are excluded from the dataset.

**How are the extracted emails validated?**
Each address is checked across four layers, reported as `syntax_valid`, `dns_valid`, `mx_valid` and `smtp_valid`, with additional `is_disposable` and `is_role_based` flags and an overall `confidence_score`.

**What does `confidence_score` mean in practice?**
It is a numeric quality signal for the address. Use it to tier your outreach — highest scores first, mid-range through a slower warm-up sequence — rather than as a single yes/no threshold.

**What is the difference between `email` and `emails`?**
`email` is the single primary address selected for the business, while `emails` is the full array of addresses recovered. `scraped_emails` holds what the website crawl found before selection.

**Can I export the Google Maps email scraper results to CSV or Excel?**
Yes. Apify datasets export as JSON, JSONL, CSV, Excel, XML and RSS directly from the Console, or through the dataset API.

**How do I avoid duplicates when merging several runs?**
De-duplicate on `place_id`. It is unique and stable per Google Maps location, unlike business names which vary in punctuation and formatting between listings.

**Can I use the coordinates for mapping?**
Yes. `lat` and `long` are returned as numbers per business, so the dataset plots directly onto any mapping tool and supports radius filtering without a separate geocoding step.

**Does the scraper find phone numbers as well as emails?**
Yes. `phone` carries the number associated with the business, and `scraped_phones` holds any additional numbers discovered during the website crawl.

**What does `pages_scraped` tell me?**
It reports how many pages of the business website were visited. A value of zero alongside a populated `scrape_error` means the crawl never got started, which usually points to a blocked or offline site rather than a business with no contact details.

**Can I schedule the Google Maps email scraper to run regularly?**
Yes. Apify Schedules let you run it on a cron expression, which is useful for tracking new business openings in a territory or refreshing a lead list monthly.

**Is scraping business contact details from Google Maps legal?**
The Actor collects publicly available business information. How you use it is governed by data-protection law in your jurisdiction and by the marketing rules that apply to your outreach. See the disclaimer below.

***

### 🆘 Support & Feedback

Hit a problem with the Google Maps email scraper? Report it on the **Issues** tab of the Actor page, including your input configuration and the run ID so the behaviour can be reproduced.

Need something tailored? For custom search logic, additional enrichment steps, a different validation policy or direct integration with your CRM, get in touch at **scraperhubapi@gmail.com** with a short description of your requirements.

If the Actor helped you build a usable lead list, a review on the Apify Store is genuinely appreciated. Feedback from real users guides which improvements get built next.

***

### ⚖️ Disclaimer

This Google Maps email scraper collects publicly available business information — listings, published websites and the contact details businesses choose to display on them. It does not access private accounts, bypass authentication or retrieve data hidden behind a login.

You are responsible for how the collected data is used. Business contact details can still constitute personal data under the GDPR, the CCPA, PECR and equivalent regimes, particularly where an address identifies an individual. Before running outreach, establish a lawful basis, honour opt-out requests promptly, include the disclosures your jurisdiction requires, and store only what you genuinely need for as long as you need it.

Respect the terms of service of Google Maps and of every website crawled during a run, along with any applicable rate limits and robots directives. Marketing to the addresses in this dataset is subject to anti-spam legislation such as CAN-SPAM, CASL and the ePrivacy rules, and compliance is entirely the user's responsibility.

If you want data about you or your business removed from a dataset produced by this Actor, contact **scraperhubapi@gmail.com** and the request will be actioned.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for the google maps email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `string`):

Target geographic location for the google maps email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `emailOnlyResults` (type: `boolean`):

Only include businesses where emails were successfully extracted from their websites

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

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "coffee shops",
  "googleMapsLocation": "Miami, Florida",
  "maxBusinesses": 20,
  "emailOnlyResults": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Records scraped by Google Maps Email Scraper, stored in the run's 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 = {
    "googleMapsSearchTerm": "coffee shops",
    "googleMapsLocation": "Miami, Florida",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/google-maps-email-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 = {
    "googleMapsSearchTerm": "coffee shops",
    "googleMapsLocation": "Miami, Florida",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/google-maps-email-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 '{
  "googleMapsSearchTerm": "coffee shops",
  "googleMapsLocation": "Miami, Florida",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapers-hub/google-maps-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/google-maps-email-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/RxT6D5ey2uQwbPPs5/builds/VwpTNo3XeddfrbBuT/openapi.json