# Insurance Agent Lead Scraper - Verified Emails (`samstorm/insurance-agent-lead-scraper`) Actor

Scrape insurance agent and agency leads from Google Maps with verified emails, phones and social links. Export clean data to HubSpot, Salesforce, CSV, JSON, or Excel.

- **URL**: https://apify.com/samstorm/insurance-agent-lead-scraper.md
- **Developed by:** [Sam Kleespies](https://apify.com/samstorm) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 verified email leads

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

## Insurance Agent Lead Scraper - Verified Emails

**Build a verified insurance email list in minutes - not days.** This actor searches Google Maps for insurance agents and agencies, visits each business website to extract email addresses, verifies every email via DNS + SMTP handshake, and pulls social media profiles - then exports it all in HubSpot- or Salesforce-ready format.

Built for carriers and MGAs recruiting agents, insurtech sales teams, agency aggregators, and B2B service providers targeting agencies.

> **Freemium pricing:** base lead results are effectively free - you only pay for leads that include a **verified email address** ($20/1,000), plus a $0.01 run start fee. No subscription, no minimum.

-

### What You Get Per Lead

- Business name, full address, phone number, website
- Google Maps rating and review count
- **Email addresses extracted from the business website** (contact pages, footers, about pages)
- **Two-stage email verification** - DNS MX lookup + SMTP handshake, no emails are sent
- Social profiles: Facebook, Instagram, LinkedIn, Twitter/X
- Export as CSV, JSON, or Excel - or pick HubSpot / Salesforce import format

### Why Verified Emails Matter

Most Google Maps scrapers stop at the listing: name, phone, maybe a generic website. Cold email to unverified addresses bounces 20-40% of the time, burning your sender reputation. This actor confirms each mailbox exists **before** it reaches your list - and you only pay for the leads that have one.

-

### How It Works

1. **Search Google Maps** for insurance agents and agencies in your target location ('Chicago, IL', 'Houston, TX', '60601')
2. **Crawl each website** for email addresses and social links
3. **Verify deliverability** of every email found (DNS MX + SMTP handshake - no emails sent)
4. **Export** clean, deduplicated leads in your CRM's import format

#### Input Example

```json
{
  "businessType": "Insurance Agency",
  "location": "Chicago, IL",
  "maxResults": 100,
  "enrichEmails": true,
  "verifyEmails": true,
  "outputFormat": "hubspot"
}
````

### Pricing

| Event | Price |
|-|-|
| Lead result (name, phone, address, website, socials) | ~free ($0.01 / 1,000) |
| Lead with a **verified email** | $20.00 / 1,000 |
| Run start | $0.01 |

Plus standard Apify platform usage for your runs. A typical 100-lead run with ~60 verified emails costs about **$1.25 total**.

### Use Cases

- **Carriers & MGAs** recruiting independent agents
- **Insurtech SaaS** (raters, AMS, CRM) outbound sales
- **Agency aggregators & networks** building M\&A pipelines
- **Continuing-education & compliance vendors** targeting agencies

### Scheduling & Scale

Use Apify Schedules to run weekly per metro area and keep your pipeline full. For full state or national coverage, run per city ("Insurance Agencies in Houston, TX", then "Dallas, TX", ...) - each run deduplicates within itself by business name + address.

-

### Feedback & Support

Found this actor useful? **A short review on the actor page helps other teams discover it** and keeps it actively maintained. Hit a problem or have a feature request? Open an issue on the Issues tab - issues are typically answered within a day or two.

-

### Related Keywords

insurance agent leads, insurance agency email list, independent agent database, insurance broker contacts, agency owner emails, google maps insurance scraper, verified insurance agent emails, insurance sales leads

# Actor input Schema

## `businessType` (type: `string`):

Select the type of insurance business to target. The actor builds the Google Maps query automatically - e.g., 'Insurance Agency' searches for 'Insurance Agencys in \[location]'. Choose 'Custom' to write your own query for niche searches.

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

The city, state, or region to search. Use 'City, ST' format for best results (e.g., 'Austin, TX' or 'Denver, CO'). You can also enter ZIP codes, neighborhoods, metro areas, or any geographic phrase Google Maps recognizes. Each location search returns up to ~120 listings.

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

A raw Google Maps search query - only used when Business Type is 'Custom'. Write it exactly as you would type it into Google Maps. Example: 'independent insurance agents in Columbus, OH'. Ignored when a named Business Type is selected.

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

The maximum number of leads to collect and return. The prefill is set to 3 for a quick test run - increase to 50-200 for production use. Google Maps typically returns up to 120 results per search query; use a smaller number first to verify data quality before scaling up.

## `enrichEmails` (type: `boolean`):

When enabled, the actor visits each business's website and scans contact pages, footers, and about pages for email addresses. This is what transforms raw Google Maps listings into a usable insurance email list. Disable only if you need phone numbers and addresses without website crawling.

## `verifyEmails` (type: `boolean`):

When enabled, each extracted email is validated via DNS MX lookup and SMTP handshake - confirming the mailbox exists before it reaches your list. Recommended for cold outreach where bounce rates hurt sender reputation. Adds ~1 min to the run. Only applies when 'Find Email Addresses' is enabled.

## `enrichSocials` (type: `boolean`):

When enabled, the actor extracts social media profiles (Facebook, Instagram, LinkedIn, Twitter/X) from each business's website. Useful for LinkedIn outreach, Facebook ads targeting, or multi-channel ABM campaigns.

## `outputFormat` (type: `string`):

Controls the structure of the output dataset. 'Full' returns all available fields. 'HubSpot Import' reformats the data to match HubSpot's CSV import column names for direct upload. 'Salesforce Import' reformats for Salesforce data import. All formats are available in Apify's dataset export (CSV, JSON, Excel).

## `proxyUrl` (type: `string`):

Optional HTTP proxy URL for using third-party residential proxies instead of Apify's built-in proxies. Format: http://username:password@host:port. Leave empty to use Apify's default residential proxies.

## Actor input object example

```json
{
  "businessType": "Insurance Agency",
  "location": "Austin, TX",
  "searchQuery": "independent insurance agents in Columbus, OH",
  "maxResults": 50,
  "enrichEmails": true,
  "verifyEmails": true,
  "enrichSocials": true,
  "outputFormat": "hubspot",
  "proxyUrl": "http://user:pass@proxy.example.com:8080"
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "location": "Chicago, IL",
    "searchQuery": "insurance agencies in Chicago, IL",
    "maxResults": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("samstorm/insurance-agent-lead-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "location": "Chicago, IL",
    "searchQuery": "insurance agencies in Chicago, IL",
    "maxResults": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("samstorm/insurance-agent-lead-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "location": "Chicago, IL",
  "searchQuery": "insurance agencies in Chicago, IL",
  "maxResults": 3
}' |
apify call samstorm/insurance-agent-lead-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=samstorm/insurance-agent-lead-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Insurance Agent Lead Scraper - Verified Emails",
        "description": "Scrape insurance agent and agency leads from Google Maps with verified emails, phones and social links. Export clean data to HubSpot, Salesforce, CSV, JSON, or Excel.",
        "version": "1.0",
        "x-build-id": "9fh54CyB0q2BruvJR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/samstorm~insurance-agent-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-samstorm-insurance-agent-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/samstorm~insurance-agent-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-samstorm-insurance-agent-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/samstorm~insurance-agent-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-samstorm-insurance-agent-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "businessType",
                    "location"
                ],
                "properties": {
                    "businessType": {
                        "title": "Business Type",
                        "enum": [
                            "Insurance Agency",
                            "Insurance Agent",
                            "Auto Insurance Agency",
                            "Life Insurance Agency",
                            "Home Insurance Agency",
                            "Insurance Broker",
                            "Custom"
                        ],
                        "type": "string",
                        "description": "Select the type of insurance business to target. The actor builds the Google Maps query automatically - e.g., 'Insurance Agency' searches for 'Insurance Agencys in [location]'. Choose 'Custom' to write your own query for niche searches.",
                        "default": "Insurance Agency"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "The city, state, or region to search. Use 'City, ST' format for best results (e.g., 'Austin, TX' or 'Denver, CO'). You can also enter ZIP codes, neighborhoods, metro areas, or any geographic phrase Google Maps recognizes. Each location search returns up to ~120 listings."
                    },
                    "searchQuery": {
                        "title": "Custom Search Query",
                        "type": "string",
                        "description": "A raw Google Maps search query - only used when Business Type is 'Custom'. Write it exactly as you would type it into Google Maps. Example: 'independent insurance agents in Columbus, OH'. Ignored when a named Business Type is selected."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "The maximum number of leads to collect and return. The prefill is set to 3 for a quick test run - increase to 50-200 for production use. Google Maps typically returns up to 120 results per search query; use a smaller number first to verify data quality before scaling up.",
                        "default": 50
                    },
                    "enrichEmails": {
                        "title": "Find Email Addresses",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each business's website and scans contact pages, footers, and about pages for email addresses. This is what transforms raw Google Maps listings into a usable insurance email list. Disable only if you need phone numbers and addresses without website crawling.",
                        "default": true
                    },
                    "verifyEmails": {
                        "title": "Verify Email Deliverability",
                        "type": "boolean",
                        "description": "When enabled, each extracted email is validated via DNS MX lookup and SMTP handshake - confirming the mailbox exists before it reaches your list. Recommended for cold outreach where bounce rates hurt sender reputation. Adds ~1 min to the run. Only applies when 'Find Email Addresses' is enabled.",
                        "default": true
                    },
                    "enrichSocials": {
                        "title": "Find Social Media Links",
                        "type": "boolean",
                        "description": "When enabled, the actor extracts social media profiles (Facebook, Instagram, LinkedIn, Twitter/X) from each business's website. Useful for LinkedIn outreach, Facebook ads targeting, or multi-channel ABM campaigns.",
                        "default": true
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "full",
                            "hubspot",
                            "salesforce"
                        ],
                        "type": "string",
                        "description": "Controls the structure of the output dataset. 'Full' returns all available fields. 'HubSpot Import' reformats the data to match HubSpot's CSV import column names for direct upload. 'Salesforce Import' reformats for Salesforce data import. All formats are available in Apify's dataset export (CSV, JSON, Excel).",
                        "default": "full"
                    },
                    "proxyUrl": {
                        "title": "Custom Proxy URL (optional)",
                        "type": "string",
                        "description": "Optional HTTP proxy URL for using third-party residential proxies instead of Apify's built-in proxies. Format: http://username:password@host:port. Leave empty to use Apify's default residential proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
