# 📍 Google Maps Email Scraper - Leads & Verified Phones (`renzomacar/google-maps-leads-with-emails`) Actor

Turn any niche + city into ready-to-use leads — one clean row per business with name, phone, website, verified emails, socials and tech stack, all from Google Maps. No API key, no duplicates, no cleanup. For agencies selling to local businesses. Pay only per lead delivered.

- **URL**: https://apify.com/renzomacar/google-maps-leads-with-emails.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 lead with emails

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Leads Scraper with Email Finder

Turn one Google Maps search into a **ready-to-use lead list with emails** — in a single run.

![Real output: one row per business with email found on the website, phone, rating and tech stack](https://api.apify.com/v2/key-value-stores/oVglg9gfEMc29bKLa/records/google-maps-leads-with-emails_output.png)

Type `dentists in Miami, FL` and get one consolidated row per business: name, address, phone, rating, reviews, category, website, **emails found on the website**, extra phone numbers, social profiles (LinkedIn, Facebook, Instagram...) and the site's tech stack.

No more chaining two scrapers, exporting CSVs and matching rows by hand. This actor scrapes Google Maps **and** visits every business website for you, then delivers everything merged.

### Who is this for?

- **Agencies & freelancers selling to local businesses** — web design, SEO, ads, social media management. Search your niche + city, export, start outreach the same day.
- **B2B sales teams** prospecting local markets (dental clinics, gyms, law firms, restaurants, contractors...).
- **Cold email senders** who need fresh, verified contact data instead of stale purchased lists.

### What you get (one row per business)

| Field | Example |
|---|---|
| `businessName` | Bright Smile Dental |
| `category` | Dentist |
| `address` | 1200 Brickell Ave, Miami, FL 33131 |
| `phone` | (305) 555-0182 |
| `website` | https://brightsmilemiami.com |
| `rating` / `reviewCount` | 4.8 / 312 |
| `emailFound` | `true` |
| `email` | info@brightsmilemiami.com |
| `emails` | all emails found on the site |
| `websitePhones` | extra phones found on the site |
| `socialLinks` | `{ "facebook": "...", "instagram": "...", "linkedin": "..." }` |
| `techStack` | `["WordPress", "Google Analytics"]` |
| `contactPageUrl` | https://brightsmilemiami.com/contact |
| `latitude` / `longitude`, `placeUrl`, `searchQuery`, `scrapedAt` | included |

Export to CSV, Excel, JSON or push straight into your CRM via the Apify API.

### Email verification (built in, free)

Emails don't just get scraped — they get **verified in the same run**, so the list you export is already cleaned. Every address is tagged:

- **`valid`** — good syntax, not disposable, domain has live MX (mail) records. Send-ready.
- **`risky`** — deliverable but lower confidence: a role address (`info@`, `office@`) or a domain receiving mail via an implicit A record.
- **`invalid`** — broken, disposable, or a domain that can't receive mail. Skip it.

Each row carries `emailStatus` (status of the primary email), **`validEmails`** (the send-ready ones) and `emailsVerified` (full per-email breakdown). It runs by default; set `verifyEmails` to `false` to turn it off. Checks are syntax, a 6,900-domain disposable blocklist, role detection and live MX lookups — no mailbox is ever contacted.

The verification engine is open-source — same logic, zero dependencies: [`mxverify` on npm](https://www.npmjs.com/package/mxverify) ([source](https://github.com/Perufitlife/mxverify)).

### How it works

![How it works: search query, Google Maps businesses, website visit, enriched leads](https://api.apify.com/v2/key-value-stores/oVglg9gfEMc29bKLa/records/google-maps-leads-with-emails_howitworks.png)

1. **Google Maps search** — scrapes the live results feed for each query (up to ~120 businesses per search, set `maxResults` per query).
2. **Website enrichment** — every business with a website gets its homepage, contact and about pages checked for emails, phones and social links (set `maxPagesPerSite`).
3. **One consolidated row** per business with an `emailFound` flag so you can filter instantly.

Tip: enable `onlyWithWebsite` to drop businesses without a website — you only pay for enrichable leads.

**Recommended `maxResults` ≤ 100 per run for best speed.** Website enrichment runs many sites in parallel with a hard per-site time limit, so a 50–100 lead run finishes in minutes. For larger lists, split into several runs (e.g. by city or niche) — it keeps each run fast and easy to monitor.

### Pricing (pay per event — you only pay for what you get)

| Event | Price |
|---|---|
| Actor start (per GB of memory, 4 GB default) | $0.005 / GB |
| Business delivered **without** email | $0.006 |
| Lead delivered **with** email | $0.02 |

**Cost examples:**

1. **Quick test** — "coffee shops in Austin, TX", 8 results, 3 emails found:
   start $0.02 + 3 × $0.02 + 5 × $0.006 = **$0.11**
2. **One niche, one city** — 100 dentists in Miami, 40 with email:
   start $0.02 + 40 × $0.02 + 60 × $0.006 = **$1.18** → **under 3 cents per emailed lead**
3. **Campaign** — 5 cities × 100 plumbers, ~200 emails found:
   start $0.02 + 200 × $0.02 + 300 × $0.006 = **$5.82** for 500 leads

Compare that with $0.05–$0.25 per contact on typical lead databases — and this data is scraped fresh at run time, not resold from a stale list.

### Why emails are not found for every business

Roughly 30–60% of local businesses publish an email on their website (varies a lot by niche). Businesses with no website, or whose site hides contact info behind forms, are delivered as **basic** rows (and charged at the lower rate) — you still get name, address, phone, rating and the Google Maps link for them.

### Responsible use

This actor collects **only publicly available business information** — data that businesses themselves publish on Google Maps and on their own public websites to be contacted by customers. No login-protected, private or personal-account data is accessed.

You are responsible for using the output in compliance with applicable laws and regulations in your jurisdiction (e.g. GDPR, CAN-SPAM, CASL), including consent and opt-out rules for commercial outreach. Use the data to make relevant, professional contact — not to spam.

### Use with AI agents — Claude, n8n, Make

The output is clean JSON (one object per business), so it drops straight into automation and AI-agent workflows. Trigger a run and read the dataset via the [Apify API](https://docs.apify.com/api/v2) or the official Apify integrations for **n8n**, **Make**, and **Zapier** — then let an agent draft and send the outreach.

Working with the **Model Context Protocol (MCP)**? This actor is also reachable through the [multi-scraper MCP server](https://apify.com/renzomacar/multi-scraper-mcp), so an MCP-enabled assistant (Claude, etc.) can search Google Maps and pull enriched leads as a tool call — no glue code.

### FAQ

**Does it work for any country/language?** Yes — queries can target any city Google Maps covers; set `language` if you want localized results.

**How long does a run take?** A 50-business query with enrichment typically takes a few minutes. Websites are crawled over plain HTTP (no second browser) with high concurrency and a hard per-site time limit, so one slow or dead website can never stall the whole run. Keep `maxResults` ≤ 100 per run for the fastest turnaround.

**What if a search returns nothing?** The run succeeds with an empty dataset and the query is recorded under `EMPTY_QUERIES` in the key-value store. Hard failures (blocked IPs, etc.) are stored under `FAILURES` — never mixed into your lead list.

---

⭐ **Found this useful? Please [leave a review](https://apify.com/renzomacar/google-maps-leads-with-emails#reviews)** — it takes 30 seconds and helps a lot.

Need fresh leads weekly without managing runs? Check the log output after each run for the Autopilot option.

# Actor input Schema

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

Google Maps searches, one per line (e.g. 'dentists in Miami, FL', 'plumbers in Austin, TX'). Tip: niche + city = best leads.
## `maxResults` (type: `integer`):

Maximum number of businesses to extract per search query. Google Maps typically returns up to ~120 per search.
## `onlyWithWebsite` (type: `boolean`):

If enabled, businesses without a website are dropped from the output (you are not charged for them). Useful when you only want enrichable leads.
## `maxPagesPerSite` (type: `integer`):

How many pages to check per business website when looking for emails (homepage, /contact, /about...). More pages = more emails found but slower.
## `includeGenericEmails` (type: `boolean`):

Include addresses like info@, hello@, contact@. Disable to keep only personal/role emails (fewer results).
## `language` (type: `string`):

Language code for Google Maps results (e.g. 'en', 'es', 'fr').
## `verifyEmails` (type: `boolean`):

Validate every scraped email: syntax, disposable-domain blocklist, role-based detection, and live MX (mailbox) records. Each email is tagged valid / risky / invalid so you can trust your outreach list.

## Actor input object example

```json
{
  "searchQueries": [
    "dentists in Miami, FL"
  ],
  "maxResults": 50,
  "onlyWithWebsite": false,
  "maxPagesPerSite": 4,
  "includeGenericEmails": true,
  "language": "en",
  "verifyEmails": true
}
````

# Actor output Schema

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

All scraped items as JSON.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "dentists in Miami, FL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/google-maps-leads-with-emails").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchQueries": ["dentists in Miami, FL"] }

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/google-maps-leads-with-emails").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "dentists in Miami, FL"
  ]
}' |
apify call renzomacar/google-maps-leads-with-emails --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📍 Google Maps Email Scraper - Leads & Verified Phones",
        "description": "Turn any niche + city into ready-to-use leads — one clean row per business with name, phone, website, verified emails, socials and tech stack, all from Google Maps. No API key, no duplicates, no cleanup. For agencies selling to local businesses. Pay only per lead delivered.",
        "version": "0.1",
        "x-build-id": "B0envcVxS1X5Vdiky"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/renzomacar~google-maps-leads-with-emails/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-renzomacar-google-maps-leads-with-emails",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/renzomacar~google-maps-leads-with-emails/runs": {
            "post": {
                "operationId": "runs-sync-renzomacar-google-maps-leads-with-emails",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/renzomacar~google-maps-leads-with-emails/run-sync": {
            "post": {
                "operationId": "run-sync-renzomacar-google-maps-leads-with-emails",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Google Maps searches, one per line (e.g. 'dentists in Miami, FL', 'plumbers in Austin, TX'). Tip: niche + city = best leads.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max businesses per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of businesses to extract per search query. Google Maps typically returns up to ~120 per search.",
                        "default": 50
                    },
                    "onlyWithWebsite": {
                        "title": "Only deliver businesses with a website",
                        "type": "boolean",
                        "description": "If enabled, businesses without a website are dropped from the output (you are not charged for them). Useful when you only want enrichable leads.",
                        "default": false
                    },
                    "maxPagesPerSite": {
                        "title": "Max pages per website",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many pages to check per business website when looking for emails (homepage, /contact, /about...). More pages = more emails found but slower.",
                        "default": 4
                    },
                    "includeGenericEmails": {
                        "title": "Include generic emails",
                        "type": "boolean",
                        "description": "Include addresses like info@, hello@, contact@. Disable to keep only personal/role emails (fewer results).",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for Google Maps results (e.g. 'en', 'es', 'fr').",
                        "default": "en"
                    },
                    "verifyEmails": {
                        "title": "Verify emails",
                        "type": "boolean",
                        "description": "Validate every scraped email: syntax, disposable-domain blocklist, role-based detection, and live MX (mailbox) records. Each email is tagged valid / risky / invalid so you can trust your outreach list.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```