# Google Maps Lead Qualifier (`devoted_incident/google-maps-lead-qualifier`) Actor

Scrapes Google Maps and qualifies leads with AI. Returns only the best prospects with a score and reasoning — not raw data dumps.

- **URL**: https://apify.com/devoted\_incident/google-maps-lead-qualifier.md
- **Developed by:** [Natnael Habte](https://apify.com/devoted_incident) (community)
- **Categories:** AI, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Qualifier

**Stop wasting time on raw scrape dumps. Get only the leads worth calling — with AI-scored reasoning.**

Google Maps Lead Qualifier scrapes Google Maps for any business type in any city, then uses Claude AI to filter and score each business based on outreach potential. Instead of exporting 500 raw rows, you get the top leads with a score (1-10) and a one-sentence explanation of *why* each lead is promising.

---

### What does Google Maps Lead Qualifier do?

Most Google Maps scrapers dump raw data — addresses, ratings, phone numbers — and leave the filtering to you. This Actor does the thinking:

1. **Scrapes** Google Maps for your target business type and city
2. **Pre-filters** by rating and removes permanently closed businesses automatically
3. **Qualifies** each result with Claude AI — evaluating phone availability, website presence, review count, and business maturity
4. **Returns** only the leads worth contacting, each with an AI score (1-10) and a reason

**Example:** Search "Zahnarzt München" → get 50 raw results → Actor returns 18 qualified leads sorted by AI score, each with a note like *"No website, 180 reviews, phone available — high outreach potential"*

---

### Who is it for?

- **Sales & outreach teams** — find local businesses that need your service, already filtered to the best prospects
- **Marketing agencies** — build targeted lead lists for clients in any city or industry
- **Freelancers & consultants** — find SMBs with weak digital presence who need your help
- **Lead generation businesses** — resell qualified lead lists at a premium
- **n8n / Make / Zapier users** — pipe results directly into your outreach automation

---

### Why use this instead of a plain Google Maps scraper?

| Feature | Plain Scraper | Google Maps Lead Qualifier |
|---|---|---|
| Raw data export | ✅ | ✅ |
| AI-scored leads | ❌ | ✅ |
| Filters closed businesses | ❌ | ✅ |
| Rating pre-filter | ❌ | ✅ |
| Reasoning per lead | ❌ | ✅ |
| Pay only for qualified leads | ❌ | ✅ |

---

### What data does it return?

Each qualified lead contains:

| Field | Description |
|---|---|
| `name` | Business name |
| `qualificationScore` | AI score 1-10 (10 = best lead) |
| `rating` | Google star rating |
| `reviewCount` | Number of Google reviews |
| `phone` | Phone number (or N/A) |
| `website` | Website URL (or N/A if none — high outreach signal) |
| `address` | Full address |
| `category` | Business category from Google Maps |
| `reason` | One-sentence AI explanation of why this is a good lead |

---

### How much does it cost?

This Actor uses **pay-per-event pricing** — you only pay for qualified leads returned, not for every scraped result.

| Event | Price |
|---|---|
| Actor start (flat fee) | $0.005/run |
| Per qualified lead returned | $0.008/lead |

**Real-world examples:**

| Run | Scraped | Qualified | Total Cost |
|---|---|---|---|
| Zahnarzt, München, 50 results | 50 | ~15 leads | ~$0.13 |
| Steuerberater, Berlin, 100 results | 100 | ~30 leads | ~$0.25 |
| Klempner, Hamburg, 200 results | 200 | ~60 leads | ~$0.49 |

> **Note:** You also need an Anthropic API key (Claude Haiku). Cost is roughly $0.001 per lead analyzed — negligible.

---

### How to use it

1. Enter your **Business Type** (e.g. `Zahnarzt`, `Steuerberater`, `Klempner`, `dentist`, `plumber`)
2. Enter your **Location** (e.g. `München`, `Berlin`, `Vienna`, `Zurich`)
3. Set **Max Results to Scrape** — how many Google Maps results to process
4. Optionally set a **Minimum Rating** filter (default: 3.5 stars)
5. Enter your **Claude API Key** — get one free at [console.anthropic.com](https://console.anthropic.com)
6. Click **Start** and wait for results
7. Download as JSON, CSV, or Excel from the Dataset tab

---

### Example inputs

**Basic run — Dentists in Munich:**
```json
{
    "searchQuery": "Zahnarzt",
    "location": "München",
    "maxResults": 50,
    "minRating": 3.5,
    "claudeApiKey": "sk-ant-..."
}
````

**Larger run — Tax advisors in Berlin:**

```json
{
    "searchQuery": "Steuerberater",
    "location": "Berlin",
    "maxResults": 100,
    "minRating": 4.0,
    "language": "de",
    "claudeApiKey": "sk-ant-..."
}
```

**English-language run — Plumbers in London:**

```json
{
    "searchQuery": "plumber",
    "location": "London",
    "maxResults": 80,
    "minRating": 3.0,
    "language": "en",
    "claudeApiKey": "sk-ant-..."
}
```

***

### Example output

```json
{
    "name": "Zahnarztpraxis Dr. Müller",
    "qualificationScore": 9,
    "rating": 4.7,
    "reviewCount": 213,
    "phone": "+49 89 123456",
    "website": "N/A",
    "address": "Leopoldstraße 42, 80802 München",
    "category": "Dentist",
    "reason": "Established practice with 213 reviews and no website — high potential for digital marketing outreach."
}
```

***

### How to get the best results

- **Start small** — test with `maxResults: 10` before scaling up
- **No website = best lead** — businesses without websites are prime targets for web design, SEO, or digital marketing outreach
- **Set minRating: 4.0** for premium lead quality — established businesses with good reputation
- **Run multiple cities** — create separate runs per city for systematic coverage
- **Combine with n8n** — pipe results into a CRM or email outreach tool automatically

***

### API usage

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('YOUR_USERNAME/google-maps-lead-qualifier').call({
    searchQuery: 'Zahnarzt',
    location: 'München',
    maxResults: 50,
    claudeApiKey: 'sk-ant-...',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('YOUR_USERNAME/google-maps-lead-qualifier').call(run_input={
    'searchQuery': 'Zahnarzt',
    'location': 'München',
    'maxResults': 50,
    'claudeApiKey': 'sk-ant-...',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

***

### FAQ

**Do I need an Apify account?**
Yes — you need an Apify account for the platform. The Google Maps scraper (compass/crawler-google-places) runs on your Apify credits automatically.

**Do I need a Claude API key?**
Yes. Get one for free at [console.anthropic.com](https://console.anthropic.com). Claude Haiku is inexpensive — roughly $0.001 per lead analyzed.

**What types of businesses work best?**
Any local service business: dentists, accountants, plumbers, electricians, restaurants, lawyers, gyms, beauty salons. The Actor is industry-agnostic.

**What languages are supported?**
Currently: German (de), English (en), French (fr), Spanish (es), Italian (it). Set the `language` parameter accordingly.

**Can I scrape multiple cities in one run?**
Not in one run — run the Actor once per city for best results. Use Apify's scheduler to automate multi-city campaigns.

**What does "qualified" mean exactly?**
Claude evaluates each business on: phone availability, website presence (no website = high outreach signal), review count (established businesses), and category relevance. A score of 7+ means strong outreach potential.

**Can I use this with n8n or Make?**
Yes — call the Apify API from n8n using the HTTP Request node. Results land in Apify dataset; fetch them with the "Get Dataset Items" API call.

**Is Google Maps scraping legal?**
Scraping publicly available Google Maps data is generally accepted for commercial purposes. This Actor accesses only publicly visible business data (name, address, phone, website, reviews). Always comply with local data protection laws for your use case.

***

### Related Actors

- [Google Maps Scraper (compass/crawler-google-places)](https://apify.com/compass/crawler-google-places) — raw Google Maps data if you want to do your own filtering
- [Email Scraper](https://apify.com/apify/cheerio-scraper) — find email addresses from the websites returned

# Actor input Schema

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

What type of business are you looking for? (e.g. Zahnarzt, Steuerberater, Klempner)

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

City or region to search in

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

How many Google Maps results to fetch before AI filtering

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

Only consider businesses with at least this Google rating (0 = no filter)

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

Language for Google Maps results

## `claudeApiKey` (type: `string`):

Your Anthropic API key Ã¢â‚¬â€ get one at console.anthropic.com

## `productOrService` (type: `string`):

Describe your product or service so the AI can qualify leads specifically for your use case. Example: 'Kassensoftware fuer Zahnarztpraxen', 'SEO und Google Ads fuer lokale Businesses', 'Buchhaltungssoftware fuer KMU'

## Actor input object example

```json
{
  "searchQuery": "Zahnarzt",
  "location": "MÃƒÂ¼nchen",
  "maxResults": 50,
  "minRating": 3.5,
  "language": "de"
}
```

# 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": "Zahnarzt",
    "location": "MÃƒÂ¼nchen",
    "maxResults": 50,
    "minRating": 3.5,
    "language": "de",
    "productOrService": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("devoted_incident/google-maps-lead-qualifier").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": "Zahnarzt",
    "location": "MÃƒÂ¼nchen",
    "maxResults": 50,
    "minRating": 3.5,
    "language": "de",
    "productOrService": "",
}

# Run the Actor and wait for it to finish
run = client.actor("devoted_incident/google-maps-lead-qualifier").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": "Zahnarzt",
  "location": "MÃƒÂ¼nchen",
  "maxResults": 50,
  "minRating": 3.5,
  "language": "de",
  "productOrService": ""
}' |
apify call devoted_incident/google-maps-lead-qualifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Lead Qualifier",
        "description": "Scrapes Google Maps and qualifies leads with AI. Returns only the best prospects with a score and reasoning — not raw data dumps.",
        "version": "0.1",
        "x-build-id": "MeI8Ghmt8mcPefw4h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devoted_incident~google-maps-lead-qualifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devoted_incident-google-maps-lead-qualifier",
                "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/devoted_incident~google-maps-lead-qualifier/runs": {
            "post": {
                "operationId": "runs-sync-devoted_incident-google-maps-lead-qualifier",
                "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/devoted_incident~google-maps-lead-qualifier/run-sync": {
            "post": {
                "operationId": "run-sync-devoted_incident-google-maps-lead-qualifier",
                "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": [
                    "searchQuery",
                    "location"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Business Type",
                        "type": "string",
                        "description": "What type of business are you looking for? (e.g. Zahnarzt, Steuerberater, Klempner)"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to search in"
                    },
                    "maxResults": {
                        "title": "Max Results to Scrape",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many Google Maps results to fetch before AI filtering"
                    },
                    "minRating": {
                        "title": "Minimum Rating Filter",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only consider businesses with at least this Google rating (0 = no filter)"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "de",
                            "en",
                            "fr",
                            "es",
                            "it"
                        ],
                        "type": "string",
                        "description": "Language for Google Maps results"
                    },
                    "claudeApiKey": {
                        "title": "Claude API Key",
                        "type": "string",
                        "description": "Your Anthropic API key Ã¢â‚¬â€ get one at console.anthropic.com"
                    },
                    "productOrService": {
                        "title": "What are you selling?",
                        "type": "string",
                        "description": "Describe your product or service so the AI can qualify leads specifically for your use case. Example: 'Kassensoftware fuer Zahnarztpraxen', 'SEO und Google Ads fuer lokale Businesses', 'Buchhaltungssoftware fuer KMU'"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
