# Google Maps Leads Qualifier (`norvane/google-maps-leads-qualifier`) Actor

Qualify Google Maps leads against your ideal customer before paying for downstream enrichment.

- **URL**: https://apify.com/norvane/google-maps-leads-qualifier.md
- **Developed by:** [Norvane Labs](https://apify.com/norvane) (community)
- **Categories:** Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 qualified lead (with website analysis)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Maps Leads Qualifier

> **Qualify Google Maps leads against your ideal customer profile BEFORE you pay to enrich them.**

***

#### Stop paying to enrich leads you will never email.

Typical Google Maps scrapes are **50% to 80% off-target** for a specific B2B Ideal Customer Profile (franchises, public clinics, closed businesses, wrong industry).

> **Net Savings Formula:**\
> **Savings per 1,000 leads** ≈ (1 - pass rate) × (downstream cost per lead) - $3.00

- At a typical **37% pass rate** and **$0.036 downstream enrichment cost**:\
  **Save ≈ $19.68 net per 1,000 leads**, while concentrating your mailboxes on **2.7× more on-target decision makers**.
- Enter your actual downstream costs in the `downstreamCostPerLead` input field and each run will automatically report your **exact dollar ROI** in the `SUMMARY` view.

***

### ⚡ Auto-Qualify Every Google Maps Scrape (3-Click Integration)

Attach this Actor as an automatic filter directly downstream of any Google Maps scraper (e.g. `compass/crawler-google-places`):

1. In your **Google Maps Scraper** on Apify, click the **Integrations** tab.
2. Click **Add integration** → **Run an Actor**, and select `norvane/google-maps-leads-qualifier`.
3. In the input configuration, enter:

```json
{
  "datasetId": "{{resource.defaultDatasetId}}",
  "icpDescription": "Your ideal customer profile and exclusions..."
}
```

Whenever your scraper completes, your leads are automatically filtered and scored before you touch or export them.

***

### What You Get Per Lead

Every processed row retains all original Google Maps fields and appends our frozen **Version 1** qualification fields:

| Field | Type | Description | Example |
|---|---|---|---|
| `qualified` | `boolean` | `true` if probability >= threshold and business is not closed | `true` |
| `icp_probability` | `float` (0.00 - 1.00) | Calibrated probability of match against your ICP | `0.94` |
| `fit_score` | `float` (1.0 - 10.0) | Calibrated qualitative fit rating | `9.4` |
| `business_type` | `string` | Categorization: `independent`, `chain`, `franchise`, `government`, `nonprofit`, `unclear` | `independent` |
| `customer_model` | `string` | Focus: `B2B`, `B2C`, `both`, `unclear` | `B2B` |
| `website_status` | `string` | Live analysis status: `live`, `none`, `social_only`, `platform_page`, `dead`, `blocked` | `live` |
| `confidence_band` | `string` | Decision reliability band: `high`, `medium`, `uncertain` | `high` |
| `reason_code` | `string` | Deterministic explanation code: `site_matched`, `category_only`, `closed`, etc. | `site_matched` |
| `schemaVersion` | `integer` | Guaranteed immutable schema version (never breaking your pipelines) | `1` |

***

### 3-Step Quickstart

1. **Scrape Google Maps** using any scraper (e.g. `compass/crawler-google-places`) **WITHOUT** paid enrichment add-ons.
2. **Open Google Maps Leads Qualifier**, paste the `datasetId` (or pass it via an Apify Integration Task).
3. **Describe your Ideal Customer (ICP)** in plain English (e.g. *"Independent dental clinics offering cosmetic dentistry or implants; exclude hospitals and corporate dental chains"*), select your threshold, and click **Save & Run**.

> 💡 **Try it free:** Leave `datasetId` empty to run an immediate, zero-cost demo on our pre-loaded 20-row sample dataset.

***

### Transparent Pay-Per-Event (PPE) Pricing

| Event | Price | When Billed |
|---|---|---|
| **Lead Qualified (with Website Analysis)** | **$0.003** per lead ($3.00 / 1k) | Business evaluated with live homepage content fetch |
| **Lead Qualified (Metadata Only)** | **$0.001** per lead ($1.00 / 1k) | Evaluated from name, category & description (no website, social-only, or `analyzeWebsite=false`) |
| **Duplicate Places** | **$0.000 (Free)** | Repeated `placeId`s in the same dataset are deduplicated at zero charge |
| **Demo Execution** | **$0.000 (Free)** | Zero-input sample runs are always 100% free |

*Fairness Guarantee: You are charged per processed lead. Non-qualified leads are accessible in the `Rejected` tab view so you can audit every single decision.*

***

### Writing an Effective ICP Description

| ❌ Poor / Vague ICP (High False Positives) | ✅ High-Precision ICP (Recommended) |
|---|---|
| *"Small businesses in healthcare"* | *"Independent physiotherapy and sports injury clinics with private practitioners. Exclude public health centers and hospital departments."* |
| *"Restaurants and food companies"* | *"High-end independent Italian restaurants offering wine pairings. Exclude fast food, pizza slices, chains, and franchise brands."* |
| *"Software companies"* | *"B2B SaaS companies selling human resources or payroll software. Exclude agencies, dev shops, and IT consultancies."* |

***

### Choosing Your Threshold (`minProbability`)

- **Balanced (`0.50` - Default):** Ideal for standard outbound campaigns. Optimizes net dollar savings while filtering out ~60% of unqualified noise.
- **High Recall (`0.30`):** Ideal when your contract value (ACV) is high ($1,000+) and missing a valid lead is expensive. Catches almost every borderline candidate.
- **High Precision (`0.70`):** Ideal when mailbox sender capacity is strictly limited and you want only the absolute highest-conviction prospects.

***

### Automated Workflow Integrations

#### Native Apify Task Automation

Create an Apify Schedule for your Google Maps Scraper, then add an **Integration → Run Actor** targeting `google-maps-leads-qualifier` passing `datasetId: "{{resource.defaultDatasetId}}"`. Every week, your scraped leads are automatically qualified and waiting in your dataset.

#### n8n Workflow Integration

Paste the following HTTP Request node into your n8n canvas:

```json
{
  "name": "Qualify Google Maps Leads",
  "type": "n8n-nodes-base.httpRequest",
  "parameters": {
    "method": "POST",
    "url": "https://api.apify.com/v2/acts/norvane~google-maps-leads-qualifier/run-sync-get-dataset-items",
    "sendQuery": true,
    "queryParameters": {
      "parameters": [
        { "name": "token", "value": "={{$env.APIFY_TOKEN}}" }
      ]
    },
    "sendBody": true,
    "specifyBody": "json",
    "jsonBody": "={ \"datasetId\": \"{{$json.defaultDatasetId}}\", \"icpDescription\": \"Independent dental clinics offering implants\", \"minProbability\": \"0.5\" }",
    "options": {
      "timeout": 300000
    }
  }
}
```

#### Make.com Blueprint

Add the **Apify: Run an Actor and Get Dataset Items** module. Connect it after your Google Maps scraper and route `qualified = true` leads directly to your CRM (HubSpot, Pipedrive) or outreach tools (Smartlead, Instantly).

***

### Data Privacy & Sub-Processors

Text snippets and business metadata are transmitted over encrypted TLS to our low-latency System 1 decision engine (`TypeSafe AI`) solely to compute qualification probabilities and fit scores. Data is never used for training models and is processed in accordance with enterprise data protection standards.

# Actor input Schema

## `datasetId` (type: `string`):

Dataset ID from an upstream scraper. Do not enable paid upstream enrichment if your goal is to qualify before enriching.

## `items` (type: `array`):

Inline source, up to 1,000 records and 4 MB. Use datasetId for larger sources. An explicitly empty array is an empty source, not a demo.

## `icpDescription` (type: `string`):

Required for real sources. Describe observable business types, services, ownership, and exclusions. The demo uses its fixed sample ICP.

## `excludeDescription` (type: `string`):

Optional exclusions such as chains, hospital departments, or businesses offering only general dentistry.

## `analyzeWebsite` (type: `boolean`):

$0.003 per processed lead when usable homepage text is analyzed. Metadata-only decisions cost $0.001, including absent, blocked, dead, social-only, and closed-business cases.

## `minProbability` (type: `string`):

Minimum probability required to qualify a lead (0.3 for high recall, 0.5 for balanced, 0.7 for high precision).

## `outputMode` (type: `string`):

Billing is per processed lead, not per qualified lead. In qualifiedOnly mode, SUMMARY contains the audit\_dataset\_id holding all paid decisions, including rejected leads.

## `maxItems` (type: `integer`):

Maximum input positions consumed. Invalid and duplicate records count toward the scan limit but are not charged.

## `downstreamCostPerLead` (type: `string`):

Optional decimal such as 0.036. SUMMARY estimates avoided downstream spend. This does not estimate the opportunity cost of false negatives.

## `fieldMapping` (type: `object`):

Map supported logical keys to top-level source fields. Supported keys: nameField, websiteField, categoryField, descriptionField, placeIdField, addressField, phoneField, cityField, languageField, closedField, temporarilyClosedField.

## `payload` (type: `object`):

Supports payload.resource.defaultDatasetId, or payload.resource.id containing the upstream run ID.

## Actor input object example

```json
{
  "icpDescription": "Independent dental clinics offering implants or cosmetic dentistry; exclude chains and hospital departments.",
  "analyzeWebsite": true,
  "minProbability": "0.5",
  "outputMode": "all",
  "maxItems": 10000
}
```

# Actor output Schema

## `leads` (type: `string`):

Standard output dataset containing qualified Google Maps leads.

# 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 = {
    "icpDescription": "Independent dental clinics offering implants or cosmetic dentistry; exclude chains and hospital departments."
};

// Run the Actor and wait for it to finish
const run = await client.actor("norvane/google-maps-leads-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 = { "icpDescription": "Independent dental clinics offering implants or cosmetic dentistry; exclude chains and hospital departments." }

# Run the Actor and wait for it to finish
run = client.actor("norvane/google-maps-leads-qualifier").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "icpDescription": "Independent dental clinics offering implants or cosmetic dentistry; exclude chains and hospital departments."
}' |
apify call norvane/google-maps-leads-qualifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,norvane/google-maps-leads-qualifier"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ffcHOneM6shNlEjEG/builds/yJ5wfA90bAwCpqVnH/openapi.json