# Email Verifier, Finder & Deliverability Checker (`fetch_cat/email-enrichment-scraper`) Actor

Verify email syntax and domains, find publicly listed business contact addresses, and export transparent deliverability and authentication signals.

- **URL**: https://apify.com/fetch\_cat/email-enrichment-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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.
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

## Email Verifier, Finder & Deliverability Checker

Verify known emails, find publicly listed business contact emails, and audit domain email authentication in one batch. The Actor exports transparent MX, SPF, DMARC, DKIM, provider, disposable, role-account, and confidence signals without treating MX records as proof that a mailbox exists.

### Who is it for?

Sales operations teams, lead-generation agencies, recruiters, founders, and developers can use this Actor to qualify public business-contact data and diagnose domain email setup before outreach.

### What you can do

- Clean CRM and lead-list emails before outreach.
- Find a named person's email when it is publicly listed on the supplied company website.
- Audit company domains for mail routing and authentication gaps.
- Separate invalid, risky, ready, not-found, and domain-only results.
- Process up to 10,000 deduplicated targets with bounded concurrency and resumable cutoff evidence.

### Example input

```json
{
  "emails": ["sales@example.com", "person@company.com"],
  "contacts": [{ "firstName": "Ada", "lastName": "Lovelace", "domain": "example.org" }],
  "domains": ["example.net"],
  "maxConcurrency": 10,
  "maxRuntimeSecs": 270
}
```

### Example output

```json
{
  "email": "sales@example.com",
  "firstName": null,
  "lastName": null,
  "domain": "example.com",
  "isValidFormat": true,
  "syntaxErrors": [],
  "hasMxRecords": true,
  "isVerified": null,
  "isCatchAll": null,
  "isDisposable": false,
  "isFreeProvider": false,
  "isRoleAccount": true,
  "confidenceScore": 85,
  "verificationMethod": "mx",
  "mxHost": "mail.example.com",
  "provider": "other",
  "patternsTried": 0,
  "sources": ["public-dns"],
  "verificationTimeMs": 120,
  "deliverabilityGrade": "A",
  "deliverabilityScore": 85,
  "spfExists": true,
  "spfValid": true,
  "dmarcExists": true,
  "dmarcPolicy": "reject",
  "dkimFound": false,
  "deliverabilityIssues": ["COMMON_DKIM_SELECTOR_NOT_FOUND"],
  "status": "READY",
  "checkedAt": "2026-09-07T07:00:00.000Z"
}
```

### Input settings

| Key | Type | Description |
|---|---|---|
| `emails` | string\[] | Known email addresses to check. |
| `contacts` | object\[] | Objects with `firstName`, `lastName`, and `domain`; only publicly evidenced matches are returned. |
| `domains` | string\[] | Domains to audit without inventing an email address. |
| `csvText` | string | Comma, whitespace, or newline-separated email addresses. |
| `maxConcurrency` | integer | Concurrent independent targets, from 1 to 25. |
| `maxRuntimeSecs` | integer | Runtime budget from 60 to 270 seconds. |

At least one target is required. Inputs are deduplicated before network work.

### Output fields

| Field | Description |
|---|---|
| `email` | Submitted or publicly evidenced email; null for domain-only/not-found rows. |
| `firstName`, `lastName` | Submitted contact identity when using finder mode. |
| `domain` | Normalized ASCII mail/company domain. |
| `isValidFormat`, `syntaxErrors` | Local syntax result and explicit issue codes. |
| `hasMxRecords`, `mxHost` | Public mail-routing result and preferred host. |
| `isVerified` | Conclusive mailbox result; null when no authorized mailbox probe was performed. |
| `isCatchAll` | Conclusive catch-all result; null when not tested. |
| `isDisposable`, `isFreeProvider`, `isRoleAccount` | Address risk classifications. |
| `confidenceScore` | Deterministic 0–100 confidence for the supplied/evidenced address. |
| `verificationMethod` | Deepest supported check: `domain`, `format`, or `mx`. |
| `provider` | Provider inferred from the preferred MX hostname. |
| `patternsTried`, `sources` | Finder work count and public evidence routes. |
| `verificationTimeMs` | Processing time for the row. |
| `deliverabilityGrade`, `deliverabilityScore` | Domain authentication grade and 0–100 score. |
| `spfExists`, `spfValid` | SPF publication and basic version validity. |
| `dmarcExists`, `dmarcPolicy` | DMARC publication and policy. |
| `dkimFound` | Whether one of several common public selector records was found. |
| `deliverabilityIssues` | Explicit mail/authentication issue codes. |
| `status` | `READY`, `RISKY`, `INVALID`, `NOT_FOUND`, `DOMAIN_ONLY`, or `FAILED`. |
| `checkedAt` | ISO timestamp for freshness. |

