# 📍📩 Google Maps Email Extractor - Leads, No API Key (`renzomacar/google-maps-businesses`) Actor

Extract business emails from Google Maps with no API key — turn any search + location into a lead list with name, address, phone, website, rating and email scraped from the site. No Google API, no quotas, no setup. Built for agencies and B2B sales teams doing local outreach. Pay only per result.

- **URL**: https://apify.com/renzomacar/google-maps-businesses.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Lead generation
- **Stats:** 58 total users, 10 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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 Business Scraper -- Extract Local Business Data at Scale

> ⭐ **Found this useful? [Leave a review](https://apify.com/renzomacar/google-maps-businesses#reviews)** — it takes 30 seconds and it is the single biggest lever a solo developer has to help other devs discover this actor. I read every one and reply.

Turn any Google Maps search into a structured database of local businesses. Extract names, addresses, phone numbers, websites, ratings, review counts, GPS coordinates, and more -- all from a simple keyword search. Whether you are building prospect lists, analyzing markets, or powering a lead generation pipeline, this scraper delivers clean, export-ready business data in seconds.

![Real output: business name, category, address, rating and review count from one Google Maps search](https://api.apify.com/v2/key-value-stores/oVglg9gfEMc29bKLa/records/google-maps-businesses_output.png)

Stop manually copying business information from Google Maps. Automate the entire process and focus on closing deals instead.

### What data can you extract?

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | The original search query used to find this business |
| `businessName` | string | Official name of the business as listed on Google Maps |
| `category` | string | Business category (e.g., "Restaurant", "Dentist", "Plumber") |
| `address` | string | Full street address including city, state, and zip code |
| `phone` | string | Primary phone number |
| `website` | string | Business website URL |
| `rating` | number | Average star rating from 1.0 to 5.0 |
| `reviewCount` | integer | Total number of Google reviews |
| `priceLevel` | string | Price level indicator ($, $$, $$$, or $$$$) |
| `openingHours` | object | Business hours broken down by day of the week |
| `latitude` | number | GPS latitude coordinate |
| `longitude` | number | GPS longitude coordinate |
| `placeUrl` | string | Direct Google Maps link to the business listing |
| `imageUrl` | string | URL of the main business photo |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was extracted |

### Use cases

- **Lead generation and sales prospecting** -- Build targeted contact lists of local businesses by industry and geography. Feed results directly into your CRM or outreach tools.
- **Local SEO and competitive analysis** -- Benchmark your business against competitors in any area. Compare ratings, review volumes, categories, and price levels across an entire market.
- **Market research and site selection** -- Map business density, pricing trends, and competitive intensity for any location. Ideal for real estate investors, franchise operators, and retail strategists.
- **Data enrichment for existing databases** -- Enrich your existing business records with fresh phone numbers, websites, ratings, and coordinates from Google Maps.
- **Monitoring and change detection** -- Schedule recurring runs to track new businesses appearing in a market, rating changes, or closures over time.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchQueries` | array of strings | Yes | -- | Search queries to run on Google Maps (e.g., "dentists in Miami FL", "coffee shops near Times Square NYC") |
| `maxResultsPerQuery` | integer | No | 100 | Maximum number of businesses to extract per query (1-500) |
| `language` | string | No | "en" | Language code for results (e.g., "en", "es", "fr", "de") |
| `maxConcurrency` | integer | No | 3 | Number of browser pages to run in parallel (1-10). Lower values reduce the risk of rate limiting. |
| `includeWebsite` | boolean | No | false | Visit each business website to extract additional data such as emails and social media links. Increases run time. |

### Example output

```json
{
    "searchQuery": "restaurants in San Francisco",
    "businessName": "House of Prime Rib",
    "category": "Steakhouse",
    "address": "1906 Van Ness Ave, San Francisco, CA 94109",
    "phone": "(415) 885-4605",
    "website": "https://houseofprimerib.net",
    "rating": 4.5,
    "reviewCount": 8234,
    "priceLevel": "$$$",
    "openingHours": null,
    "latitude": 37.7937,
    "longitude": -122.4228,
    "placeUrl": "https://www.google.com/maps/place/House+of+Prime+Rib/@37.7937,-122.4228,17z",
    "imageUrl": "https://lh5.googleusercontent.com/p/AF1QipN...",
    "scrapedAt": "2026-03-01T12:00:00.000Z"
}
````

### How much does it cost?

This actor uses a **pay-per-result** pricing model, so you only pay for the data you actually receive:

- **$0.004 per business** extracted ($4.00 per 1,000 businesses)
- A typical run scraping 100 businesses from a single search query costs approximately **$0.40**
- Scraping 1,000 businesses costs approximately **$4.00**
- Scraping 10,000 businesses across multiple queries costs approximately **$40.00**

There are no monthly fees or commitments. You only pay for the data you extract.

### Tips and tricks

- **Use specific, location-based queries for the best results.** A query like "Italian restaurants in Manhattan, NY" will return more relevant results than a generic "restaurants in New York." Google Maps search results are inherently location-scoped, so the more specific you are, the better the data quality.
- **Google Maps typically returns up to 120 results per search.** If you need broader coverage of a large area, break your search into multiple targeted queries (e.g., by neighborhood, zip code, or subcategory) rather than relying on a single broad query.
- **Keep concurrency between 1 and 3 for reliable results.** Higher concurrency speeds up execution but increases the risk of Google rate-limiting your requests. For large-scale projects, it is better to run multiple smaller batches.
- **Schedule recurring runs for market monitoring.** Business data on Google Maps does not change as frequently as product prices or reviews. Weekly or monthly runs are typically sufficient for monitoring purposes.

### Using AI to write your outreach / posts / replies?

If you use this scraped data to inform AI-generated cold emails, LinkedIn posts, Reddit replies, etc., **modern detectors are catching on**. Em-dashes, "delve", parallel bullets, and 9 other patterns get accounts flagged or callout-replied. Built [**aitells.vercel.app**](https://aitells.vercel.app) after my own reddit account got 2 "all AI generated" callouts in one day. Free detector + $19 lifetime rewriter that matches your voice.

### Found this useful?

If this scraper saved you time, please consider leaving a quick review on the **Reviews** tab above. Reviews help small developers like me get visibility on the Apify Store, and your feedback is genuinely valuable for improving the actor. Thanks!

### Related scrapers

- [Google Maps Reviews Scraper](https://apify.com/renzomacar/google-maps-reviews) -- Extract all reviews, ratings, and owner responses for businesses you discover with this scraper.
- [Website Contact & Email Finder](https://apify.com/renzomacar/website-contact-finder) -- Crawl the websites extracted from Google Maps to find emails, phone numbers, social media profiles, and technology stacks.

***

### More from Renzo

If this actor was useful, you might like these too:

- **[Supabase Security Scanner](https://apify.com/renzomacar/supabase-rls-scanner)** -- find leaks in any public Supabase project (anon key + URL).
- **[RLS Audit Friday $99](https://perufitlife.github.io/rls-audit-friday/)** -- I'll run the scan + write a report by Monday. 24h delivery.
- **[Vibe-code Security Review $199](https://perufitlife.github.io/vibe-code-review/)** -- I review your Cursor / v0 / Bolt / Lovable app for security holes before you ship.
- **[Sandbox-as-a-Service $499](https://perufitlife.github.io/sandbox-as-a-service/)** -- I build a custom partner integration sandbox for your API in 48h.
- **[AI-tells Removal $29/1k words](https://perufitlife.github.io/aitells-removal/)** -- strip AI fingerprints (em-dashes, "delve", parallel bullets) from your drafts.
- **[Public Wall of Shame](https://perufitlife.github.io/rls-public-scan-wall/)** -- 30 random Supabase projects scanned, 43% had a critical leak.

Open source family: github.com/Perufitlife

# Actor input Schema

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

List of search queries to run on Google Maps (e.g., 'dentists in Miami', 'coffee shops near Times Square NYC').

## `maxResultsPerQuery` (type: `integer`):

Maximum number of businesses to extract per search query. Google Maps typically shows up to 120 results per search.

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

Language code for results (e.g., 'en', 'es', 'fr'). Leave empty for default.

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

Number of browser pages to run in parallel. Default 1 avoids Google Maps rate-limiting and yields the highest success rate.

## `includeWebsite` (type: `boolean`):

Whether to visit each business website to extract additional info (emails, social links). Slower but more data.

## `outputFormat` (type: `string`):

Choose 'json' for raw dataset only, 'html-report' to also generate a polished Lead List HTML report (KPIs, charts, scored lead table, agency-quality deliverable) saved to the run's key-value store under the key REPORT, or 'both'.

## Actor input object example

```json
{
  "searchQueries": [
    "restaurants in San Francisco",
    "dentists in Miami FL",
    "plumbers in Chicago"
  ],
  "maxResultsPerQuery": 100,
  "language": "en",
  "maxConcurrency": 1,
  "includeWebsite": false,
  "outputFormat": "json"
}
```

# 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": [
        "restaurants in San Francisco",
        "dentists in Miami FL",
        "plumbers in Chicago"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/google-maps-businesses").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": [
        "restaurants in San Francisco",
        "dentists in Miami FL",
        "plumbers in Chicago",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/google-maps-businesses").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": [
    "restaurants in San Francisco",
    "dentists in Miami FL",
    "plumbers in Chicago"
  ]
}' |
apify call renzomacar/google-maps-businesses --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📍📩 Google Maps Email Extractor - Leads, No API Key",
        "description": "Extract business emails from Google Maps with no API key — turn any search + location into a lead list with name, address, phone, website, rating and email scraped from the site. No Google API, no quotas, no setup. Built for agencies and B2B sales teams doing local outreach. Pay only per result.",
        "version": "0.1",
        "x-build-id": "649iaNM4jurm05qGj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/renzomacar~google-maps-businesses/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-renzomacar-google-maps-businesses",
                "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-businesses/runs": {
            "post": {
                "operationId": "runs-sync-renzomacar-google-maps-businesses",
                "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-businesses/run-sync": {
            "post": {
                "operationId": "run-sync-renzomacar-google-maps-businesses",
                "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": "List of search queries to run on Google Maps (e.g., 'dentists in Miami', 'coffee shops near Times Square NYC').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of businesses to extract per search query. Google Maps typically shows up to 120 results per search.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for results (e.g., 'en', 'es', 'fr'). Leave empty for default.",
                        "default": "en"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of browser pages to run in parallel. Default 1 avoids Google Maps rate-limiting and yields the highest success rate.",
                        "default": 1
                    },
                    "includeWebsite": {
                        "title": "Visit business websites",
                        "type": "boolean",
                        "description": "Whether to visit each business website to extract additional info (emails, social links). Slower but more data.",
                        "default": false
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "json",
                            "html-report",
                            "both"
                        ],
                        "type": "string",
                        "description": "Choose 'json' for raw dataset only, 'html-report' to also generate a polished Lead List HTML report (KPIs, charts, scored lead table, agency-quality deliverable) saved to the run's key-value store under the key REPORT, or 'both'.",
                        "default": "json"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
