# Docker Email Scraper (`email_scraper/docker-email-scraper`) Actor

Docker Email Scraper extracts publicly listed email addresses from Docker.com search results using keywords, locations, custom email domains, and exclusion filters. Get structured contact data with email, title, description, URL, and keyword fields for lead generation and research.

- **URL**: https://apify.com/email\_scraper/docker-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **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

### 🔍 Docker Email Scraper – Overview

**Docker Email Scraper** helps you discover publicly listed email addresses associated with Docker.com search results using targeted keywords, optional locations, and selected email domain suffixes.

Instead of manually searching Docker-related pages and checking descriptions for contact information, this Actor automates the search process and returns structured lead data containing the keyword, result title, description, URL, and extracted email address.

> 💡 **What problem does Docker Email Scraper solve?**
>
> - Finds publicly indexed Docker-related contact emails from search results.
> - Lets you target specific keywords such as `Developer` or `Software Company`.
> - Supports optional country, state, or city targeting.
> - Filters results by email domain, such as `@gmail.com` or `@outlook.com`.
> - Returns structured records directly to an Apify dataset.
> - Removes duplicate email addresses during the run.

Docker Email Scraper is useful for lead discovery, prospect research, developer outreach, B2B research, business intelligence, and building targeted contact datasets from publicly available search-result information.

For better coverage, use several specific keywords rather than relying on one broad query.

***

### 🔹 Docker Email Scraper – Key Features

Docker Email Scraper is designed around flexible search combinations. You can combine multiple keywords with multiple email domain suffixes and optionally narrow those searches by geographic location.

> ✅ **Key Features**
>
> - 🔎 Keyword-based Docker email discovery
> - 🌍 Optional country, state, or city filtering
> - ✉️ Custom email-domain filtering
> - 🚫 Description-based exclusion words and phrases
> - ♻️ Duplicate email prevention
> - 📊 Structured Apify Dataset output
> - 🔄 Incremental result saving during execution
> - ▶️ Resume support after an interrupted run
> - 🎯 Configurable result target from 1 to 10,000
> - 🧩 Multiple keyword × domain combinations

The Actor extracts email addresses that are publicly present in search-result descriptions and match the email domains you specify.

This makes Docker Email Scraper particularly useful when you already know the audience, role, business type, or niche you want to research.

***

### 🔍 Docker Email Scraper – What Data Can You Extract?

Docker Email Scraper returns structured information for each newly discovered email address.

The default dataset view contains these main fields:

| Field         | Description                                                     |
| ------------- | --------------------------------------------------------------- |
| `keyword`     | The keyword used for the search                                 |
| `title`       | Title of the corresponding search result                        |
| `description` | Search-result description containing the discovered information |
| `url`         | URL associated with the search result                           |
| `email`       | Email address extracted from the result description             |

The scraper also attaches a `network` value to pushed records identifying the source as Docker.com.

> 📦 **Output / Data Fields**
>
> - `network` — Source network identifier, set to Docker.com.
> - `keyword` — Search keyword responsible for the result.
> - `title` — Search-result title.
> - `description` — Search-result description text.
> - `url` — Result URL.
> - `email` — Matching email address extracted from the description.

The email field is generated only when an address matching at least one selected email-domain suffix is found.

This means the output is not simply a list of emails. Each email remains connected to contextual search information that can help with lead qualification and later research.

***

### 🔎 Docker Email Scraper – How to Use It

Using Docker Email Scraper requires only a few input settings.

Start by entering several relevant keywords. Then choose optional location targeting and email domains. Finally, select the maximum number of emails you want the Actor to target for each keyword and domain combination.

#### 🧭 Step 1: Add Keywords

Use specific, descriptive queries instead of only broad terms.

For example:

- `Developer`
- `DevOps Engineer`
- `Software Company`
- `Cloud Developer`
- `Container Developer`
- `Software Consultant`

More focused search terms can help you discover different groups of publicly indexed Docker results.

#### 🌍 Step 2: Add a Location

The `location` field is optional.

You can enter a country, state, or city when you want to narrow the search.

Examples:

- `United States`
- `New York`
- `California`
- `United Kingdom`
- `Toronto`

Leave the field empty when you want a broader search without geographic filtering.

#### ✉️ Step 3: Select Email Domains

The `customDomains` field controls which email-domain suffixes the scraper looks for.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- `@icloud.com`

You can also provide other domain suffixes when they are relevant to your research.

#### 🎯 Step 4: Set Max Emails

The `maxEmails` setting accepts a value from **1 to 10,000**.

The target is applied while processing each keyword and selected domain combination.

