# 20+ Million Business Leads With Emails (From Google Maps) (`xmiso_scrapers/millions-us-businesses-leads-with-emails-from-google-maps`) Actor

Don't have time to scrape google maps? Looking for affordable B2B data apollo.io alternative? Get recent leads from continuously updated database of businesses worldwide with emails and social links scraped for you. Current number of businesses with unique emails :23.000.000+ in 2000+ categories

- **URL**: https://apify.com/xmiso_scrapers/millions-us-businesses-leads-with-emails-from-google-maps.md
- **Developed by:** [Miso](https://apify.com/xmiso_scrapers) (community)
- **Categories:** Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 3,325 total users, 114 monthly users, 98.9% runs succeeded, 132 bookmarks
- **User rating**: 4.75 out of 5 stars

## Pricing

from $0.80 / 1,000 business 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Business Leads With Emails and Contact Persons (From Google Maps)

Get business leads from a continuously updated Google Maps database, including company emails, phone numbers, websites, social profiles, reviews, and optional decision-maker contact data.

Search by one or more business categories, keyword, country, US state, city, or a geographic area. Export the results to CSV, Excel, JSON, or another format supported by Apify.

### What's new

#### Select multiple categories

Pick up to **20 categories** in one run, for example `bakery` + `cafe` + `coffee_shop`. You get one combined dataset:

- a business that belongs to several selected categories is returned **only once**,
- each email address is returned **only once**,
- the new `matched_categories` field shows which of your selected categories the business belongs to.

#### Start offset and continuing a previous export

Results are always returned in the same stable order (oldest records first), so you can split a large export into several runs:

- **Start offset** (`start_offset`) skips the first N results, for example `10000` to start at result 10,001.
- **Start after Google Place ID** (`start_after_google_place_id`) continues right after a specific business. At the end of every run the Actor saves the last returned ID to the run's key-value store as `LAST_CURSOR`. Paste it into the next run to continue without duplicates.

If Apify restarts or migrates a run, the Actor automatically resumes from the last saved page instead of starting over.

#### Contact persons

For US category searches, you can enable **Include contact persons** to return only businesses for which suitable people were identified.

Each qualifying business can include up to three people with:

- name,
- normalized job title,
- business email when available,
- business phone when available.

The people option is disabled by default, so existing tasks and saved inputs continue to work as before.

> Contact-person search is currently available only for the United States. When enabled, businesses without a qualifying person are excluded. Shared-hosting domains, domains used by many unrelated locations, incomplete names, and unsuitable job titles may also be excluded to improve data quality.

### Database coverage

Current approximate numbers of unique business leads with emails:

| Country | Approximate leads |
|---|---:|
| United States | 9M |
| Germany | 2.5M |
| United Kingdom | 1.5M |
| Canada | 1.3M |
| France | 1M |
| India, Italy, Brazil, Australia | 700k each |
| Spain | 600k |
| Netherlands, Poland, Japan, Mexico | 500k each |
| Turkey, Belgium, Switzerland | 300k each |
| Austria, Czech Republic | 250k each |
| Sweden | 200k |
| Denmark, Finland, Indonesia, Portugal | 100k each |

Coverage changes as new businesses are added and existing records are updated.

### Features

- **Millions of business leads with emails** across supported countries.
- **Optional contact persons for US businesses**, with up to three people per company.
- **2,000+ Google Maps business categories**, with up to 20 categories per run.
- **Category or keyword search** such as `dentist`, `bakery`, `roofing`, or `teeth whitening`.
- **One row per email**: results are deduplicated by email address, also across multiple categories.
- **Start offset and continuation** for splitting large exports into several runs without duplicates.
- **Country selection**, including an option to search all supported countries.
- **US state and city filtering** for more targeted lists.
- **Geographic area search** using latitude, longitude, and radius.
- **Company contact details**, including email, phone number, website, and social links when available.
- **Google Maps data**, including category, rating, review count, and Maps URL.
- **Up to 100,000 results per paid run**.
- **CSV, Excel, JSON, XML, RSS, and other Apify dataset exports**.

### Supported countries

The current input form supports:

`AE`, `AR`, `AT`, `AU`, `BE`, `BG`, `BR`, `CA`, `CH`, `CZ`, `DE`, `DK`, `ES`, `FI`, `FR`, `GB`, `HK`, `ID`, `IE`, `IL`, `IN`, `IT`, `JP`, `KR`, `MX`, `NL`, `NO`, `PL`, `PT`, `SA`, `SE`, `SK`, `TH`, `TR`, and `US`.

Select `ALL` to search across all supported countries. Contact-person enrichment is currently limited to `US`.

### Input options

| Field | Type | Description | Example |
|---|---|---|---|
| `categories` | array | One or more predefined business categories (max 20). Results include businesses from any of them. Ignored when `keyword` is provided. | `["dentist", "orthodontist"]` |
| `keyword` | string | Searches across Google business categories and takes priority over `category`. | `roofing` |
| `country` | string | Two-letter country code or `ALL`. | `US` |
| `state` | string | Optional US state filter. Ignored for other countries. | `CA` |
| `city` | string | Optional city or partial city-name filter. | `Los Angeles` |
| `lat` | string | Latitude used for geographic area search. | `34.0522` |
| `lon` | string | Longitude used for geographic area search. | `-118.2437` |
| `area` | integer | Search radius in kilometres. Used together with `lat` and `lon`. | `10` |
| `people_required` | boolean | When enabled, returns only US businesses with qualifying contact persons. | `true` |
| `max_results` | integer | Maximum number of results to return, up to 100,000 for paid users. | `2000` |
| `start_offset` | integer | Skip this many results before returning data. | `10000` |
| `start_after_google_place_id` | string | Continue right after this business, for example the `LAST_CURSOR` value from a previous run. Takes priority over `start_offset`. | `ChIJ...` |

The older single-value `category` field is still accepted for existing tasks and API integrations. When both `category` and `categories` are sent, they are combined.

The Actor uses up to three contact persons per business. This limit is managed automatically and does not need to be included in normal input.

### Example: standard business leads

```json
{
  "categories": ["dentist"],
  "country": "US",
  "state": "CA",
  "people_required": false,
  "max_results": 500
}
```

This returns ordinary business leads. It does not require a matching contact person.

### Example: multiple categories

```json
{
  "categories": ["bakery", "cafe", "coffee_shop"],
  "country": "US",
  "state": "NY",
  "max_results": 5000
}
```

Businesses listed in more than one of these categories appear only once. The `matched_categories` field shows, for example, `cafe, coffee_shop`.

### Example: splitting a large export

First run, results 1–50,000:

```json
{
  "categories": ["restaurant"],
  "country": "US",
  "max_results": 50000
}
```

Second run, results 50,001–100,000, using the offset:

```json
{
  "categories": ["restaurant"],
  "country": "US",
  "max_results": 50000,
  "start_offset": 50000
}
```

Or continue exactly where the first run ended, using `LAST_CURSOR` from the first run's key-value store:

```json
{
  "categories": ["restaurant"],
  "country": "US",
  "max_results": 50000,
  "start_after_google_place_id": "ChIJ..."
}
```

Keep the other filters identical between runs, otherwise the offset refers to a different list. `start_after_google_place_id` is the safer choice when new businesses may have been added between runs, because new records are appended at the end of the list.

### Example: businesses with contact persons

```json
{
  "categories": ["dentist"],
  "country": "US",
  "state": "CA",
  "people_required": true,
  "max_results": 500
}
```

This returns only businesses with at least one qualifying contact person. Contact-person results use a separate paid event in addition to the standard business-lead result event. See the Actor's **Pricing** tab for current event prices.

### Example: geographic area search

```json
{
  "country": "US",
  "lat": "34.0522",
  "lon": "-118.2437",
  "area": 10,
  "max_results": 1000
}
```

Provide all three geographic fields—`lat`, `lon`, and `area`—to activate area search.

### Output fields

Every business result can contain:

- `google_place_id`
- `name`
- `street`
- `city`
- `country`
- `country_code`
- `url`
- `phone_number`
- `email`
- `google_business_categories`
- `matched_categories`: which of your selected categories the business belongs to (category searches without contact persons)
- `google_maps_url`
- `review_score`
- `reviews_number`
- `facebook`
- `instagram`
- `linkedin`
- `source_country`

When `people_required` is enabled, results can additionally contain:

- `people_count`
- `person_1_name`, `person_1_title`, `person_1_email`, `person_1_phone`
- `person_2_name`, `person_2_title`, `person_2_email`, `person_2_phone`
- `person_3_name`, `person_3_title`, `person_3_email`, `person_3_phone`

Fields are `null` when the corresponding value is unavailable.

### Example output with contact persons

```json
{
  "google_place_id": "ChIJ...",
  "name": "Example Dental Clinic",
  "city": "Los Angeles",
  "country_code": "US",
  "url": "https://example.com",
  "phone_number": "+1 555 123 4567",
  "email": "info@example.com",
  "google_business_categories": "Dentist|Dental clinic",
  "google_maps_url": "https://www.google.com/maps?cid=...",
  "review_score": 4.8,
  "reviews_number": 126,
  "people_count": 2,
  "person_1_name": "Jane Smith",
  "person_1_title": "Owner",
  "person_1_email": "jane@example.com",
  "person_1_phone": null,
  "person_2_name": "John Doe",
  "person_2_title": "Practice Manager",
  "person_2_email": null,
  "person_2_phone": null
}
```

### Important behavior

- `keyword` takes priority over `categories` when both are provided.
- Up to 20 categories can be selected per run.
- Results are deduplicated by email address and returned in a stable order (oldest records first), so offsets and `LAST_CURSOR` stay consistent between runs with the same filters.
- With country `ALL`, use `start_offset`; `start_after_google_place_id` works only with a single country.
- State filtering applies only to the United States.
- Geographic search activates only when latitude, longitude, and area are all provided.
- `people_required` is off by default.
- People mode currently supports only `country: "US"`.
- If people mode is selected for another country, the Actor logs a warning and finishes successfully with an empty dataset.
- People data is matched at company-domain level and filtered to reduce incorrect reuse across unrelated businesses.
- Availability differs by category, location, and website data quality.

### Use cases

- B2B prospecting and outbound sales
- Local business lead generation
- CRM enrichment
- Agency and market research
- Supplier and partner discovery
- Territory planning
- Finding company owners, managers, and other relevant contacts

### Support

If you find a problem or need help with a specific search, open an issue from the Actor page and include the run ID and non-sensitive input parameters. This makes the run easier to diagnose.

# Changelog

This Actor's version history is a separate document: https://apify.com/xmiso_scrapers/millions-us-businesses-leads-with-emails-from-google-maps/changelog.md

# Actor input Schema

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

Select one or more business categories (max 20). Results include businesses from any of the selected categories, deduplicated by email. Ignored when Keyword is set.

## `keyword` (type: `string`):

Optional: Search for any keyword (e.g. teeth whitening, hvac) in business categories. If provided, this takes priority over category.

## `country` (type: `string`):

Choose the country for business leads. Select 'ALL' to search across all supported countries.

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

Filter results by US state

## `people_required` (type: `boolean`):

Add people scraped from business website - owners, decision makers etc at rate +$1/1000 rows

## `verify_emails` (type: `boolean`):

Directly verify emails - Emails will be verified immediately at additional rate +$1/1000 rows

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

Optional: Filter out leads by searching for string in city field. Eg Washington or just Wash

## `lat` (type: `string`):

latitude

## `lon` (type: `string`):

longitude

## `area` (type: `integer`):

Area to look for business in

## `max_results` (type: `integer`):

Maximum number of results to retrieve

## `start_offset` (type: `integer`):

Skip this many results before returning data.

## `start_after_google_place_id` (type: `string`):

Continue after this google_place_id (e.g. LAST_CURSOR from a previous run). Overrides start_offset.

## Actor input object example

```json
{
  "categories": [
    "bakery"
  ],
  "keyword": "",
  "country": "US",
  "state": "All",
  "city": "",
  "area": 10,
  "max_results": 100,
  "start_offset": 0
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "categories": [
        "bakery"
    ],
    "keyword": "",
    "country": "US",
    "state": "All",
    "city": "",
    "area": 10,
    "max_results": 100
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "categories": ["bakery"],
    "keyword": "",
    "country": "US",
    "state": "All",
    "city": "",
    "area": 10,
    "max_results": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "categories": [
    "bakery"
  ],
  "keyword": "",
  "country": "US",
  "state": "All",
  "city": "",
  "area": 10,
  "max_results": 100
}' |
apify call xmiso_scrapers/millions-us-businesses-leads-with-emails-from-google-maps --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xmiso_scrapers/millions-us-businesses-leads-with-emails-from-google-maps"
        }
    }
}
```

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/SO9xTra0rtb9NNVfw/builds/FVMVZj2PYysoIPbit/openapi.json
