# Domain Email Finder (`mighty_monk/domain-email-finder`) Actor

Find email addresses for company domains by crawling homepage, contact, about, and team pages (mailto, regex, JSON-LD) and generating common email patterns from full names. Lead-gen ready with confidence scores.

- **URL**: https://apify.com/mighty\_monk/domain-email-finder.md
- **Developed by:** [Harsh](https://apify.com/mighty_monk) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 email or domain results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

### What does Domain Email Finder do?

**Domain Email Finder** discovers **email addresses for company domains** — ideal for cold outreach, lead lists, and enrichment pipelines. Give it domains like `acme.com`, optionally add full names, and it:

1. **Crawls** the homepage plus `/contact`, `/about`, `/team` (and linked contact pages) with a fast Cheerio crawler
2. **Extracts** emails from `mailto:` links, page text, and JSON-LD structured data
3. **Generates** common email patterns from names (`first@`, `first.last@`, `flast@`, `firstl@`, …)
4. **Deduplicates** results with confidence scores (`high` / `medium` / `low`)

Runs on the [Apify platform](https://apify.com) with **API access**, **scheduling**, **integrations**, proxy rotation, and monitoring.

### Why use Domain Email Finder?

- **Cold email stacks** need domain → emails without paying Apollo for every lookup
- **Lead generation** at scale: feed domains from SERP, directories, or CRM exports
- **Pattern + website hybrid**: catch public inbox addresses *and* guess role-based / name-based patterns
- **Honest confidence**: patterns are **not SMTP-verified** — marked medium/low so you can filter or verify elsewhere (e.g. MillionVerifier)
- **Pay-per-result** pricing (~$0.003 per dataset item) keeps cost predictable

### How to use Domain Email Finder

1. Open the Actor in [Apify Console](https://console.apify.com)
2. Enter one or more **domains** (e.g. `acme.com`)
3. Optionally add **full names** for pattern generation
4. Leave **Crawl website** and **Generate patterns** enabled (defaults)
5. Click **Start** and download the dataset as JSON, CSV, Excel, or HTML

#### Example input

```json
{
    "domains": ["apify.com", "stripe.com"],
    "fullNames": ["Jane Doe"],
    "maxPagesPerDomain": 8,
    "generatePatterns": true,
    "crawlWebsite": true,
    "maxConcurrency": 5,
    "requestDelayMs": 200
}
```

### Input

| Field | Type | Required | Default | Description |
| ----- | ---- | -------- | ------- | ----------- |
| `domains` | `string[]` | Yes | — | Domains to process (`acme.com` or full URLs) |
| `fullNames` | `string[]` | No | `[]` | Names for pattern generation |
| `maxPagesPerDomain` | `integer` | No | `8` | Cap on pages crawled per domain |
| `generatePatterns` | `boolean` | No | `true` | Build pattern emails from names |
| `crawlWebsite` | `boolean` | No | `true` | Crawl site for public emails |
| `maxConcurrency` | `integer` | No | `5` | Parallel HTTP requests |
| `maxRequestRetries` | `integer` | No | `3` | Retries for failed pages |
| `requestDelayMs` | `integer` | No | `200` | Rate-limit hint |
| `proxyConfiguration` | `object` | No | Proxy off | Apify Proxy settings |

See the **Input** tab for the full form schema.

### Output

Each dataset item is either an **email** row or a **domain\_summary** row (null-safe fields on both).

#### Email result

```json
{
    "type": "email",
    "domain": "acme.com",
    "email": "info@acme.com",
    "source": "mailto",
    "confidence": "high",
    "fullName": null,
    "pattern": null,
    "pageUrl": "https://acme.com/contact",
    "emailsFound": null,
    "pagesScraped": null,
    "error": null,
    "scrapedAt": "2026-07-18T12:00:00.000Z"
}
```

#### Domain summary

```json
{
    "type": "domain_summary",
    "domain": "acme.com",
    "email": null,
    "source": null,
    "confidence": null,
    "fullName": null,
    "pattern": null,
    "pageUrl": null,
    "emailsFound": 5,
    "pagesScraped": 4,
    "error": null,
    "scrapedAt": "2026-07-18T12:00:00.000Z"
}
```

You can download the dataset in **JSON, HTML, CSV, or Excel**.

### Data table

| Field | Description |
| ----- | ----------- |
| `type` | `email` or `domain_summary` |
| `domain` | Normalized host without `www` |
| `email` | Found or generated address |
| `source` | `mailto`, `json-ld`, `website`, or `pattern` |
| `confidence` | `high` (mailto/json-ld), `medium` (text or strong patterns), `low` (weaker patterns) |
| `fullName` | Name used for the pattern, if any |
| `pattern` | Template id (e.g. `first.last`, `flast`) |
| `pageUrl` | Page where the email was scraped |
| `emailsFound` | Unique emails for the domain (summary only) |
| `pagesScraped` | Pages successfully scraped (summary only) |
| `scrapedAt` | ISO timestamp |

### Patterns generated (when names are provided)

| Pattern | Example (`Jane Doe` @ `acme.com`) | Default confidence |
| ------- | --------------------------------- | ------------------ |
| `first` | jane@acme.com | medium |
| `first.last` | jane.doe@acme.com | medium |
| `flast` | jdoe@acme.com | medium |
| `firstl` | janed@acme.com | medium |
| `f.last` | j.doe@acme.com | medium |
| `last` | doe@acme.com | low |
| `first_last` | jane\_doe@acme.com | low |
| `first-last` | jane-doe@acme.com | low |
| `first.l` | jane.d@acme.com | low |
| `last.first` | doe.jane@acme.com | low |
| `lastf` | doej@acme.com | low |
| `f_last` | j\_doe@acme.com | low |

**These are not SMTP-verified.** Use a verifier if you need deliverability guarantees.

### Pricing / Cost estimation

**How much does it cost to find emails for a domain?**

Pay-per-event pricing: **$0.003 per dataset item** (`apify-default-dataset-item`), plus a tiny actor-start fee.

- Each **email** row is one chargeable result
- Each **domain\_summary** row is also one result
- Example: 1 domain, 10 unique emails → ~11 items ≈ **$0.033**

Apify free tier compute units apply for development; production usage depends on crawl depth and proxy.

### Tips

- Set `crawlWebsite: false` if you only want **pattern** emails from names (fast, no HTTP)
- Raise `maxPagesPerDomain` for sites that bury emails deep in `/careers` or multi-language paths
- Prefer **high** confidence (`mailto` / `json-ld`) for outreach; treat **pattern** rows as candidates
- Use Apify Proxy for domains that block datacenter IPs
- Combine with a SERP or directory Actor for bulk domain lists

### FAQ, disclaimers, and support

**Is scraping emails legal?**\
Scraping publicly available contact info is common for B2B lead gen, but you must comply with applicable laws (CAN-SPAM, GDPR, CASL, etc.), the target site’s Terms of Service, and anti-spam rules. This Actor does not send email.

**Are pattern emails verified?**\
No. Patterns are heuristic only. Confidence never exceeds `medium` for patterns.

**Why were some emails dropped?**\
Noise filters remove placeholders (`example.com`, Sentry, Wixpress, noreply, image-like addresses, etc.).

**Need a custom solution?**\
Open an issue on the Actor’s **Issues** tab or contact the developer for custom enrichment pipelines.

***

Built with TypeScript, Apify SDK, and Crawlee CheerioCrawler.

# Actor input Schema

## `domains` (type: `array`):

Company domains to find emails for (e.g. acme.com). Protocols and paths are stripped automatically.

## `fullNames` (type: `array`):

Optional people names used for email pattern generation (e.g. "Jane Doe"). Applied to every domain when generatePatterns is enabled.

## `maxPagesPerDomain` (type: `integer`):

Maximum pages to crawl per domain (homepage + contact/about/team paths and discovered links).

## `generatePatterns` (type: `boolean`):

When enabled and fullNames are provided, generate common email patterns (first@, first.last@, flast@, etc.). Patterns are marked low/medium confidence — not SMTP-verified.

## `crawlWebsite` (type: `boolean`):

Crawl homepage, /contact, /about, /team and discovered contact links to extract emails from mailto, page text, and JSON-LD.

## `maxConcurrency` (type: `integer`):

Maximum number of pages processed in parallel.

## `maxRequestRetries` (type: `integer`):

How many times to retry failed HTTP requests before giving up.

## `requestDelayMs` (type: `integer`):

Approximate delay between requests used for rate limiting (converted to maxRequestsPerMinute).

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

Optional Apify Proxy settings for production runs.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "stripe.com"
  ],
  "fullNames": [],
  "maxPagesPerDomain": 8,
  "generatePatterns": true,
  "crawlWebsite": true,
  "maxConcurrency": 5,
  "maxRequestRetries": 3,
  "requestDelayMs": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "domains": [
        "apify.com",
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mighty_monk/domain-email-finder").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 = { "domains": [
        "apify.com",
        "stripe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mighty_monk/domain-email-finder").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 '{
  "domains": [
    "apify.com",
    "stripe.com"
  ]
}' |
apify call mighty_monk/domain-email-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/4qHOJSO16afaH7WPc/builds/dEGiFSW5cxwuiScAj/openapi.json