For example, with three keywords and two domains, the Actor works through the resulting combinations rather than treating your entire input as one search query.

Actual results can be lower than the requested number because the Actor only collects publicly available matching email addresses and can stop when useful results become exhausted.

***

### 🧩 Docker Email Scraper Input

The Actor accepts five user-facing input fields.

| Input           | Type    | Required | Default                         |
| --------------- | ------- | -------: | ------------------------------- |
| `keywords`      | Array   |      Yes | `Developer`, `Software Company` |
| `location`      | String  |       No | Empty                           |
| `customDomains` | Array   |       No | `@gmail.com`                    |
| `maxEmails`     | Integer |       No | `10`                            |
| `excludeWords`  | Array   |       No | Empty                           |

#### 🔑 Keywords or Queries

`keywords` is the required input and contains the terms used to search Docker-related results.

Example:

```json
{
  "keywords": [
    "Developer",
    "DevOps Engineer",
    "Software Company"
  ]
}
```

Specific keywords usually provide more focused research than a single generic term.

#### 📍 Region / Location

`location` optionally narrows searches geographically.

Example:

```json
{
  "location": "United States"
}
```

The field can be left blank for a broader search.

#### 📧 E-mail Domain Suffixes

`customDomains` defines the email suffixes the Actor should look for.

Example:

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

Using several relevant domains can increase coverage when publicly listed addresses use different providers.

#### 🔢 Maximum Emails

`maxEmails` controls the requested collection target for processing.

Example:

```json
{
  "maxEmails": 25
}
```

The accepted range is **1–10,000**.

#### 🚫 Exclude Words

`excludeWords` lets you skip search-result descriptions containing unwanted words or phrases.

Example:

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

Single words are matched without regard to capitalization and use whole-word matching. Phrases are matched without regard to capitalization as a phrase within the description.

***

### 🔍 How to Scrape Docker Email Addresses More Effectively

The easiest way to improve Docker email discovery is to combine several relevant keyword variations with multiple suitable email domains.

For example, instead of searching only:

```text
Developer
```

you could use:

```text
Developer
DevOps Engineer
Cloud Engineer
Software Company
Container Developer
Docker Consultant
Software Consultant
```

You can then pair these keywords with domains such as:

```text
@gmail.com
@outlook.com
@yahoo.com
```

> 💡 **Search Strategy Tip**
>
> - Start with broad but relevant professional keywords.
> - Add role-specific variations.
> - Add business-oriented terms when researching companies.
> - Use several email domains when wider coverage is needed.
> - Remove the location filter when geographic targeting is too restrictive.
> - Use `excludeWords` to reduce unwanted categories.

A very narrow combination can naturally produce fewer results because the Actor depends on publicly indexed search information containing a matching email address.

***

### 🧪 Docker Email Scraper – Input Example

A practical example for software and developer research could look like this:

