# lead scraper (email) (`coder_luffy/lead-scraper-email`) Actor

Lead Scraper (Email) generates targeted business leads from any keyword. Get emails, phone numbers, websites, addresses, and more—perfect for B2B marketing, outreach, and lead generation. Fast, accurate, and easy to use.

- **URL**: https://apify.com/coder\_luffy/lead-scraper-email.md
- **Developed by:** [Luffy](https://apify.com/coder_luffy) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 410 total users, 2 monthly users, 100.0% runs succeeded, 22 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$9.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

## Business Lead Scraper: Generate B2B Leads with Emails from Any Keyword Search

![Business Lead Scraper](https://i.imgur.com/8pVUcbY.png)

### You know what kind of businesses you want to reach. Finding them is the easy part.

Search "digital marketing agencies in London" and you get a list of names. No emails. No direct phone numbers you can use for outreach. Just enough to start the real work — visiting every site, hunting for a contact page, copying an email, pasting it somewhere, and doing it again two hundred times.

That afternoon belongs to you. Not a spreadsheet.

---

### The problem is not finding businesses. It is reaching them.

Every city has hundreds of businesses in every niche. The names are public. The addresses are listed. But to actually contact them — to send an email, start a conversation, make a pitch — you have to visit each site individually and hope they have a contact page with something useful on it.

Sales teams spend entire mornings on this. Agencies pad their timelines to account for it. Lead generation services sell you lists that are six months old and filled with generic contact forms instead of real emails.

There is a faster way to go from search phrase to outreach-ready contact list.

---

### Type a keyword. Get a contact list.

Business Lead Scraper searches for businesses matching your keyword, visits each company website, and returns a structured dataset with everything you need to start outreach — no manual work required.

**Step 1: Add your search queries**
Use any phrase you would type to find businesses: "SEO agencies in New York," "roofing contractors in Miami FL," "dentists near downtown Chicago." Add as many queries as you need.

**Step 2: Run the actor**
The actor searches each query, finds every matching business, visits the website for each one, and collects the email address — automatically, in parallel, as fast as the sites allow.

**Step 3: Download your lead list**
Records appear in your dataset as each business finishes processing. Export as CSV or JSON, push to Google Sheets, or connect directly to your CRM or email tool.

---

### What you get for every business

For each business found, the actor returns a clean, structured lead record:

- **Business name**
- **Full address** (street, city, state, ZIP)
- **Phone number**
- **Website URL**
- **Email address** extracted directly from the business website
- **Business categories** from the search results

```json
{
    "query": "Digital marketing agency in London, UK",
    "name": "Pearl Lemon",
    "address": "Kemp House, 152 - 160 City Rd, London EC1V 2NX, United Kingdom",
    "phone": "+442071833436",
    "website": "https://pearllemon.com/",
    "email": "team@pearllemon.com",
    "categories": "Internet marketing service;Advertising agency;Marketing agency"
}
````

### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | The search query that returned this business |
| `name` | string | Business name |
| `address` | string | Full street address |
| `phone` | string | Primary phone number |
| `website` | string | Business website URL |
| `email` | string | Primary contact email extracted from the business website |
| `categories` | string | Semicolon-separated list of business category labels |

***

### What you can do with this data

- **Cold email outreach**: build targeted prospect lists with real emails for any category of business in any city, ready to import into your email tool
- **B2B lead generation**: collect contact details for direct outreach campaigns across specific industries or locations without manual research
- **Agency client prospecting**: search by niche and city, then filter for businesses that might need your services
- **Sales prospecting**: get direct contact emails and phone numbers for local businesses in seconds rather than hours
- **CRM enrichment**: append verified emails and phone numbers to existing lead records
- **Market research**: run the same category search across multiple cities to compare availability and coverage
- **Directory building**: collect structured business data for an entire niche or region in a single run
- **International outreach**: works in any country — search in any language and collect business contacts worldwide

***

### Without this, here is what you are doing instead

You are spending three hours building a 100-contact list that should take five minutes. You are buying outdated lead lists that include contact forms instead of real email addresses. You are assigning junior staff to manually copy-paste contact details from hundreds of websites. And by the time the list is ready, some of those businesses have already moved or closed.

Every hour spent finding emails is an hour not spent sending them.

***

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `search_query` | array | required | One or more search queries. Each returns up to the max results limit. |
| `maxResultsPerQuery` | integer | `50` | Max leads to collect per query. Default is 50, maximum is 500. Optional. |
| `proxyConfiguration` | object | Datacenter (Anywhere) | Proxy type and location. Supports Datacenter, Residential, and custom proxies. Optional. |

#### Example input

```json
{
    "search_query": [
        "Digital marketing agency in London, UK",
        "SEO agency in New York, NY",
        "roofing contractor in Miami, FL",
        "dentist near downtown Chicago, IL",
        "real estate agents in Houston, TX",
        "lawyers in Washington, DC",
        "wedding photographers in Atlanta, GA",
        "restaurants in Tokyo, Japan"
    ],
    "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### FAQ

**What email addresses does this actor collect?**
The actor visits each business website and extracts the primary contact email listed there. It prioritizes business domain emails (e.g. team@agency.com) but also captures personal emails (e.g. owner@gmail.com) when they are publicly listed. If no email is found, the field returns blank.

**What happens if a business has no website or no email?**
All other fields (name, address, phone, categories) are still returned. The `email` field will be blank. No record is skipped because of a missing email.

**How many results does each query return?**
Up to 50 by default. You can increase this up to 500 per query using the `maxResultsPerQuery` field. If the search has fewer results available, you get whatever is there.

**Can I search by ZIP code?**
Yes. Queries like "plumbers near 90210" or "dentists in 10001 New York" work the same as city-name queries.

**Does it work outside the US?**
Yes. Use any location in your search query: "marketing agencies in Berlin, Germany," "accountants in Sydney, Australia," or "restaurants in Tokyo, Japan" all work.

**Do results appear while the run is still going?**
Yes. Each record is pushed to your dataset the moment its contact extraction finishes, so data appears one business at a time as the actor works.

**Can I run many queries at once?**
Yes. Add as many queries as you need. Multiple queries run in parallel automatically.

***

### Integrations

Connect Business Lead Scraper with other tools via [Apify integrations](https://apify.com/integrations). Works with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and more. [Webhooks](https://docs.apify.com/integrations/webhooks) let you trigger downstream actions the moment your leads are ready.

***

[![Try Business Lead Scraper](https://i.imgur.com/8dh7ao7.png)](https://apify.com/kawsarlog/lead-scraper)

# Actor input Schema

## `search_query` (type: `array`):

One or more keywords or niches to search. Each query returns up to 200 business leads with name, address, phone, website, email, and categories. Use phrases like 'digital marketing agency in London, UK' or 'plumber, NYC, New York' for best results.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of business leads to collect per search query. The default is 50. You can increase this up to 500 per query. The actor paginates automatically to reach this number. If a query has fewer results available, you get whatever is there.

## `proxyConfiguration` (type: `object`):

Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect.

## Actor input object example

```json
{
  "search_query": [
    "Digital marketing agency in London, UK",
    "SEO agency in New York, NY",
    "roofing contractor in Miami, FL",
    "dentist near downtown Chicago, IL",
    "plumbers near 90210",
    "real estate agents in Houston, TX",
    "lawyers in Washington, DC",
    "wedding photographers in Atlanta, GA",
    "restaurants in Tokyo, Japan",
    "gyms near 94102 San Francisco CA"
  ],
  "maxResultsPerQuery": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "search_query": [
        "Digital marketing agency in London, UK"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("coder_luffy/lead-scraper-email").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 = {
    "search_query": ["Digital marketing agency in London, UK"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("coder_luffy/lead-scraper-email").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 '{
  "search_query": [
    "Digital marketing agency in London, UK"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call coder_luffy/lead-scraper-email --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "lead scraper (email)",
        "description": "Lead Scraper (Email) generates targeted business leads from any keyword. Get emails, phone numbers, websites, addresses, and more—perfect for B2B marketing, outreach, and lead generation. Fast, accurate, and easy to use.",
        "version": "0.0",
        "x-build-id": "XrBm4uwow2vYb2eye"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coder_luffy~lead-scraper-email/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coder_luffy-lead-scraper-email",
                "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/coder_luffy~lead-scraper-email/runs": {
            "post": {
                "operationId": "runs-sync-coder_luffy-lead-scraper-email",
                "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/coder_luffy~lead-scraper-email/run-sync": {
            "post": {
                "operationId": "run-sync-coder_luffy-lead-scraper-email",
                "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": [
                    "search_query"
                ],
                "properties": {
                    "search_query": {
                        "title": "Search Query (Keywords or Niche)",
                        "type": "array",
                        "description": "One or more keywords or niches to search. Each query returns up to 200 business leads with name, address, phone, website, email, and categories. Use phrases like 'digital marketing agency in London, UK' or 'plumber, NYC, New York' for best results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Number of Results to Collect Per Search (Default: 50, Up to 500)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of business leads to collect per search query. The default is 50. You can increase this up to 500 per query. The actor paginates automatically to reach this number. If a query has fewer results available, you get whatever is there.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
