# Target Email Scraper (`solid-scraper/target-email-scraper`) Actor

📧 Target Email Scraper finds verified business emails using filters like keywords, industry & location. 🚀 Ideal for outreach, sales, and marketing teams to build quality leads faster—save time and boost conversion.

- **URL**: https://apify.com/solid-scraper/target-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Target Email Scraper 📬

**Target Email Scraper** is an email address scraper designed to help you extract lead email addresses from publicly available sources using your **keywords**, an optional **location** filter, and **custom email-domain** rules. Whether you're using a **targeted email scraper tool** for prospecting, a **business email scraper** for B2B lead generation, or an **email mining tool** for research, this actor streamlines the process of finding contacts at scale—saving you hours of manual work.

---

### Why choose Target Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Keyword-driven searching** | Lets you target specific themes (and combinations) instead of scraping broad results |
| ✅ **Custom Email Domains filter** | Extracts emails only for the domains you specify (e.g., `@gmail.com`) |
| ✅ **Optional Location filter** | Helps narrow results by a single location value when you need regional targeting |
| ✅ **Proxy support** | Improves reliability when scraping at scale with built-in proxy configuration |
| ✅ **Fallback logic for reliability** | Uses a fallback path when no emails are found under the current proxy setup |
| ✅ **Structured JSON output** | Produces consistent records with `keyword`, `title`, `description`, `url`, and `email` for easy export |

---

### Key features

- 🔎 **Targeted email scraping**: Extracts email addresses that match your provided `customDomains` rules.
- 🧠 **Keyword + domain combination logic**: Searches using each keyword together with each custom domain to focus results.
- 📍 **Location-aware filtering**: Optionally adds the `location` value to help refine what gets scraped.
- 🛡️ **ProxyConfiguration support**: Works with the `proxyConfiguration` input you provide for more dependable runs.
- 🔄 **Reliability fallback**: If a run under the current setup doesn’t yield emails, the actor attempts a fallback approach.
- 📊 **Clean, export-ready records**: Each result includes the email plus the surrounding context (`title`, `description`, and `url`).
- 💾 **De-duplicated emails**: Prevents repeated emails within the same run using an internal `seen_emails` set.
- 💫 **Bulk-friendly**: Designed to iterate across all your keywords and custom domains in one execution.

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["john", "marketing"],
  "location": "",
  "platform": "Target",
  "customDomains": ["@gmail.com"],
  "proxyConfiguration": {}
}
````

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `keywords` | ✅ Yes | A list of keywords to search for. This is the main driver for finding relevant leads and emails. |
| `location` | ❌ No | A single location string used to filter results. Leave it empty (`""`) when you don’t need location targeting. |
| `platform` | ❌ No | Select platform. The only available option in this actor is `Target`. |
| `customDomains` | ❌ No | A list of custom email domains to extract (for example `@gmail.com`). The scraper will only keep emails matching these domains. |
| `proxyConfiguration` | ❌ No | Configure proxies for this Actor. Use this when you want proxy control for reliability and scale. |

> Notes:
> `keywords` is the only required field. The actor also supports passing `keywords` as a string (it will be converted into a list internally), but the schema is defined as an array.

***

### Output

The actor saves your collected results as JSON by pushing an array of records.

Example output:

