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

target Email Scraper extracts publicly available email addresses from Target search results using keywords, locations, and custom email domains. Collect structured leads with email, title, description, keyword, and URL for prospecting, research, and contact discovery.

- **URL**: https://apify.com/email\_scraper/target-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 – Overview

**target Email Scraper** is an Apify Actor designed to discover publicly listed email addresses associated with Target search results using targeted keywords, optional locations, and customizable email-domain filters.

Instead of relying on a single broad search term, the **target Email Scraper** lets you build a structured lead-discovery workflow around multiple keywords and email domains. This makes it useful when you need to identify Target-related contacts connected with roles, businesses, professionals, or other publicly indexed profiles.

The Actor returns structured contact data including the original keyword, result title, description, URL, and extracted email address. Results are pushed incrementally into the Apify dataset, making the collected data easy to review and work with inside your Apify workflow.

> 💡 **What does target Email Scraper do?**
>
> - Searches for Target-related results using your keywords
> - Supports optional country, state, city, or other location terms
> - Filters collected addresses by your selected email-domain suffixes
> - Extracts email addresses from publicly available search-result descriptions
> - Removes duplicate email addresses during a run
> - Stores results in a structured Apify dataset

The easiest way to start is to provide a few specific keywords, optionally add a location, choose your desired email domains, and set the maximum number of emails for each keyword-and-domain combination.

***

### 🚀 target Email Scraper – Key Features

The **target Email Scraper** combines keyword targeting, geographic filtering, domain targeting, duplicate control, exclusions, and structured output into one workflow.

#### 🔹 Targeted keyword searching

Use multiple search terms instead of depending on one generic keyword. For example, business-focused queries such as `founder`, `manager`, or more specific role combinations can help create different discovery paths.

More specific keywords generally produce more focused search coverage.

#### 🔹 Location-based targeting

The **target Email Scraper** supports an optional `location` input. You can enter a country, state, city, or other geographic phrase to narrow the search.

Leave the field empty when you want broader coverage without a location filter.

#### 🔹 Custom email-domain targeting

The `customDomains` input lets you decide which email-domain suffixes the scraper should look for.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- A relevant company or organization domain

This makes the **target Email Scraper** useful for both general contact discovery and more targeted business research.

#### 🔹 Per-combination result limits

The `maxEmails` setting is applied independently to each keyword + domain combination.

For example, with 3 keywords, 2 domains, and a limit of 20, the Actor processes 6 combinations and can target up to 20 addresses for each combination, subject to available public results and duplicate filtering.

#### 🔹 Exclude unwanted snippets

The `excludeWords` field lets you skip result descriptions containing unwanted words or phrases.

Single words are matched as complete words, while phrases are checked as phrase-level text. Matching is case-insensitive.

#### 🔹 Duplicate email control

The Actor tracks previously discovered email addresses so the same address is not repeatedly stored as a new result.

#### 🔹 Incremental dataset output

Each discovered result is pushed to the Apify dataset during processing rather than waiting until the entire run is finished.

> ✅ **Key Features**
>
> - Multiple keywords
> - Multiple email domains
> - Optional geographic targeting
> - Per keyword + domain result limits
> - Exclude-word filtering
> - Duplicate email prevention
> - Structured dataset output
> - Incremental result storage
> - Free-user result ceiling
> - Higher limits for paid users

***

### 📊 target Email Scraper – What Data Can You Extract?

The **target Email Scraper** produces structured records representing the search result associated with each discovered email address.

The available fields are:

| Field         | Description                                                            |
| ------------- | ---------------------------------------------------------------------- |
| `keyword`     | The keyword used for the discovery search                              |
| `title`       | Title associated with the search result                                |
| `description` | Search-result description containing the extracted contact information |
| `url`         | URL of the associated result                                           |
| `email`       | Email address identified in the result description                     |

The dataset view is organized as a table, making it convenient to inspect individual leads and associated source information.

> 📦 **Output / Data Fields**
>
> - `keyword` — discovery keyword
> - `title` — result title
> - `description` — result description
> - `url` — source URL
> - `email` — extracted email address

The output is designed for structured lead research, contact discovery, data enrichment, prospecting workflows, and other tasks where source context is useful alongside an email address.

The Actor's result records are written incrementally, so the dataset can contain already collected records even when a longer run stops before reaching its requested target.

***

### 🛠️ target Email Scraper – How to Use It

Using the **target Email Scraper** requires only a few input choices.

#### 1. Add targeted keywords

Provide one or more keywords in the `keywords` field.

Instead of relying only on a broad term, consider combining different roles, business types, or relevant search phrases.

Example:

```json
{
  "keywords": [
    "founder",
    "manager",
    "business owner"
  ]
}
```

#### 2. Add a location when needed

Use the `location` field when you need geographic targeting.

```json
{
  "location": "New York"
}
```

To search without a geographic filter, leave it empty.

#### 3. Select email domains

The default email domain is `@gmail.com`, but multiple domains can be supplied.

```json
{
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ]
}
```

#### 4. Set the result target

Use `maxEmails` to control the target number of addresses for each keyword + domain combination.