```json
{
  "keywords": [
    "Developer",
    "DevOps Engineer",
    "Software Company"
  ],
  "location": "United States",
  "customDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

This configuration searches multiple Docker-related keyword categories, applies a United States location filter, looks for two email suffixes, targets up to 20 results while processing each combination, and skips descriptions containing the specified exclusions.

***

### 📊 Docker Email Scraper – Output Example

A resulting dataset record can look like this:

```json
{
  "network": "Docker.com",
  "keyword": "Software Company",
  "title": "Example Software Company",
  "description": "Software development information and contact: example@gmail.com",
  "url": "https://example.com/example-page",
  "email": "example@gmail.com"
}
```

> 📌 **Important Output Note**
>
> - The title, description, and URL come from the corresponding search result.
> - The email is extracted from the result description.
> - Duplicate email addresses are not added repeatedly during collection.
> - The default Apify dataset view focuses on `keyword`, `title`, `description`, `url`, and `email`.

***

### 🚀 Docker Email Scraper – Use Cases

Docker Email Scraper can support several research and lead-generation workflows where publicly listed contact information is relevant.

> 🎯 **Use Cases**
>
> - 👨‍💻 Developer and engineering lead research
> - 🏢 Software-company prospect discovery
> - ☁️ Cloud and DevOps business research
> - 📩 B2B contact list development
> - 🔍 Prospect qualification
> - 📚 Market and competitor research
> - 🌎 Location-specific business research
> - 🧠 Contact-data enrichment workflows

For example, a SaaS researcher could search for `Software Company`, while a technical recruiting workflow could focus on `Developer`, `DevOps Engineer`, or related professional terms.

Because each output record retains contextual information, the results can also be reviewed before being used in downstream research or outreach workflows.

***

### ⚙️ Can Docker Email Scraper Resume an Interrupted Run?

Yes. Docker Email Scraper saves progress while processing results rather than waiting until the entire run finishes.

This means collected records are pushed incrementally to the dataset during execution.

> 🔄 **Reliability Features**
>
> - Results are saved incrementally.
> - Previously discovered emails are tracked to prevent duplicate collection.
> - Processing progress is retained so an interrupted execution can resume from its stored position.
> - Long searches can continue through multiple keyword and domain combinations.

This is particularly useful for larger research jobs where many combinations are being processed.

***

### 💰 Docker Email Scraper – Pricing and Limits

The Actor configuration contains a free-user result limitation of **100 emails**.

Paid users are not subject to that specific 100-email free-tier restriction.

The `maxEmails` input itself accepts values from **1 to 10,000**, but the number of usable results depends on the user's plan and the amount of matching public information available.

> 💰 **Pricing / Limit Information**
>
> - Free users: maximum of 100 collected emails under the Actor's free-tier limitation.
> - Paid users: the Actor does not apply that 100-email free-tier ceiling.
> - `maxEmails`: configurable from 1 to 10,000.
> - No fixed monetary price is specified in this README because the provided Actor configuration does not verify a specific public price.

A requested target is not a guarantee. Searches may finish with fewer results when matching public email information is limited.

***

### 💡 Docker Email Scraper – Tips and Best Practices

For broader coverage, use several highly relevant keyword variations instead of repeating a single generic term.

> ✅ **Tips / Important Notes**
>
> - Use 3–5 closely related keywords for an initial search.
> - Add additional email domains when Gmail-only results are insufficient.
> - Use location targeting only when geographic relevance matters.
> - Remove or broaden the location when results are too sparse.
> - Use exclusion words to avoid unwanted categories.
> - Increase the run timeout for particularly broad searches.
> - Keep in mind that only publicly indexed matching information can be extracted.
> - Larger keyword and domain combinations can require more processing time.

The best configuration depends on the type of Docker-related contacts you are researching.

***

### ❓ Frequently Asked Questions

#### 🔹 What is Docker Email Scraper?

Docker Email Scraper is an Apify Actor that searches publicly indexed Docker-related results for email addresses matching your selected keywords and email-domain suffixes.

#### 🔹 How do I use Docker Email Scraper?

Enter one or more keywords, optionally add a location, choose email domains, set `maxEmails`, and run the Actor. The discovered records are stored in the Apify dataset.

#### 🔹 Can Docker Email Scraper search by country or city?

Yes. The optional `location` input accepts a country, state, or city and uses that value to narrow the search.

#### 🔹 What email domains can Docker Email Scraper find?

You can provide custom email suffixes through `customDomains`, including examples such as `@gmail.com`, `@yahoo.com`, and `@outlook.com`.

#### 🔹 Can I exclude certain words from Docker email results?

Yes. The `excludeWords` input skips result descriptions containing your specified words or phrases.

#### 🔹 What data does Docker Email Scraper return?

The dataset contains `keyword`, `title`, `description`, `url`, and `email`. Records pushed by the Actor also include a Docker.com network identifier.

#### 🔹 Does Docker Email Scraper remove duplicate emails?

Yes. The Actor tracks discovered email addresses and avoids adding the same email repeatedly during collection.

#### 🔹 Can I request more than 100 emails?

Yes for paid users, subject to the availability of matching public data. The Actor's free-tier limit is 100 emails, while `maxEmails` supports up to 10,000.

#### 🔹 Why did Docker Email Scraper return fewer emails than requested?

A requested number is a target rather than a guarantee. Fewer emails may be returned when search results contain limited matching addresses, when filters are restrictive, or when useful search results become exhausted.

#### 🔹 What keywords should I use for Docker email discovery?

Use specific professional or business terms relevant to your target audience, such as `Developer`, `DevOps Engineer`, `Software Company`, `Cloud Engineer`, or `Docker Consultant`.

#### 🔹 Can Docker Email Scraper collect private or hidden email addresses?

No. The Actor is designed to extract matching email addresses available in publicly indexed search-result information. It does not provide access to private credentials or hidden contact data.

***

### 🛠️ Support

Docker Email Scraper is intended to provide a straightforward workflow for discovering structured, publicly available Docker-related contact information using keyword and domain-based searches.

For custom requirements, improvements, or a bespoke scraper request, contact me by email:

- 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": [
    "Developer",
    "Software Company"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "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": [
        "Developer",
        "Software Company"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/docker-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": [
    "Developer",
    "Software Company"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/docker-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/docker-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/PNUVKbW2jVXeEKQO5/builds/Ut3GXss376I1Ai0up/openapi.json