# Google Maps Lead Generator Pro with AI Enrichment (`jurassic_jove/google-maps-lead-generator-pro`) Actor

Scrape Google Maps businesses & visit each website to extract verified emails, social links, and phone numbers. AI enrichment on every lead: leadScore, digitalPresenceScore, opportunityType & bestOutreachChannel. $0.05/lead.

- **URL**: https://apify.com/jurassic\_jove/google-maps-lead-generator-pro.md
- **Developed by:** [Data Runner](https://apify.com/jurassic_jove) (community)
- **Categories:** Lead generation, AI, Social media
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 charged for each lead extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Lead Generator Pro with AI Enrichment

The most powerful **Google Maps scraper** for generating **local business leads** with real contact data. Built for **B2B lead generation**, this **Google Maps email extractor** goes beyond basic profile scraping — it visits every business website, extracts emails and social profiles, and runs **AI lead enrichment** on every result. If you need a **business contact scraper** that actually delivers actionable leads, not just names and addresses, this is it.

### What makes this different from basic Google Maps scrapers

Most Google Maps scrapers only pull data from the business profile. That gives you a name, address, maybe a phone number — and almost never an email. This Actor does what a human researcher would do, but at scale:

- **Visits each business's real website** using a full Playwright browser — not just the Google Maps listing
- **40-60% email hit rate** compared to less than 10% from profile-only scrapers
- **AI enrichment on every lead** — each business gets scored with `leadScore`, `digitalPresenceScore`, `businessHealthScore`, `opportunityType`, and `bestOutreachChannel`
- **Follows Linktree, Beacons, and 15+ link aggregators** — if a business uses a link-in-bio page instead of a traditional website, this Actor finds the real links behind it
- **Extracts full social media profiles** — Facebook, Instagram, LinkedIn, Twitter/X, TikTok, YouTube
- **Multiple search queries** — run several searches in one go and combine results with automatic deduplication
- **Optional review extraction** — pull recent Google reviews with author, rating, text, and date

The result: leads you can actually reach out to, with data that tells you exactly what to pitch and how.

### Who is it for

- **Sales teams** doing local outreach and cold calling
- **Marketing agencies** building prospect lists for clients
- **B2B service providers** — web design, SEO, social media management, reputation management
- **Real estate agents, contractors, and consultants** looking for local business clients
- **Anyone running cold email or cold calling campaigns** who needs verified contact data with context

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | string | Single search query, e.g. `"plumbers in Tampa FL"` | — |
| `searchQueries` | array | Multiple queries, e.g. `["plumbers in Tampa FL", "electricians in Tampa FL"]` | — |
| `location` | string | Optional city or region to focus the search | — |
| `maxResults` | number | Maximum number of leads to return (total across all queries) | 50 |
| `maxConcurrency` | number | Parallel browser sessions for website visiting | 5 |
| `includeReviews` | boolean | Extract recent Google reviews for each business | false |
| `maxReviewsPerBusiness` | number | Max reviews to extract per business (when reviews enabled) | 10 |

You can use `searchQuery` (single string) or `searchQueries` (array) or both. If both are provided, all queries are combined.

### Output

Every lead includes the full business profile, extracted contact data, and AI-generated scores:

#### Business Profile

| Field | Description |
|-------|-------------|
| `businessName` | Business name from Google Maps |
| `category` | Google Maps business category |
| `address` | Full street address |
| `phone` | Phone number |
| `website` | Business website URL |
| `rating` | Google Maps star rating (1-5) |
| `reviewCount` | Total number of Google reviews |
| `openingHours` | Weekly opening hours |
| `googleMapsUrl` | Direct link to Google Maps listing |

#### Contact Data (extracted from website)

| Field | Description |
|-------|-------------|
| `emails` | Email addresses found on the website, contact pages, footers, and mailto links |
| `socialLinks.facebook` | Facebook page URL |
| `socialLinks.instagram` | Instagram profile URL |
| `socialLinks.linkedin` | LinkedIn page URL |
| `socialLinks.twitter` | Twitter/X profile URL |
| `socialLinks.tiktok` | TikTok profile URL |
| `socialLinks.youtube` | YouTube channel URL |

#### AI Enrichment

| Field | Description |
|-------|-------------|
| `niche` | Specific sub-category beyond Google's broad category |
| `digitalPresenceScore` | 1-10 score based on website quality, social media presence, and online visibility |
| `businessHealthScore` | 1-10 score based on rating, review count, and review recency |
| `leadScore` | 1-10 overall outreach potential — higher means better prospect |
| `decisionMakerScore` | 1-10 likelihood of reaching a decision maker directly |
| `weaknessFlags` | Array of identified gaps: `"no website"`, `"low reviews"`, `"no social media"`, `"poor rating"`, `"no email found"` |
| `opportunityType` | What service they most likely need: `"web design"`, `"SEO"`, `"social media"`, `"reputation management"` |
| `bestOutreachChannel` | Recommended way to reach them: `"email"`, `"phone"`, `"instagram"`, `"facebook"`, `"linkedin"` |

#### Reviews (optional)

When `includeReviews` is enabled, each lead includes a `reviews` array:

| Field | Description |
|-------|-------------|
| `reviews[].authorName` | Name of the reviewer |
| `reviews[].rating` | Star rating (1-5) |
| `reviews[].text` | Full review text |
| `reviews[].date` | When the review was posted |

### Pricing

- **$0.05 per lead** — you only pay for results, not for searches or failed attempts
- **$0.01 per review** — only charged when `includeReviews` is enabled

AI enrichment is included at no extra cost. Every lead comes with full scoring and opportunity analysis.

### How it works

1. **Searches Google Maps** using your keywords and optional location filter — supports multiple queries in one run
2. **Deduplicates results** across queries so you never pay for the same business twice
3. **Extracts business profiles** — name, address, phone, rating, reviews, hours, category
4. **Extracts recent reviews** (optional) — author, rating, full text, and date
5. **Visits each business website** with a real browser to find emails and social links
6. **Follows link aggregators** — if a business links to Linktree, Beacons, or similar services, the Actor follows those links to find the real website, email, and social profiles
7. **AI enriches every lead** with scores, weakness analysis, opportunity type, and recommended outreach channel

No manual work. No CSV imports. Just run a search and get enriched, ready-to-use leads.

### Tips for best results

- **Use specific searches** — `"dentists in Miami FL"` works much better than just `"dentists"`. Include the city and state for targeted local results.
- **Use multiple queries** — combine related searches like `["plumbers in Tampa FL", "HVAC in Tampa FL", "electricians in Tampa FL"]` to build a comprehensive list in one run.
- **Filter by leadScore** — leads scored 7+ are your best outreach candidates. Sort by `leadScore` descending to prioritize.
- **Use weaknessFlags to craft your pitch** — if a business has `"no website"`, pitch web design. If they have `"low reviews"`, pitch reputation management. The data tells you what to sell.
- **Check opportunityType** — this field tells you exactly what service each business is most likely to need, so you can personalize your outreach.
- **Use bestOutreachChannel** — don't waste time emailing businesses that are most responsive on Instagram, or calling businesses that prefer email.
- **Enable reviews for reputation management pitches** — seeing actual low-star reviews helps you craft specific, compelling outreach.
- **Start with maxResults: 20** to test your search query before running larger batches.

### Supported link aggregators

This Actor detects and follows all major link-in-bio and link aggregator services to find the real contact data behind them:

Linktree, Beacons, Bio.link, Tap.bio, Campsite.bio, Lnk.bio, Carrd, Solo.to, Stan Store, Snipfeed, Milkshake, Koji, Hoo.be, Flowpage, Direct.me, InstaBio, ContactInBio, Feedlink, Many.link, Shorby, Later Link in Bio, About.me, Bio.fm, and more.

### MCP Compatible

[![MCP](https://img.shields.io/badge/MCP-Compatible-blue)](https://apify.com/docs/integrations/mcp)

This Actor is **MCP-compatible**. Use it with Claude Desktop, Cursor, or any MCP client via the [Apify MCP server](https://apify.com/apify/actors-mcp-server).

#### Claude Desktop configuration

Add this to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-apify"],
      "env": {
        "APIFY_TOKEN": "your-apify-token"
      }
    }
  }
}
````

Then ask Claude: *"Search Google Maps for plumbers in Tampa FL and enrich the leads"* — it will call this Actor automatically.

***

Built by [data-runner.dev](https://data-runner.dev)

# Actor input Schema

## `searchQuery` (type: `string`):

Single search query for Google Maps, e.g. "plumbers in Tampa FL". Use this OR searchQueries.

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

Array of search queries to run. Results from all queries are combined. Example: \["plumbers in Tampa FL", "electricians in Tampa FL"]

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

Optional city/region to focus the search. Leave empty to rely on the search query.

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

Maximum number of business leads to return (total across all queries).

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

Maximum number of parallel browser pages for website visiting.

## `includeReviews` (type: `boolean`):

Extract recent Google reviews for each business. Additional $0.01 per review extracted.

## `maxReviewsPerBusiness` (type: `integer`):

Maximum number of reviews to extract per business (only used when Include Reviews is enabled).

## Actor input object example

```json
{
  "searchQuery": "plumbers in Tampa FL",
  "maxResults": 50,
  "maxConcurrency": 5,
  "includeReviews": false,
  "maxReviewsPerBusiness": 10
}
```

# 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 = {
    "searchQuery": "plumbers in Tampa FL"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jurassic_jove/google-maps-lead-generator-pro").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 = { "searchQuery": "plumbers in Tampa FL" }

# Run the Actor and wait for it to finish
run = client.actor("jurassic_jove/google-maps-lead-generator-pro").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 '{
  "searchQuery": "plumbers in Tampa FL"
}' |
apify call jurassic_jove/google-maps-lead-generator-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Lead Generator Pro with AI Enrichment",
        "description": "Scrape Google Maps businesses & visit each website to extract verified emails, social links, and phone numbers. AI enrichment on every lead: leadScore, digitalPresenceScore, opportunityType & bestOutreachChannel. $0.05/lead.",
        "version": "1.0",
        "x-build-id": "tZqGbLRNUawGPwaI8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jurassic_jove~google-maps-lead-generator-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jurassic_jove-google-maps-lead-generator-pro",
                "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/jurassic_jove~google-maps-lead-generator-pro/runs": {
            "post": {
                "operationId": "runs-sync-jurassic_jove-google-maps-lead-generator-pro",
                "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/jurassic_jove~google-maps-lead-generator-pro/run-sync": {
            "post": {
                "operationId": "run-sync-jurassic_jove-google-maps-lead-generator-pro",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Single search query for Google Maps, e.g. \"plumbers in Tampa FL\". Use this OR searchQueries."
                    },
                    "searchQueries": {
                        "title": "Search Queries (multiple)",
                        "type": "array",
                        "description": "Array of search queries to run. Results from all queries are combined. Example: [\"plumbers in Tampa FL\", \"electricians in Tampa FL\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional city/region to focus the search. Leave empty to rely on the search query."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of business leads to return (total across all queries).",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of parallel browser pages for website visiting.",
                        "default": 5
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Extract recent Google reviews for each business. Additional $0.01 per review extracted.",
                        "default": false
                    },
                    "maxReviewsPerBusiness": {
                        "title": "Max Reviews Per Business",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per business (only used when Include Reviews is enabled).",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
