# PHANTOM LEADS - Google Maps Business Scraper (`renaissant_overload/phantom-leads-google-maps-business-scraper`) Actor

Scrape Google Maps business leads at scale: name, address, phone, website, email, social media, GPS coordinates, rating & reviews. Export CSV/JSON for cold email, CRM enrichment & sales prospecting. Multi-query, all countries & languages. Built for sales teams, agencies & B2B lead gen.

- **URL**: https://apify.com/renaissant\_overload/phantom-leads-google-maps-business-scraper.md
- **Developed by:** [NABIL](https://apify.com/renaissant_overload) (community)
- **Categories:** Lead generation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 business leads

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

## PHANTOM LEADS - Google Maps Business Scraper

**Extract verified business leads from Google Maps at scale.** PHANTOM LEADS scrapes business name, address, phone, website, email, social media, rating & reviews directly from Google Maps.

Built for **sales teams, marketing agencies, lead generation freelancers, and B2B prospectors** who need accurate, structured business data without manual research.

---

### What Does This Actor Do?

PHANTOM LEADS automates the extraction of business information from Google Maps search results. You provide a list of search queries, and the actor returns a clean dataset of business leads.

The scraper operates in two phases:
1. **Phase 1** - Collects all business listing URLs from the Google Maps search results page
2. **Phase 2** - Visits each business page individually to extract the full lead profile

---

### Why Use PHANTOM LEADS?

- **No API key required** - scrapes Google Maps directly
- **Deep data extraction** - goes beyond basic info to grab emails, socials, coordinates
- **Multi-query support** - run multiple search queries in a single Actor run
- **CRM-ready output** - structured JSON/CSV output compatible with HubSpot, Salesforce, Airtable
- **Sales automation friendly** - export leads for cold email, LinkedIn outreach, or ad targeting
- **Global coverage** - works with any country and language via `countryCode` and `language` parameters

---

### How Many Leads Can I Get?

> **Important:** Google Maps typically returns **80-120 unique businesses per search query**, regardless of the `maxLeadsPerQuery` setting. This is a Google Maps limitation, not an actor limit.

**To get 500-1,000 leads, use multiple specific queries in one run:**

| Goal | Strategy |
|------|----------|
| ~100 leads | 1 broad query: `"restaurants in New York"` |
| ~300 leads | 3 queries: `"Italian restaurants in Manhattan"`, `"Chinese restaurants in Brooklyn"`, `"Seafood restaurants in Queens"` |
| ~500 leads | 5 queries across niches or neighborhoods |
| ~1,000 leads | 10 targeted queries |

**Example input for 500 leads:**
```json
{
  "searchQueries": [
    "plumbers in Houston",
    "electricians in Houston",
    "HVAC companies in Houston",
    "roofers in Houston",
    "landscaping companies in Houston"
  ],
  "maxLeadsPerQuery": 100
}
````

This approach gives you **more targeted, niche-specific leads** and is the recommended way to build large lead lists.

***

### Quick Start

1. Click **Try for free** or **Save as task**
2. Set your `searchQueries` (e.g., `["plumbers in Houston", "lawyers in Chicago"]`)
3. Set `maxLeadsPerQuery` (default: 50)
4. Click **Start** and wait for results
5. Download your leads as **JSON**, **CSV**, or **Excel**

***

### Input

| Field | Type | Default | Description |
|--------|-------|---------|-------------|
| `searchQueries` | Array of strings | `["restaurants in New York"]` | Google Maps search queries to scrape |
| `maxLeadsPerQuery` | Integer | `50` | Maximum number of leads to extract per query (Google Maps caps results at ~100-120 per query) |
| `language` | String | `en` | Language code for Google Maps results (e.g., `en`, `fr`, `es`) |
| `countryCode` | String | *(optional)* | Country code to localize results (e.g., `us`, `gb`, `fr`) |

#### Example Input

```json
{
  "searchQueries": [
    "digital marketing agencies in Dubai",
    "accountants in London",
    "dentists in Toronto"
  ],
  "maxLeadsPerQuery": 50,
  "language": "en",
  "countryCode": "us"
}
```

***

### Output

Each result in the dataset represents one business lead with the following fields:

```json
{
  "name": "ABC Digital Agency",
  "address": "123 Main St, Suite 400",
  "phone": "+971 4 123 4567",
  "website": "https://abcdigital.com",
  "email": "hello@abcdigital.com",
  "rating": 4.8,
  "reviewCount": 312,
  "category": "Digital Marketing Agency",
  "googleMapsUrl": "https://maps.google.com/?cid=...",
  "socialLinks": {
    "facebook": "https://facebook.com/abcdigital",
    "instagram": "https://instagram.com/abcdigital",
    "linkedin": "https://linkedin.com/company/abcdigital"
  },
  "hours": "Monday-Friday 9AM-6PM",
  "query": "digital marketing agencies in Dubai",
  "scrapedAt": "2026-05-22T03:00:00.000Z"
}
```

> **Note on email extraction:** Emails are scraped from the business's own website where publicly listed. Not all businesses display an email on their homepage - typical email hit rates are **30-60%** depending on the industry. Retail, restaurants, and service businesses tend to have lower rates; agencies, law firms, and B2B companies tend to have higher rates.

***

### Use Cases

- **Cold email campaigns** - extract emails and contact info for outreach
- **Sales prospecting** - build targeted lead lists by niche and location
- **Market research** - analyze competitor density, ratings, and categories
- **CRM enrichment** - fill in missing data for existing contacts
- **Ad targeting** - build location-based audiences
- **Franchise research** - identify gaps and opportunities in specific cities
- **Directory building** - power local business directories or apps

***

### Pricing

This actor uses **pay-per-result** pricing. You are charged per business lead extracted:

| Tier | Price |
|-------|-------|
| Per result | $0.001 |
| 1,000 leads | ~$1.00 |
| 10,000 leads | ~$10.00 |

Free trial credits are available for new Apify users. Platform compute costs (memory/time) are billed separately per Apify's standard rates.

***

### Is It Legal?

This actor scrapes **publicly available data** from Google Maps - the same information anyone can view in a browser. It does not access private data, bypass authentication, or store personal information beyond what is publicly displayed.

As with any web scraping tool, users are responsible for complying with applicable laws (GDPR, CCPA, etc.) and the terms of service of the target website.

> **Always scrape responsibly.** Do not use this data to spam, harass, or engage in unsolicited contact that violates applicable law.

***

### FAQ

**Q: How many leads can I get per run?**
A: Google Maps limits each search query to approximately **80-120 unique business results**, regardless of scroll depth. To get more leads, add more search queries - the actor processes all queries in a single run. For example, 10 queries x 100 leads = ~1,000 leads per run.

**Q: Does it extract emails from websites?**
A: Yes - when a business has a website listed on Google Maps, the actor visits that website and attempts to extract any publicly visible email addresses. **Email availability depends entirely on whether the business lists an email on their website.** Expect roughly 30-60% of leads to have an email, depending on the industry. The email field will be empty for businesses with no website or businesses that do not display emails publicly.

**Q: What countries does it support?**
A: All countries where Google Maps operates. Use the `countryCode` and `language` parameters to localize results.

**Q: Can I schedule recurring scrapes?**
A: Yes - use Apify's built-in Scheduler to run this actor on a daily, weekly, or custom schedule.

**Q: What format is the output?**
A: JSON by default. You can download as CSV or Excel directly from the Apify dataset view.

***

### Support

For questions, bugs, or feature requests, please use the **Issues** tab on this actor's page or contact us through the Apify community forum.

***

*PHANTOM LEADS is maintained and updated regularly. Star this actor to stay notified of new features and improvements.*

# Actor input Schema

## `queries` (type: `array`):

List of Google Maps search queries. Each query can return up to ~99 results. Use multiple queries to get 1000+ leads (e.g. 'restaurants in New York', 'pizza in Brooklyn', 'burger in Manhattan').

## `maxLeadsPerQuery` (type: `integer`):

Maximum number of leads to collect per search query. Google Maps limits each query to ~80-120 results. Use more queries to get more total leads.

## `extractEmails` (type: `boolean`):

Visit each business website to attempt email extraction. Increases run time but improves email coverage.

## `countryCode` (type: `string`):

ISO 3166-1 alpha-2 country code to localize Google Maps results (e.g. 'US', 'GB', 'FR').

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

Language code for Google Maps results (e.g. 'en', 'fr', 'es').

## Actor input object example

```json
{
  "queries": [
    "restaurants in New York"
  ],
  "maxLeadsPerQuery": 100,
  "extractEmails": true,
  "language": "en"
}
```

# 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 = {
    "queries": [
        "restaurants in New York"
    ],
    "countryCode": "",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("renaissant_overload/phantom-leads-google-maps-business-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 = {
    "queries": ["restaurants in New York"],
    "countryCode": "",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("renaissant_overload/phantom-leads-google-maps-business-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 '{
  "queries": [
    "restaurants in New York"
  ],
  "countryCode": "",
  "language": "en"
}' |
apify call renaissant_overload/phantom-leads-google-maps-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PHANTOM LEADS - Google Maps Business Scraper",
        "description": "Scrape Google Maps business leads at scale: name, address, phone, website, email, social media, GPS coordinates, rating & reviews. Export CSV/JSON for cold email, CRM enrichment & sales prospecting. Multi-query, all countries & languages. Built for sales teams, agencies & B2B lead gen.",
        "version": "0.0",
        "x-build-id": "eaLd4mGr1hFRYoKnI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/renaissant_overload~phantom-leads-google-maps-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-renaissant_overload-phantom-leads-google-maps-business-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/renaissant_overload~phantom-leads-google-maps-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-renaissant_overload-phantom-leads-google-maps-business-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/renaissant_overload~phantom-leads-google-maps-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-renaissant_overload-phantom-leads-google-maps-business-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of Google Maps search queries. Each query can return up to ~99 results. Use multiple queries to get 1000+ leads (e.g. 'restaurants in New York', 'pizza in Brooklyn', 'burger in Manhattan').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxLeadsPerQuery": {
                        "title": "Max Leads Per Query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of leads to collect per search query. Google Maps limits each query to ~80-120 results. Use more queries to get more total leads.",
                        "default": 100
                    },
                    "extractEmails": {
                        "title": "Extract Emails",
                        "type": "boolean",
                        "description": "Visit each business website to attempt email extraction. Increases run time but improves email coverage.",
                        "default": true
                    },
                    "countryCode": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "ISO 3166-1 alpha-2 country code to localize Google Maps results (e.g. 'US', 'GB', 'FR')."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for Google Maps results (e.g. 'en', 'fr', 'es')."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