### Input recipes

**Verify a pasted list**

```json
{ "csvText": "hello@example.com\nsales@example.org" }
```

**Audit domains**

```json
{ "domains": ["google.com", "microsoft.com"] }
```

**Find a public contact email**

```json
{ "contacts": [{ "firstName": "Jane", "lastName": "Smith", "domain": "example.com" }] }
```

### Pricing

The Actor uses pay-per-event pricing: one small start charge per run and one `result` charge after each dataset row is saved. See the [live Actor Pricing tab](https://apify.com/fetch_cat/email-enrichment-scraper/pricing) for current account-tier rates. Failed targets that produce no row are not charged as results.

### Limits and data availability

- The maximum batch size is 10,000 unique targets; finder mode checks a bounded set of public company pages.
- Results depend on public DNS and website availability. Missing public evidence produces `NOT_FOUND` rather than a guessed address.
- A valid format and MX record do not prove that a specific mailbox exists.
- `isVerified: null` and `isCatchAll: null` mean the claim was not conclusively tested, not `false`.
- DKIM selectors are chosen by each sender; common-selector discovery is useful but not exhaustive.
- Public contact discovery returns only an address found on the supplied company's public pages and textually matching a conventional person pattern.
- DNS changes can take time to propagate; use `checkedAt` when comparing runs.
- Large workloads may stop before the platform cutoff and preserve pending targets in the run key-value store.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~email-enrichment-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"emails":["hello@example.com"]}'
```

JavaScript:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/email-enrichment-scraper').call({ emails: ['hello@example.com'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Python:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/email-enrichment-scraper').call(
    run_input={'emails': ['hello@example.com']}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
```

### Use with MCP and AI agents

Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/email-enrichment-scraper"
```

Desktop, Cursor, or VS Code MCP configuration:

```json
{ "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=fetch_cat/email-enrichment-scraper" } } }
```

### FAQ

#### Does this send email?

No. It analyzes supplied/public addresses and domain mail configuration.

#### Does an MX result prove the mailbox exists?

No. The Actor reports mailbox-only claims as null unless conclusively supported.

#### Why is DKIM false when a domain sends signed mail?

The domain may use a custom selector not included in the bounded common-selector check.

#### Can I combine all modes?

Yes. `emails`, `contacts`, `domains`, and `csvText` can be submitted together.

### Related Actors

- [Email MX & Deliverability Verifier](https://apify.com/fetch_cat/email-mx-deliverability-verifier)
- [Public B2B Email Finder & MX Verifier](https://apify.com/fetch_cat/email-finder-api-scraper)
- [Google Maps Email Extractor & Lead Finder](https://apify.com/fetch_cat/google-maps-lead-finder)
- [Decision-Maker Public Email Finder](https://apify.com/fetch_cat/decision-maker-email-finder)
- [Public Email Domain Verifier](https://apify.com/fetch_cat/public-osint-email-lookup-verifier-scraper)

### Support

Open an issue from the Actor page with a sanitized input example, run ID, expected result, and observed result. Do not include private lead lists or credentials.

# Actor input Schema

## `emails` (type: `array`):

Known email addresses to verify.

## `contacts` (type: `array`):

Find only emails publicly associated with each named person. Each object needs firstName, lastName, and domain.

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

Domains to audit for MX, SPF, DMARC, and common DKIM selectors.

## `csvText` (type: `string`):

Optional comma, whitespace, or newline-separated email addresses.

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

Process at most this many independent targets concurrently.

## `maxRuntimeSecs` (type: `integer`):

Stop admitting new targets before this many seconds and preserve pending work.

## Actor input object example

```json
{
  "emails": [
    "hello@example.com"
  ],
  "contacts": [],
  "domains": [],
  "csvText": "",
  "maxConcurrency": 10,
  "maxRuntimeSecs": 270
}
```

# Actor output Schema

## `overview` (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 = {
    "emails": [
        "hello@example.com"
    ],
    "contacts": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/email-enrichment-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 = {
    "emails": ["hello@example.com"],
    "contacts": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/email-enrichment-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 '{
  "emails": [
    "hello@example.com"
  ],
  "contacts": []
}' |
apify call fetch_cat/email-enrichment-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/email-enrichment-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/JihcRKpgpw3LSYeak/builds/8pDyaPCEj8BWfmfBT/openapi.json