```json
{
  "maxEmails": 20
}
```

The supported value is from **1 to 10,000**.

#### 5. Add exclusion terms

Use `excludeWords` when certain words or phrases should cause a search-result description to be ignored.

```json
{
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

#### 6. Start the Actor

Once the inputs are configured, start the run in Apify. The Actor processes the configured keyword and domain combinations and writes discovered records to the dataset.

> ⚡ **Tip**
>
> - Start with several relevant keywords.
> - Add multiple appropriate email domains when broader coverage is needed.
> - Use a location only when geographic targeting is important.
> - Increase `maxEmails` when deeper discovery is required.
> - Use exclusions to remove unwanted categories from the results.

***

### 🔎 How to Scrape Target Emails Using Keywords and Domains

The **target Email Scraper** works best when the search strategy is specific enough to identify the type of contact you need while remaining broad enough to produce meaningful public results.

For example, instead of using only:

```text
founder
```

you can combine several related keywords:

```text
founder
manager
business owner
marketing manager
company founder
```

You can also combine those keywords with multiple email-domain suffixes.

For example:

```json
{
  "keywords": [
    "founder",
    "manager",
    "business owner"
  ],
  "customDomains": [
    "@gmail.com",
    "@outlook.com",
    "@yahoo.com"
  ],
  "maxEmails": 10
}
```

With 3 keywords and 3 email domains, the Actor works across **9 separate keyword + domain combinations**.

This combination-based approach is useful when a single keyword does not provide enough results. It also lets you control the type of search coverage rather than depending on one large, generic query.

***

### 🎯 Can target Email Scraper Find More Relevant Contacts?

Yes. Search relevance can often be improved by using more specific keywords, carefully selected domain suffixes, and an appropriate location.

For example, a professional prospecting workflow may combine job-related terms, business ownership terms, and geographic targeting.

The important point is that the Actor can only collect email addresses that are publicly discoverable in the available search-result content. It does not guarantee that every keyword will produce the requested number of addresses.

> ⚠️ **Important**
>
> - Results depend on publicly indexed information.
> - A higher `maxEmails` value does not guarantee more emails.
> - Narrow keywords may produce fewer results.
> - Very restrictive locations can reduce available coverage.
> - Duplicate email addresses are not repeatedly stored as new contacts.

***

### 💼 target Email Scraper – Use Cases

The **target Email Scraper** can support several research and lead-generation workflows.

#### 🔹 Lead discovery

Find publicly listed contact addresses associated with relevant Target search results and store them with source context.

#### 🔹 Business prospecting

Use keywords such as `founder`, `manager`, or industry-specific role terms to identify potentially relevant business contacts.

#### 🔹 Local market research

Use the `location` field to investigate publicly indexed contacts connected with a particular city, state, country, or region.

#### 🔹 Contact enrichment

Combine the extracted email address with its title, description, keyword, and source URL for a more useful research record.

#### 🔹 Market research

Run multiple search terms and domains to compare different segments, roles, or geographic areas.

#### 🔹 Automated data workflows

Because the Actor runs on Apify and produces structured dataset records, the results can become part of larger Apify-based data collection and processing workflows.

> 🎯 **Use Cases**
>
> - Lead generation
> - Business contact research
> - Prospect discovery
> - Local market analysis
> - Contact enrichment
> - Public web research
> - Keyword-based email discovery
> - Structured lead collection

***

### 🧾 Input – What Can You Configure?

| Input           | Type    | Required | Default              | Range / Notes                             |
| --------------- | ------- | -------: | -------------------- | ----------------------------------------- |
| `keywords`      | Array   |      Yes | `founder`, `manager` | One or more keywords or queries           |
| `location`      | String  |       No | Empty                | Country, state, city, or other region     |
| `customDomains` | Array   |       No | `@gmail.com`         | Email-domain suffixes                     |
| `maxEmails`     | Integer |       No | `5`                  | 1–10,000 per keyword + domain combination |
| `excludeWords`  | Array   |       No | Empty                | Words or phrases to exclude               |

#### 🔹 Example Input

```json
{
  "keywords": [
    "founder",
    "manager"
  ],
  "location": "United States",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 10,
  "excludeWords": [
    "crypto"
  ]
}
```

The only required input is `keywords`. All other fields are optional.

***

### 📤 Output – Example Result

A typical dataset record follows this structure:

```json
{
  "keyword": "founder",
  "title": "Example Result Title",
  "description": "Example public result description containing contact information.",
  "url": "https://example.com/example",
  "email": "example@gmail.com"
}
```

The dataset stores the contact email together with the discovery keyword and source information, helping you understand where each result came from.

The output schema is intentionally focused on the fields generated by the Actor: keyword, title, description, URL, and email.

***

### 💰 Pricing and Usage Limits

The **target Email Scraper** applies a different result ceiling depending on the user plan.

For free users, the Actor enforces a maximum of **100 emails per run**. Even if a higher `maxEmails` value is entered, the free-user limit is applied automatically.

Paid users do not have this 100-email restriction from the Actor's plan logic, although the configured `maxEmails` value still controls the requested target for each keyword + domain combination.

The Actor also records each pushed result as a charged `result` event. The exact monetary price should be checked on the current Apify Store pricing page because the configured event name does not itself specify a currency amount.

> 💳 **Pricing**
>
> - Free users: maximum 100 emails per run
> - Paid users: no Actor-level 100-email free-tier restriction
> - `maxEmails`: 1–10,000 per keyword + domain combination
> - Result events are recorded as `result`
> - Actual current price: see the Apify Store pricing displayed for this Actor

***

### 🧠 Tips and Best Practices

The **target Email Scraper** can produce better coverage when inputs are planned around the type of contacts you actually need.

#### 🔹 Use several related keywords

Different keyword variations can expose different result sets. Mix broad and specific phrases instead of depending on only one term.

#### 🔹 Select relevant domains

If your objective includes business addresses, adding suitable organizational domains can expand the types of emails searched for.

#### 🔹 Use location strategically

A geographic filter is helpful for local prospecting, but it can also reduce the size of the available result set.

#### 🔹 Avoid unnecessarily high limits

Set `maxEmails` according to the amount of data you actually need. Higher targets may require broader search coverage and longer runs.

#### 🔹 Use exclusions carefully

An exclusion term removes an entire result description when that term is detected. Use exclusions only for categories you genuinely want to skip.

#### 🔹 Broaden when results are low

If the Actor does not reach the requested target, consider adding related keywords, expanding domains, or removing an overly narrow location.

> 📌 **Important Notes**
>
> - The maximum does not guarantee that every requested email will be found.
> - Results are limited by publicly available searchable information.
> - Free accounts are limited to 100 emails by the Actor's plan logic.
> - The Actor stores unique email addresses rather than repeatedly adding duplicates.
> - Longer or broader runs may require more execution time.

***

### ❓ Frequently Asked Questions

#### 🔍 What is target Email Scraper?

The **target Email Scraper** is an Apify Actor for discovering publicly listed email addresses associated with Target search results using keywords, optional locations, and email-domain filters.

#### 🔍 How does target Email Scraper find email addresses?

It searches for relevant Target results using the supplied keyword and domain combinations, then extracts matching email addresses from the available result descriptions.

#### 🔍 Can I use multiple keywords with target Email Scraper?

Yes. The `keywords` input accepts an array, allowing multiple search terms in the same run.

#### 🔍 Can I target a specific city or country?

Yes. Enter a country, state, city, or other geographic phrase in `location` to narrow the discovery scope.

#### 🔍 Can I search multiple email domains?

Yes. Add multiple domain suffixes to `customDomains`, such as `@gmail.com`, `@yahoo.com`, or `@outlook.com`.

#### 🔍 What is the maximum email limit?

The `maxEmails` input supports values from **1 to 10,000** for each keyword + domain combination.

#### 🔍 Is maxEmails a run-wide total?

No. The configured target is applied independently to each keyword + domain combination.

For example, 2 keywords × 3 domains with `maxEmails: 10` creates six combinations, each targeting up to 10 addresses.

#### 🔍 What is the free-user limit?

Free users are limited to **100 collected email addresses per run** by the Actor's plan logic.

#### 🔍 Can paid users collect more than 100 emails?

Yes. Paid users are not subject to the Actor's 100-email free-tier ceiling.

#### 🔍 Can I exclude unwanted categories?

Yes. Add words or phrases to `excludeWords`. Matching is case-insensitive, and a matching description is skipped.

#### 🔍 Does the Actor guarantee the requested number of emails?

No. The requested limit is a target, not a guarantee. Results depend on publicly indexed information, search coverage, keyword quality, domain selection, and other result availability factors.

#### 🔍 Does target Email Scraper remove duplicates?

Yes. The Actor tracks discovered email addresses and avoids storing the same address repeatedly as a new unique result.

#### 🔍 What data does target Email Scraper return?

Each output record contains `keyword`, `title`, `description`, `url`, and `email`.

#### 🔍 Where are the results stored?

Results are pushed incrementally into the Actor's Apify dataset and displayed using a structured table view.

#### 🔍 What happens if a run stops early?

The Actor maintains progress information and can resume from its stored run state rather than treating every previously discovered address as new.

#### 🔍 How can I improve Target email results?

Use several specific and related keywords, add suitable email-domain suffixes, widen an overly restrictive location, and increase the requested limit when appropriate.

***

### 📚 Support

The **target Email Scraper** is designed to keep the configuration simple while providing structured output suitable for lead research, prospect discovery, and contact-data workflows.

For custom changes, feature requests, or a bespoke scraper, contact:

- contact me by email : <alphascraper69@gmail.com>

# Actor input Schema

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

A list of keywords or queries to search for.

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

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

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

List of custom email domains

## `maxEmails` (type: `integer`):

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "manager"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 5,
  "excludeWords": []
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "founder",
        "manager"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_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": [
        "founder",
        "manager",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/target-email-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "founder",
    "manager"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/target-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/target-email-scraper"
        }
    }
}

```

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

## OpenAPI specification

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