# Google Maps Email Scraper - B2B Leads with Verified Emails (`benthepythondev/google-maps-email-scraper`) Actor

Scrape businesses from Google Maps and enrich each with verified contact emails. Pulls name, phone, website, address, rating + finds emails from the site's contact/Impressum pages and role-based addresses (MX + SMTP checked). Pay per lead; small premium only when an email is found.

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

## Pricing

from $10.00 / 1,000 results

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 Email Scraper — B2B Lead Finder with Verified Emails

Turn a Google Maps search into a ready-to-use B2B lead list **with contact emails**. This Actor finds businesses by keyword + location (or enriches a list of websites you already have), then visits each company's website — including its **contact, Kontakt and Impressum pages** — to pull real published email addresses, falling back to role-based addresses (info@, sales@, kontakt@) validated with MX and SMTP checks.

You get the business details *and* the email in one clean row — no second tool, no copy-pasting domains into an email finder. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🔎 What is the Google Maps Email Scraper?

Most Google Maps scrapers stop at the website URL and leave you to find the email yourself. This one finishes the job: for every business it scrapes the site's contact pages for published addresses and, when none are public, tests the most common business inboxes and validates them — so each lead arrives with a usable, scored email.

It is built for sales, agencies and recruiters who want **targeted, verified outbound lists** without an enterprise database contract. The German-market coverage is a real edge: because German sites are legally required to publish a contact email in their **Impressum**, hit rates on DACH businesses are especially high.

#### What data does it extract?

- **Business name, full address, and phone number**
- **Website and clean domain**
- **Primary contact email** with a confidence score (0–100) and its source (website, Impressum, contact page, or role pattern)
- **All emails found** for the business, not just the best one
- **Rating and review count** from Google Maps
- **Categories** the business is listed under
- **Lead score (0–100)** combining contact completeness, reviews and rating
- **Google Maps URL** and the original search query/location

### ⬇️ Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | string | `search` (Google Maps by keyword + location) or `websites` (enrich your own list). Required. |
| `query` | string | What to search for, e.g. `dentists`, `law firms`. Used in `search` mode. |
| `location` | string | City or region, e.g. `Berlin, Germany`, `Austin, TX`. Used in `search` mode. |
| `maxResults` | integer | Max leads to scrape and enrich (1–200). Default `20`. |
| `websites` | array | List of company websites/domains to find emails for. Used in `websites` mode. |
| `requireEmail` | boolean | Only return leads where an email was found (you are not charged the email fee for skipped leads). Default `false`. |
| `enableSmtpVerification` | boolean | SMTP-verify role-based guesses when possible. Default `true`. |
| `smtpTimeout` | integer | Per-server SMTP timeout in seconds (2–15). Default `5`. |

#### Example input

