# Google Maps Full Leads Extractor (`vectorops-project/google-maps-full-extractor`) Actor

Extract structured Google Maps leads with websites, emails, ratings, reviews, contacts, geo filters, lead scores, and clean business-ready exports.

- **URL**: https://apify.com/vectorops-project/google-maps-full-extractor.md
- **Developed by:** [VectorOps Team](https://apify.com/vectorops-project) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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 Full Leads Extractor

Extract structured Google Maps leads, seriously cleaned and ready for export, with available business details such as contacts, websites, emails, ratings, review counts, and Google Maps URLs.

### What this Actor does

Google Maps Full Leads Extractor helps collect structured business data from Google Maps searches and prepares it for prospecting, lead research, local business analysis, and business workflow integration.

The goal is not only to extract raw data, but to produce cleaner, more readable, and more usable outputs for people who need business leads they can quickly review, export, and use.

This Actor is designed to provide a solid, practical extraction layer: structured Google Maps data, useful contact fields, website detection, email detection when available, and simple scoring signals to help prioritize leads.

### Main features

- Extract Google Maps business listings
- Get business names, categories, addresses, cities, postal codes, and countries
- Extract phone numbers when available
- Extract business websites when available
- Detect emails from business websites when available
- Extract ratings and review counts when available
- Extract Google Maps URLs
- Apply basic geographic filtering for cleaner local results
- Add lead scoring based on available business information
- Export structured results to an Apify dataset

### Example use cases

- Build local prospecting lists
- Find businesses in a specific niche and location
- Prepare lead datasets for outreach
- Research local markets and competitors
- Collect business information for sales, marketing, or operations
- Export structured data for spreadsheets, CRMs, or business workflows
- Use Google Maps data as a starting point for deeper lead qualification

### Input

You can configure the Actor with one or more Google Maps search queries, result limits, and optional enrichment settings.

Example:

```json
{
  "searchStrings": [
    "eyewear store Aspen"
  ],
  "locationName": "Aspen",
  "country": "US",
  "language": "en",
  "maxPlacesPerSearch": 5,
  "includeEmails": true,
  "includeReviews": true,
  "includeSocialLinks": false,
  "exportReviewsLimit": 3
}
````

### Output

The Actor returns structured business data in the Apify dataset.

Example output fields:

- `searchString`
- `locationName`
- `placeId`
- `businessName`
- `category`
- `address`
- `city`
- `postalCode`
- `country`
- `phone`
- `website`
- `emails`
- `rating`
- `reviewsCount`
- `googleMapsUrl`
- `openingHours`
- `hasWebsite`
- `hasEmail`
- `leadScore`
- `scrapedAt`

### Notes about email extraction

Email extraction depends on what is publicly available on each business website.

Some businesses publish clear contact emails. Others use contact forms, hidden emails, JavaScript-rendered pages, third-party platforms, or no public email at all.

For this reason, the Actor detects emails when available, but it does not guarantee that every business will have an email.

### Notes about data quality

Google Maps data can vary depending on the location, business category, language, country, and Google Maps page structure.

The Actor is designed to return structured and usable data, but some fields may be missing when they are not available or not reliably detected.

### Best for

This Actor is useful if you need a practical Google Maps extraction tool for:

- local lead generation
- market research
- business list building
- sales prospecting
- spreadsheet exports
- workflow automation
- first-level business data collection

### Not designed for

This Actor is not intended to replace a full manual lead qualification process.

For advanced outreach campaigns, you may still want to review, filter, enrich, or validate the exported data depending on your business use case.

# Actor input Schema

## `searchStrings` (type: `array`):

One or more Google Maps search queries, for example: eyewear store Aspen, dentist Miami, restaurant London.

## `locationName` (type: `string`):

Optional location label such as Aspen, New York, London, etc.

## `googleMapsUrls` (type: `array`):

Optional list of direct Google Maps URLs to process.

## `latitude` (type: `number`):

Optional latitude for geo filtering.

## `longitude` (type: `number`):

Optional longitude for geo filtering.

## `radiusKm` (type: `number`):

Optional radius around the given coordinates.

## `maxPlacesPerSearch` (type: `integer`):

Maximum number of places to extract for each search.

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

Optional country code or country name, for example US, United States, GB, United Kingdom, FR, or France.

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

Preferred language for results, for example en, fr, es, de, or it.

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

Try to extract website URLs.

## `includeEmails` (type: `boolean`):

Try to find emails on the business website when available.

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

Extract reviews when available.

## `includeSocialLinks` (type: `boolean`):

Try to find social media links on the website.

## `onlyWithWebsite` (type: `boolean`):

Keep only businesses with a website.

## `onlyWithEmail` (type: `boolean`):

Keep only businesses where at least one email was found.

## `minRating` (type: `number`):

Keep only businesses with a rating equal to or higher than this value.

## `minReviewsCount` (type: `integer`):

Keep only businesses with at least this many reviews.

## `categoryInclude` (type: `array`):

Optional list of categories to include.

## `categoryExclude` (type: `array`):

Optional list of categories to exclude.

## `deduplicateBy` (type: `string`):

How duplicates should be removed.

## `exportReviewsLimit` (type: `integer`):

Maximum number of reviews to export per place.

## `debugMode` (type: `boolean`):

Enable extra logs for debugging.

## Actor input object example

```json
{
  "searchStrings": [
    "eyewear store Aspen"
  ],
  "radiusKm": 5,
  "maxPlacesPerSearch": 5,
  "country": "US",
  "language": "en",
  "includeWebsite": true,
  "includeEmails": true,
  "includeReviews": true,
  "includeSocialLinks": false,
  "onlyWithWebsite": false,
  "onlyWithEmail": false,
  "minRating": 0,
  "minReviewsCount": 0,
  "deduplicateBy": "placeId",
  "exportReviewsLimit": 5,
  "debugMode": false
}
```

# Actor output Schema

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

Structured Google Maps leads extracted by the Actor.

# 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 = {
    "searchStrings": [
        "eyewear store Aspen"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vectorops-project/google-maps-full-extractor").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 = { "searchStrings": ["eyewear store Aspen"] }

# Run the Actor and wait for it to finish
run = client.actor("vectorops-project/google-maps-full-extractor").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 '{
  "searchStrings": [
    "eyewear store Aspen"
  ]
}' |
apify call vectorops-project/google-maps-full-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Full Leads Extractor",
        "description": "Extract structured Google Maps leads with websites, emails, ratings, reviews, contacts, geo filters, lead scores, and clean business-ready exports.",
        "version": "0.0",
        "x-build-id": "ZOGf2ma1drosKSX7F"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vectorops-project~google-maps-full-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vectorops-project-google-maps-full-extractor",
                "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/vectorops-project~google-maps-full-extractor/runs": {
            "post": {
                "operationId": "runs-sync-vectorops-project-google-maps-full-extractor",
                "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/vectorops-project~google-maps-full-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-vectorops-project-google-maps-full-extractor",
                "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": {
                    "searchStrings": {
                        "title": "Search strings",
                        "type": "array",
                        "description": "One or more Google Maps search queries, for example: eyewear store Aspen, dentist Miami, restaurant London.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationName": {
                        "title": "Location name",
                        "type": "string",
                        "description": "Optional location label such as Aspen, New York, London, etc."
                    },
                    "googleMapsUrls": {
                        "title": "Google Maps URLs",
                        "type": "array",
                        "description": "Optional list of direct Google Maps URLs to process.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "number",
                        "description": "Optional latitude for geo filtering."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "number",
                        "description": "Optional longitude for geo filtering."
                    },
                    "radiusKm": {
                        "title": "Radius in km",
                        "type": "number",
                        "description": "Optional radius around the given coordinates.",
                        "default": 5
                    },
                    "maxPlacesPerSearch": {
                        "title": "Max places per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of places to extract for each search.",
                        "default": 5
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional country code or country name, for example US, United States, GB, United Kingdom, FR, or France.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Preferred language for results, for example en, fr, es, de, or it.",
                        "default": "en"
                    },
                    "includeWebsite": {
                        "title": "Include website",
                        "type": "boolean",
                        "description": "Try to extract website URLs.",
                        "default": true
                    },
                    "includeEmails": {
                        "title": "Include emails",
                        "type": "boolean",
                        "description": "Try to find emails on the business website when available.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Extract reviews when available.",
                        "default": true
                    },
                    "includeSocialLinks": {
                        "title": "Include social links",
                        "type": "boolean",
                        "description": "Try to find social media links on the website.",
                        "default": false
                    },
                    "onlyWithWebsite": {
                        "title": "Only with website",
                        "type": "boolean",
                        "description": "Keep only businesses with a website.",
                        "default": false
                    },
                    "onlyWithEmail": {
                        "title": "Only with email",
                        "type": "boolean",
                        "description": "Keep only businesses where at least one email was found.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "type": "number",
                        "description": "Keep only businesses with a rating equal to or higher than this value.",
                        "default": 0
                    },
                    "minReviewsCount": {
                        "title": "Minimum reviews count",
                        "type": "integer",
                        "description": "Keep only businesses with at least this many reviews.",
                        "default": 0
                    },
                    "categoryInclude": {
                        "title": "Included categories",
                        "type": "array",
                        "description": "Optional list of categories to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryExclude": {
                        "title": "Excluded categories",
                        "type": "array",
                        "description": "Optional list of categories to exclude.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "deduplicateBy": {
                        "title": "Deduplicate by",
                        "enum": [
                            "placeId",
                            "phone",
                            "website",
                            "nameAddress"
                        ],
                        "type": "string",
                        "description": "How duplicates should be removed.",
                        "default": "placeId"
                    },
                    "exportReviewsLimit": {
                        "title": "Reviews limit",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to export per place.",
                        "default": 5
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable extra logs for debugging.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