```json
[
  {
    "keyword": "john",
    "title": "Example result title",
    "description": "Extracted context text from the result description",
    "url": "https://example.com/some-page",
    "email": "johndoe@gmail.com"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | The keyword that produced this result record |
| `title` | string | The result title text (as found in the scraped content) |
| `description` | string | The extracted description text used for email matching |
| `url` | string | The URL associated with the scraped result |
| `email` | string | The extracted email address matching your `customDomains` rules |

Closing note: The output is delivered as dataset records in JSON, which you can export to formats supported by Apify (for example, JSON/CSV via the dataset UI).

***

### How to use Target Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the **Actors** tab.

2. **Find the actor**\
   Search for **Target Email Scraper** and open its actor page.

3. **Go to the INPUT section**\
   Paste your `input.json` or use the built-in form fields.

4. **Set your keywords**\
   Add one or more terms you want to use for targeted lead email scraper results (this is required).

5. **(Optional) Add a location**\
   If you want region-specific targeting, fill the `location` field; otherwise keep it empty.

6. **(Optional) Set custom email domains**\
   Enter domains like `@gmail.com` in `customDomains` to control which email addresses get extracted.

7. **(Optional) Configure proxy settings**\
   Adjust `proxyConfiguration` if you need specific proxy behavior for more reliable scraping at scale.

8. **Run the actor and monitor logs**\
   During the run, you’ll see progress logs, including when emails are extracted (and fallback behavior when applicable).

9. **Open the output dataset**\
   After completion, open the dataset in the **OUTPUT** tab and export your results (JSON/CSV as supported by the dataset view).

No coding required—get targeted email scraping results in minutes with **Target Email Scraper**. ✅

***

### Advanced features & SEO optimization

- 🔍 **Engineered for targeted lead generation email scraper workflows**: Uses your provided `keywords` plus `customDomains` so you get fewer irrelevant emails and more usable leads.
- 🌐 **Email scraping software with structured context**: Every record includes `title`, `description`, and `url` alongside `email` for faster review and validation.
- 🛡️ **Resilience with proxy support**: Lets you configure proxies through `proxyConfiguration` to improve reliability in real-world runs.
- 🔄 **Fallback for when results are sparse**: If no emails are found under the current setup, the actor attempts a fallback approach to keep the run productive.
- 💾 **Batch-style extraction**: Iterates across all keywords and all custom domains so you can run bulk email scraper workflows in one shot.

***

### Best use cases

- 📈 **B2B lead generation**: Build targeted prospect lists by extracting business email contacts tied to specific themes (keywords) and email domains.
- 🧑‍💼 **Sales teams prospecting**: Quickly populate a CRM pipeline with lead email scraper outputs that include context (`title`, `description`, `url`).
- 🔬 **Market researchers**: Gather email addresses from publicly available sources to validate outreach hypotheses across regions (via `location`).
- ✉️ **Email marketing enrichment**: Expand cold-email datasets by finding emails from specific domains you trust or want to target.
- 🏢 **Website email extractor for competitive research**: Compare how different pages reference contact info and quickly locate matching email-domain addresses.
- 🧩 **Developer and analyst workflows**: Feed dataset JSON into downstream pipelines for filtering, deduplication, and scoring.

***

### Technical specifications

**Supported Input Formats**

- ✅ **`keywords`**: array of strings (the actor also converts a string into a list internally)
- ✅ **`location`**: string (single location value)
- ✅ **`platform`**: string with enum `Target`
- ✅ **`customDomains`**: array of strings (email domains)
- ✅ **`proxyConfiguration`**: object (proxy settings input)

**Proxy Support**

- ✅ Uses `proxyConfiguration` when provided
- ✅ Includes fallback logic when emails are not found under the current setup

**Retry Mechanism**

- ✅ Includes resilience via fallback logic (behavior is designed to improve chances of getting results)

**Dataset Structure**

- ✅ JSON array of records pushed via `Actor.push_data(results)`
- Records include: `keyword`, `title`, `description`, `url`, `email`

**Rate Limits & Performance**

- 🟡 Performance depends on external web responses and your proxy configuration (varies run to run)

**Limitations**

- ❌ Only extracts emails that match the provided `customDomains` patterns
- ❌ If no matching emails exist in the scraped publicly available content, the dataset may be empty for that keyword/domain combination

***

### FAQ

#### What does Target Email Scraper extract?

✅ Target Email Scraper extracts email addresses that match your `customDomains`, and it saves each result with supporting context fields: `keyword`, `title`, `description`, and `url`.

#### Do I need to provide keywords?

✅ Yes. `keywords` is the only required input field. The actor uses each keyword together with each custom domain to guide extraction.

#### Can I filter by location?

✅ Yes. You can provide `location` as a single string. If you leave it empty (`""`), no location filtering is applied.

#### How do custom email domains work?

✅ `customDomains` lets you define which email domains should be extracted (for example `@gmail.com`). Emails that don’t match those domains won’t be included in the results.

#### Is proxy support available?

✅ Yes. You can provide `proxyConfiguration` to configure proxies for the actor. The actor also includes fallback behavior when no emails are found under the current setup.

#### How can I export my results?

✅ After the run finishes, open the dataset in the **OUTPUT** tab and export it using the dataset UI options (JSON/CSV depending on what’s available there).

#### Does this actor include failure details?

❌ The output records shown by the actor include `keyword`, `title`, `description`, `url`, and `email`. There is no explicit `error_message` field in the pushed dataset structure.

***

### Support & feature requests

If you’re using **Target Email Scraper** and want improvements, feedback helps shape the roadmap.

- 💡 **Feature Requests**: Want enhancements like additional output fields, better domain filtering controls, or more export-friendly formatting? Share your idea and we’ll consider it.
- 📧 **Contact**: For support or suggestions, email us at <dataforleads@gmail.com>.

Thanks for helping make this targeted email scraper tool even more useful—your feedback directly influences future updates. 🙌

***

*Target Email Scraper is a purpose-built, SEO-optimized email address scraper for finding targeted lead emails at scale—so you can move from research to outreach faster.*

***

### Disclaimer

**This tool only accesses publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected content. It’s your responsibility to comply with applicable laws and regulations (including GDPR and CCPA where relevant), spam regulations, and each platform or website’s Terms of Service.

For data removal requests, contact <dataforleads@gmail.com>. Please use Target Email Scraper responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords to search for.

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

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "john",
    "marketing"
  ],
  "location": "",
  "platform": "Target",
  "customDomains": [
    "@gmail.com"
  ]
}
```

# 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 = {
    "keywords": [
        "john",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/target-email-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 = {
    "keywords": [
        "john",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/target-email-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 '{
  "keywords": [
    "john",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call solid-scraper/target-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Email Scraper",
        "description": "📧 Target Email Scraper finds verified business emails using filters like keywords, industry & location. 🚀 Ideal for outreach, sales, and marketing teams to build quality leads faster—save time and boost conversion.",
        "version": "0.0",
        "x-build-id": "LzK3k3PEueIFaLJN9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~target-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-target-email-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/solid-scraper~target-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-target-email-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/solid-scraper~target-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-target-email-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "john",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Target"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Target"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```