```json
{
  "mode": "search",
  "query": "marketing agencies",
  "location": "Munich, Germany",
  "maxResults": 50,
  "requireEmail": true
}
````

Already have a list of companies? Switch modes:

```json
{
  "mode": "websites",
  "websites": ["acme-corp.com", "https://www.example-gmbh.de", "studio-berlin.com"]
}
```

### ⬆️ Output

Each item is one enriched business lead:

```json
{
  "name": "Studio Berlin Marketing GmbH",
  "website": "https://www.studio-berlin.de",
  "domain": "studio-berlin.de",
  "phone": "+49 30 1234567",
  "address": "Friedrichstraße 100, 10117 Berlin, Germany",
  "rating": 4.8,
  "review_count": 64,
  "categories": ["Marketing agency", "Advertising agency"],
  "primary_email": "info@studio-berlin.de",
  "email_confidence": 95,
  "email_source": "impressum",
  "emails": [
    { "email": "info@studio-berlin.de", "confidence": 95, "source": "impressum" },
    { "email": "jobs@studio-berlin.de", "confidence": 90, "source": "contact_page" }
  ],
  "has_email": true,
  "lead_score": 92,
  "google_maps_url": "https://www.google.com/maps/place/...",
  "search_query": "marketing agencies",
  "search_location": "Munich, Germany"
}
```

### 💡 Use cases

- 📈 **Outbound sales** — build targeted, verified prospect lists for any niche + city and push them straight to your CRM.
- 🏢 **Agencies & freelancers** — find local businesses (especially ones with weak web presence) and pitch them with a real contact address.
- 🧑‍💼 **Recruiting & partnerships** — reach companies directly via their published inbox instead of a generic web form.
- 🌍 **DACH market research** — exploit legally-published Impressum emails for high hit rates across Germany, Austria and Switzerland.

### ❓ FAQ

**Do I need an API key or login?**
No. Give a search query + location (or a list of websites) and run it.

**Where do the emails come from?**
First from the business's own website — its homepage, contact/Kontakt page and Impressum, where addresses are published. If none are public, the Actor tests common business inboxes (info@, kontakt@, sales@…) and validates them with MX records and best-effort SMTP.

**What does the confidence score mean?**
Higher means more trustworthy. Emails published in an Impressum or matching the company domain score highest (90–95). Role-based guesses validated only by MX score lower (~50). Use the score to decide what to send.

**How accurate are the emails?**
Published addresses are real, taken directly from the site. Role-based guesses are educated patterns; many cloud networks block SMTP (port 25), so when SMTP can't run, those fall back to MX-validated guesses — filter by `email_confidence` if you only want high-certainty addresses.

**Can I get only leads that have an email?**
Yes — set `requireEmail` to `true` and leads without a findable email are skipped.

**How does pricing work?**
Pay per event: a small fee per business lead returned, plus a small premium **only** when an email is actually found and attached. No subscription, no per-seat fee.

**Is it good for the German market?**
Especially. German law requires a contact email in every site's Impressum, so DACH businesses have very high email hit rates.

**Can I schedule it or call it from my app?**
Yes — schedule recurring runs, call it via the Apify API, or connect it to Make, Zapier or n8n.

**Is this legal?**
It collects publicly available business contact information. Use it for legitimate B2B outreach and comply with GDPR/CAN-SPAM and local law, including honoring opt-outs.

### 🔗 You might also like

- [Google Maps Business Scraper](https://apify.com/benthepythondev/google-maps-business-scraper) — business data + lead scoring without email enrichment.
- [Smart Email Finder & Verifier](https://apify.com/benthepythondev/smart-email-finder-verifier) — find a specific person's email from name + company domain.
- [Gelbe Seiten Scraper](https://apify.com/benthepythondev/gelbe-seiten-scraper) — German business directory leads.
- [Business Contact Scraper (local.ch)](https://apify.com/benthepythondev/business-contact-scraper) — Swiss business contacts.

***

**Keywords:** google maps email scraper, google maps lead scraper, b2b email finder, business email scraper, lead generation scraper, extract emails from google maps, email finder, verified business emails, impressum email scraper, german business leads, sales prospecting tool, outbound leads, contact scraper, zoominfo alternative, apollo alternative, find company emails, scrape business contacts, local business leads, email enrichment, dach b2b data

# Actor input Schema

## `mode` (type: `string`):

Search Google Maps by keyword + location, or enrich a list of websites you already have.

## `query` (type: `string`):

What to search for on Google Maps, e.g. 'dentists', 'law firms', 'Restaurants'. Used in 'search' mode.

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

City or region to search, e.g. 'Berlin, Germany', 'Austin, TX', 'London, UK'. Used in 'search' mode.

## `maxResults` (type: `integer`):

Maximum number of leads to scrape and enrich (1-200). Email enrichment visits each site, so large runs take longer.

## `websites` (type: `array`):

List of company websites or domains to find emails for, e.g. 'acme.com'. Used in 'websites' mode.

## `requireEmail` (type: `boolean`):

If enabled, leads where no contact email could be found are skipped (you are not charged the email fee for them).

## `enableSmtpVerification` (type: `boolean`):

Verify role-based guesses (info@, sales@...) over SMTP when possible. Published emails from the site are always MX-validated. SMTP is often blocked in the cloud; disable to run faster.

## `smtpTimeout` (type: `integer`):

Per-server SMTP timeout. Lower = faster runs, higher = more thorough.

## Actor input object example

```json
{
  "mode": "search",
  "query": "marketing agencies",
  "location": "Berlin, Germany",
  "maxResults": 10,
  "requireEmail": false,
  "enableSmtpVerification": true,
  "smtpTimeout": 5
}
```

# 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 = {
    "query": "marketing agencies",
    "location": "Berlin, Germany"
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "query": "marketing agencies",
    "location": "Berlin, Germany",
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/google-maps-email-scraper").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 '{
  "query": "marketing agencies",
  "location": "Berlin, Germany"
}' |
apify call benthepythondev/google-maps-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Email Scraper - B2B Leads with Verified Emails",
        "description": "Scrape businesses from Google Maps and enrich each with verified contact emails. Pulls name, phone, website, address, rating + finds emails from the site's contact/Impressum pages and role-based addresses (MX + SMTP checked). Pay per lead; small premium only when an email is found.",
        "version": "1.0",
        "x-build-id": "aLZMzJdh3CqhgwG83"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~google-maps-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-google-maps-email-scraper",
                "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/benthepythondev~google-maps-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-google-maps-email-scraper",
                "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/benthepythondev~google-maps-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-google-maps-email-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "websites"
                        ],
                        "type": "string",
                        "description": "Search Google Maps by keyword + location, or enrich a list of websites you already have.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "What to search for on Google Maps, e.g. 'dentists', 'law firms', 'Restaurants'. Used in 'search' mode.",
                        "default": "marketing agencies"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to search, e.g. 'Berlin, Germany', 'Austin, TX', 'London, UK'. Used in 'search' mode.",
                        "default": "Berlin, Germany"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of leads to scrape and enrich (1-200). Email enrichment visits each site, so large runs take longer.",
                        "default": 10
                    },
                    "websites": {
                        "title": "Websites to enrich",
                        "type": "array",
                        "description": "List of company websites or domains to find emails for, e.g. 'acme.com'. Used in 'websites' mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "requireEmail": {
                        "title": "Only return leads with an email",
                        "type": "boolean",
                        "description": "If enabled, leads where no contact email could be found are skipped (you are not charged the email fee for them).",
                        "default": false
                    },
                    "enableSmtpVerification": {
                        "title": "SMTP verification",
                        "type": "boolean",
                        "description": "Verify role-based guesses (info@, sales@...) over SMTP when possible. Published emails from the site are always MX-validated. SMTP is often blocked in the cloud; disable to run faster.",
                        "default": true
                    },
                    "smtpTimeout": {
                        "title": "SMTP timeout (seconds)",
                        "minimum": 2,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Per-server SMTP timeout. Lower = faster runs, higher = more thorough.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```