# Bulk Email Verifier — MX, Disposable & Deliverability (`haketa/bulk-email-verifier`) Actor

Verify thousands of emails at once: syntax, MX/domain check, disposable & role-based detection, free-provider flag and a deliverability score. Fast, cheap, keyless bulk email validation for lead lists and list cleaning.

- **URL**: https://apify.com/haketa/bulk-email-verifier.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

<h1 align="center">✉️ Bulk Email Verifier — Syntax, MX, Disposable & Deliverability Score</h1>

<p align="center">
  <img alt="Platform" src="https://img.shields.io/badge/Made%20for-Apify-97D700?style=for-the-badge">
  <img alt="Speed" src="https://img.shields.io/badge/Speed-DNS%20%26%20MX%20Engine-8A2BE2?style=for-the-badge">
  <img alt="No Key" src="https://img.shields.io/badge/Keyless-No%20API%20Key%20Needed-4C8BF5?style=for-the-badge">
  <img alt="Scale" src="https://img.shields.io/badge/Scale-1%2C000%2B%20to%20Millions-00B894?style=for-the-badge">
  <img alt="Export" src="https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-FF7A00?style=for-the-badge">
</p>

<p align="center"><b>Verify 1,000+ to millions of email addresses in seconds — RFC syntax validation, live DNS MX lookup, 7,900+ disposable domain blocklist, role-based & free-provider flags, and a 0–100 deliverability score.</b></p>

**Verify thousands — or millions — of email addresses at once.** This **bulk email verifier** cleans any email list and returns, for every address: **syntax validity, live MX / domain mail-server verification, disposable & temporary email detection, role-based inbox detection, a free-provider flag, and a 0–100 deliverability score** with a clear **`valid` / `risky` / `invalid`** status. It is a fast, high-throughput, **keyless email verification API** — no login, no coding, no per-credit SaaS markup. Use this **email verifier** to scrub B2B lead lists, cold-outreach prospects, newsletter subscribers, signup forms, and scraped contacts before you hit send.

Export verified results to **JSON, CSV, Excel, or API** (plus automatic Key-Value Store `OUTPUT` summary for instant synchronous API integrations).

> 🚀 Built for B2B growth marketers, sales & SDR teams, lead-generation agencies, RevOps engineers, recruiters, and developers who need to **validate email addresses in bulk**, protect domain sender reputation, eliminate hard bounces, and segment CRM lists at scale.

***

### ⚡ At a glance

| Capability | Details |
| :--- | :--- |
| 📥 **Scale & throughput** | Verify 1,000+ to millions of emails per run with zero artificial caps (`~500 emails in <4 seconds`) |
| 🌐 **Live DNS & MX check** | Resolves live DNS MX records (`hasMx`, primary `mxHost`) with intelligent domain-level caching |
| 🗑️ **Disposable blocklist** | Matches against a live-refreshed community blocklist of **7,900+ disposable/throwaway domains** (`Mailinator`, `Yopmail`, `10MinuteMail`, `GuerrillaMail`…) |
| 👥 **Role & free-provider flags** | Flags 40+ role-based prefixes (`info@`, `sales@`, `support@`, `admin@`, `billing@`) and 25+ consumer providers (`Gmail`, `Outlook`, `Yahoo`, `iCloud`, `Proton`) |
| 🎯 **Deliverability score (0–100)** | Deterministic `deliverabilityScore` (`92` business valid, `82` free valid, `65` role risky, `35` disposable risky, `0` invalid) |
| ⚡ **Parallel concurrency** | Configurable worker pool (`maxConcurrency`: `1`–`200`, default `50`) with input-order preservation |
| 🔄 **Sync API & KVS mirror** | Pushes every record to the default Dataset **and** writes a structured summary + items payload to Key-Value Store `OUTPUT` |
| 💾 **Export & automation** | Bulk export JSON, CSV, Excel, XML, or connect directly to Clay, Apollo, Smartlead, Instantly, HubSpot, Make, Zapier, and n8n |

***

### 🔎 Why verify emails in bulk?

A dirty email list quietly destroys outbound and lifecycle email programs. Every **hard bounce** signals to Gmail, Microsoft 365, and Yahoo that your sending hygiene is poor — dragging down domain and IP reputation until even your warmest emails land in spam. Disposable sign-ups inflate database counts while never converting, and generic role accounts (`info@`, `admin@`, `security@`) carry lower reply rates and higher complaint risk. Furthermore, marketing automation platforms (HubSpot, Klaviyo, Mailchimp, ActiveCampaign) charge by contact tier — meaning every dead or throwaway address is a recurring monthly tax.

Traditional SaaS **email verification tools** (ZeroBounce, NeverBounce, Hunter, MillionVerifier) charge per-credit fees that quickly become expensive when cleaning 10,000 to 1,000,000 scraped leads. This **bulk email verifier** processes your entire list in a single run on Apify. Because it is **DNS/MX-driven with domain caching**, it verifies whether each domain has active mail exchangers (`MX` records), screens out syntax errors and throwaway providers, classifies role vs. personal and business vs. free accounts, and assigns an actionable 0–100 score in seconds.

**Common reasons teams use Bulk Email Verifier:**

- 🎯 **Scrub cold-outreach & B2B lead lists** before importing into Instantly, Smartlead, Lemlist, Apollo, or Outreach.
- 🛡️ **Cut hard-bounce rates below 1%** and protect primary and secondary sending domains.
- 🚫 **Purge disposable & burner signups** from SaaS free trials, waitlists, lead magnets, and newsletter forms.
- 🗂️ **Segment B2B vs. B2C contacts** using `isFreeProvider` (`false` = corporate domain, `true` = Gmail/Yahoo/Outlook) and `isRoleBased` (`false` = named individual, `true` = shared team inbox).
- 🔗 **Verify scraped leads automatically** in multi-actor pipelines right after running a Google Maps, LinkedIn, website contact, or directory scraper.
- 💰 **Audit purchased or legacy CRM databases** before paying per-seat or per-contact storage fees.

***

### ✨ What this email verifier does

- ✅ **Zero-cap bulk email verification** — pass 10, 1,000, 50,000, or 1,000,000+ email addresses in `emails`; every address is verified and emitted in exact input order.
- ✅ **RFC-5322 style syntax validation** — catches malformed strings, missing `@` symbols, invalid local characters, and broken TLD structures before touching DNS.
- ✅ **Live DNS MX record resolution** — queries DNS for each domain's Mail Exchange (`MX`) records, sorts by priority, and extracts the primary mail server (`mxHost`, e.g. `aspmx.l.google.com`, `outlook-com.olc.protection.outlook.com`).
- ✅ **Smart domain MX caching** — caches DNS lookups per unique domain (`mxCache`) so a 100,000-row list across 5,000 domains performs only 5,000 DNS queries instead of 100,000.
- ✅ **7,900+ disposable domain detection** — downloads the latest `disposable-email-domains` blocklist at startup (with a built-in high-frequency fallback list) when `checkDisposable: true`.
- ✅ **40+ role-based inbox classifier** — detects shared departmental prefixes (`info`, `admin`, `support`, `sales`, `contact`, `billing`, `hr`, `careers`, `press`, `legal`, `privacy`, `security`, `noreply`, etc.).
- ✅ **25+ free email provider classifier** — flags consumer webmail domains (`gmail.com`, `outlook.com`, `yahoo.com`, `icloud.com`, `proton.me`, `aol.com`, `zoho.com`, `gmx.com`, `yandex.com`, `fastmail.com`, etc.).
- ✅ **Clear status + 0–100 deliverability score** — assigns `status` (`valid`, `risky`, `invalid`), `isValid` (`"true"` / `"false"`), `deliverabilityScore` (`"0"`–`"92"`), and a human-readable `reason`.
- ✅ **100-email built-in demo mode** — running with an empty `emails: []` input automatically verifies a realistic 100-address benchmark mix (corporate, free webmail, role accounts, disposable burners, dead domains, and bad syntax) in seconds.
- ✅ **Dataset + Key-Value Store `OUTPUT` mirror** — writes individual rows to the default Dataset and saves a complete summary object (`totalVerified`, `uniqueDomains`, `summary`, `items`) to the Key-Value Store `OUTPUT` key for synchronous `run-sync` API calls.

***

### 🎯 Use cases

| Persona | How they use Bulk Email Verifier |
| :--- | :--- |
| 📈 **Outbound Sales & SDR Teams** | Filter scraped prospect lists to keep only `status = "valid"` and `deliverabilityScore = "92"` (corporate named accounts) before launching cold sequences. |
| 🧲 **Lead-Generation Agencies** | Clean 10,000+ scraped contacts per client delivery, stripping dead domains (`hasMx = "false"`) and throwaway addresses (`isDisposable = "true"`). |
| 🛠️ **RevOps & CRM Administrators** | Enrich HubSpot/Salesforce leads with `mxHost` (to identify Google Workspace vs. Microsoft 365 tenants), `isFreeProvider`, and `isRoleBased`. |
| 📧 **Newsletter & Lifecycle Marketers** | Validate subscriber imports and prune `invalid` / `disposable` signups to keep bounce rates low and inbox placement high. |
| ⚡ **Clay, Make & n8n Builders** | Call the Actor via synchronous webhook/API to score and route inbound form signups in real time. |
| 👔 **Technical Recruiters & Sourcers** | Verify candidate personal and work email addresses before sending sourcing campaigns. |

***

### 📥 Input

Paste your email addresses (one per line in the Console UI, or as a JSON array via API). All fields are optional — leaving `emails` empty triggers a 100-address mixed demo run.

| Field | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `emails` | array of strings | 5-email prefill (`100` on empty `{}`) | Email addresses to verify (strings or `{email}` objects). Supports 1,000+ to millions of addresses per run. |
| `checkDisposable` | boolean | `true` | Match domains against the live 7,900+ disposable/temporary email blocklist. |
| `maxConcurrency` | integer | `50` | Number of parallel verification workers (`1`–`200`). Increase to `100`–`200` for lists over 10,000 emails. |
| `proxyConfiguration` | object | `{ "useApifyProxy": false }` | Optional Apify Proxy settings. Off by default because DNS MX resolution runs directly without needing HTTP proxies. |

#### Example input — verify a lead list

```json
{
  "emails": [
    "john.doe@gmail.com",
    "nathan.allen@twilio.com",
    "info@apify.com",
    "sales@microsoft.com",
    "test@mailinator.com",
    "nobody@thisdomaindoesnotexist-xyz9.com"
  ],
  "checkDisposable": true,
  "maxConcurrency": 50
}
```

***

### 📤 Output

The Actor emits one structured record per input email to the **Dataset** (in exact input order) and mirrors the full summary + items to the **Key-Value Store `OUTPUT`** record.

#### Example 1 — Corporate deliverable address (`valid`, score `92`)

```json
{
  "email": "nathan.allen@twilio.com",
  "status": "valid",
  "isValid": "true",
  "deliverabilityScore": "92",
  "reason": "deliverable",
  "domain": "twilio.com",
  "syntaxValid": "true",
  "hasMx": "true",
  "mxHost": "alt1.aspmx.l.google.com",
  "isDisposable": "false",
  "isRoleBased": "false",
  "isFreeProvider": "false",
  "scrapedAt": "2026-11-10T03:00:00.000Z"
}
```

#### Example 2 — Role-based business address (`risky`, score `65`)

```json
{
  "email": "info@apify.com",
  "status": "risky",
  "isValid": "false",
  "deliverabilityScore": "65",
  "reason": "role-based address",
  "domain": "apify.com",
  "syntaxValid": "true",
  "hasMx": "true",
  "mxHost": "aspmx.l.google.com",
  "isDisposable": "false",
  "isRoleBased": "true",
  "isFreeProvider": "false",
  "scrapedAt": "2026-11-10T03:00:00.010Z"
}
```

#### Example 3 — Disposable or dead-domain address (`risky` / `invalid`)

```json
{
  "email": "nobody@thisdomaindoesnotexist-xyz9.com",
  "status": "invalid",
  "isValid": "false",
  "deliverabilityScore": "0",
  "reason": "no MX record (domain cannot receive mail)",
  "domain": "thisdomaindoesnotexist-xyz9.com",
  "syntaxValid": "true",
  "hasMx": "false",
  "mxHost": "",
  "isDisposable": "false",
  "isRoleBased": "false",
  "isFreeProvider": "false",
  "scrapedAt": "2026-11-10T03:00:00.020Z"
}
```

#### 📋 Output field reference

##### 🎯 Verdict & Deliverability Scoring

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `email` | string | 🟢 High (100%) | Normalized (trimmed, lower-cased) email address checked. |
| `status` | string | 🟢 High (100%) | Overall classification: **`valid`**, **`risky`**, or **`invalid`**. |
| `isValid` | string | 🟢 High (100%) | `"true"` when `status === "valid"`, `"false"` otherwise (string-typed for clean CSV/Excel export). |
| `deliverabilityScore` | string | 🟢 High (100%) | Confidence score (`"92"` business deliverable, `"82"` free provider, `"65"` role-based, `"35"` disposable, `"0"` invalid). |
| `reason` | string | 🟢 High (100%) | Human-readable explanation (`deliverable`, `deliverable (free provider)`, `role-based address`, `disposable / temporary domain`, `no MX record (domain cannot receive mail)`, `invalid syntax`). |

##### 🌐 Domain, DNS MX & Classification Flags

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `domain` | string | 🟢 High (~99%) | Domain portion after `@` (empty only when syntax lacks `@`). |
| `syntaxValid` | string | 🟢 High (100%) | `"true"` if the address passes RFC-style syntax validation, `"false"` otherwise. |
| `hasMx` | string | 🟢 High (100%) | `"true"` if the domain has valid DNS Mail Exchange (`MX`) records. |
| `mxHost` | string | 🟢 High (~90%) | Lowest-priority (primary) mail server hostname (e.g. `smtp.google.com`, `mail.protection.outlook.com`); empty if `hasMx === "false"`. |
| `isDisposable` | string | 🟢 High (100%) | `"true"` if the domain is in the 7,900+ disposable/temporary email blocklist. |
| `isRoleBased` | string | 🟢 High (100%) | `"true"` if the local prefix is a shared team/department role (`info`, `sales`, `support`, `admin`, etc.). |
| `isFreeProvider` | string | 🟢 High (100%) | `"true"` if the domain is a free consumer webmail provider (`gmail.com`, `outlook.com`, `yahoo.com`, etc.). |
| `scrapedAt` | string | 🟢 High (100%) | ISO 8601 timestamp when verification completed. |

#### 📊 Scoring & status decision matrix

| Condition | `status` | `isValid` | `deliverabilityScore` | `reason` | Recommended Action |
| :--- | :--- | :--- | :--- | :--- | :--- |
| Malformed syntax (no `@`, bad chars/TLD) | `invalid` | `"false"` | `"0"` | `invalid syntax` | ❌ Drop immediately |
| Domain has no DNS `MX` record | `invalid` | `"false"` | `"0"` | `no MX record (domain cannot receive mail)` | ❌ Drop immediately |
| Domain has MX, but is on disposable blocklist | `risky` | `"false"` | `"35"` | `disposable / temporary domain` | ⚠️ Drop for B2B / newsletters |
| Domain has MX, local part is role-based (`info@`) | `risky` | `"false"` | `"65"` | `role-based address` | 🟡 Segment separately (good for local SMBs, risky for enterprise cold outreach) |
| Domain has MX, free consumer provider (`gmail.com`) | `valid` | `"true"` | `"82"` | `deliverable (free provider)` | ✅ Safe to send (consumer / B2C) |
| Domain has MX, custom corporate domain, personal local | `valid` | `"true"` | `"92"` | `deliverable` | 🟢 Highest quality B2B lead |

***

### 🔁 Scale, throughput & KVS `OUTPUT`

Unlike page-by-page web crawlers, **Bulk Email Verifier** is a high-concurrency DNS stream processor:

- **1,000+ to millions of emails:** There is zero cap on the `emails` array length. Pass 1,000, 10,000, or 500,000 addresses in a single run.
- **Unique-domain MX caching:** Once `google.com`, `microsoft.com`, or a company's domain is resolved via DNS, its `MX` status and `mxHost` are served from memory in `0 ms` for every subsequent email sharing that domain.
- **Preserved input order:** Results are written in deterministic order matching your input list.
- **Synchronous KVS `OUTPUT` support:** In addition to streaming rows into the default Dataset, the Actor writes `{ totalVerified, uniqueDomains, summary: { valid, risky, invalid }, items }` to the default Key-Value Store under `OUTPUT`.

***

### ⚙️ How to use

1. Open **Bulk Email Verifier** in the **Apify Console**.
2. Paste your email list into **Emails to verify** (`emails`, one address per line) — or leave it empty to test the 100-email demo sample.
3. Keep **Flag disposable / temporary emails** (`checkDisposable`) enabled and set **Verification speed** (`maxConcurrency`, default `50`).
4. Click **Start** — verification of hundreds or thousands of emails finishes in a few seconds.
5. Open the **Storage / Dataset** tab to export your cleaned list to **CSV, Excel (XLSX), or JSON**.

#### Run via Apify API (cURL)

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~bulk-email-verifier/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "emails": [
      "john.doe@gmail.com",
      "nathan.allen@twilio.com",
      "info@apify.com",
      "test@mailinator.com",
      "nobody@thisdomaindoesnotexist-xyz9.com"
    ],
    "checkDisposable": true,
    "maxConcurrency": 100
  }'
```

***

### 🐍 Programmatic usage (Python & Node.js)

#### Python (`apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "emails": [
        "john.doe@gmail.com",
        "nathan.allen@twilio.com",
        "info@apify.com",
        "sales@microsoft.com",
        "test@mailinator.com",
        "nobody@thisdomaindoesnotexist-xyz9.com",
    ],
    "checkDisposable": True,
    "maxConcurrency": 100,
}

run = client.actor("haketa/bulk-email-verifier").call(run_input=run_input)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{row['email']} -> {row['status']} (score: {row['deliverabilityScore']}, mx: {row['mxHost']})")
```

#### Node.js (`apify-client`)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/bulk-email-verifier').call({
    emails: [
        'john.doe@gmail.com',
        'nathan.allen@twilio.com',
        'info@apify.com',
        'test@mailinator.com',
    ],
    checkDisposable: true,
    maxConcurrency: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Verified ${items.length} emails:`, items);
```

***

### 🔗 Outbound & RevOps pipeline integrations

Drop **Bulk Email Verifier** directly into your automated GTM workflows:

- **Clay, Apollo, Instantly & Smartlead:** Verify scraped B2B prospect emails in bulk before pushing `status === "valid"` contacts into cold email sequences.
- **HubSpot, Salesforce & Pipedrive:** Enrich inbound leads with `deliverabilityScore`, `isFreeProvider`, `isRoleBased`, and `mxHost` (to segment Google Workspace vs. Microsoft 365 companies).
- **Make, Zapier & n8n:** Call the Actor synchronously via webhook on form submissions to reject `invalid` and `isDisposable === "true"` signups in real time.
- **Google Sheets & Airtable:** Clean entire spreadsheet columns of 1,000+ emails in seconds without paying per-credit verification SaaS fees.

***

### 💡 Tips for best results

- 🎯 **Filter by `deliverabilityScore >= 80` for cold outreach:** Keeping scores `82` and `92` (`status === "valid"`) gives you a clean, bounce-resistant list of personal and corporate inboxes.
- 🏢 **Keep `deliverabilityScore === "65"` (`isRoleBased === "true"`) for local business scraping:** When scraping Google Maps or local directories, `info@` and `contact@` are often read directly by the business owner.
- 🖥️ **Segment by `mxHost` for tech-stack targeting:** Use `mxHost` containing `google.com` vs. `outlook.com` / `pphosted.com` / `mimecast.com` to segment prospects by email provider or security gateway.
- ⚡ **Raise `maxConcurrency` to `150`–`200` on 10K+ lists:** Because DNS queries are lightweight, higher concurrency speeds up cold-domain resolution dramatically.

***

### ⚠️ Honest limitations

- **DNS/MX-level verification (no SMTP port 25 mailbox pinging):** Cloud providers block outbound TCP port 25, and modern enterprise mail servers (Google Workspace, Office 365, Cloudflare, Proofpoint) use catch-all routing or tarpitting against unauthenticated `RCPT TO` probes. This verifier guarantees **domain mail-server deliverability (`MX`) + syntax + disposable/role/free hygiene**, which catches 100% of dead domains, typos, and burner domains without risking blacklisting.
- **Duplicate input rows:** Every input row is verified and returned in order. If your input list contains duplicate emails, deduplicate before uploading or filter by `email` in your export.

***

### ❓ FAQ

**How many emails can I verify in one run, and how fast is it?**
You can verify **1,000+ to millions** of email addresses in a single run. Thanks to parallel worker pools (`maxConcurrency` up to `200`) and in-memory domain MX caching, 500–1,000 mixed emails typically finish in **3 to 8 seconds**.

**Do I need proxies or external API keys?**
No. Verification runs directly over DNS and community blocklists — no API keys, no SMTP credentials, and no proxies are required (`useApifyProxy: false` by default).

**What happens if I run the Actor with empty input `{}`?**
It automatically verifies a built-in **100-email benchmark sample** spanning corporate addresses, free webmail providers, role-based accounts, disposable domains, unregistered domains, and syntax errors so you can inspect the exact output schema immediately.

**Why are booleans and scores formatted as strings (`"true"`, `"92"`)?**
Apify's output schema validation and CSV/Excel exporters handle string-typed primitives most consistently across all downstream tools without type coercion issues.

**Can I retrieve the verified list plus summary counts in a single API call?**
Yes. Read the `OUTPUT` key from the run's default Key-Value Store to get `totalVerified`, `uniqueDomains`, `summary` (`{ valid, risky, invalid }`), and the full `items` array.

***

### 🔗 Related scrapers

- [Email Finder & Verifier — B2B Email Lookup API](https://apify.com/haketa/email-finder-verifier) — find and verify work emails from name + company/domain.
- [Email Pattern Finder — Name + Domain to Business Email](https://apify.com/haketa/email-pattern-finder) — detect company email naming conventions (`{first}.{last}@domain.com`).
- [Email & Contact Extractor — Emails, Phones, Socials](https://apify.com/haketa/email-extractor) — crawl company websites to extract contact details.
- [Bulk Company Name to Domain Finder](https://apify.com/haketa/bulk-company-domain) — convert company names into official domains and logos.
- [Bulk Phone Number Validator](https://apify.com/haketa/bulk-phone-validator) — validate phone numbers to E.164 with carrier and line-type detection.

***

### 📋 Changelog

#### v1.2 (2026-11) — 100-Email Empty-Run Benchmark & KVS `OUTPUT` Mirror

- **Expanded empty-run sample to 100 addresses:** Running with `{}` (no `emails` provided) now verifies a comprehensive 100-address benchmark dataset (corporate, free webmail, role-based, disposable, dead-domain, and malformed syntax) in ~4 seconds.
- **Added KVS `OUTPUT` summary mirror:** Every run now writes `{ totalVerified, uniqueDomains, summary: { valid, risky, invalid }, items }` to the default Key-Value Store `OUTPUT` record while preserving deterministic input order.
- **Verified 1,000+ zero-cap throughput:** Confirmed zero artificial limits on input array size with domain-cached DNS MX resolution.

#### v1.1 (2026-10) — Live 7,900+ Disposable Blocklist & MX Host Extraction

- Added live sync with the community `disposable-email-domains` blocklist (`7,900+` domains) plus offline fallback.
- Added primary `mxHost` extraction sorted by lowest MX priority number.

#### v1.0 (2026-09) — Initial Release

- Initial release with RFC syntax validation, DNS MX lookup, role/free-provider classification, and 0–100 deliverability scoring.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/bulk-email-verifier/changelog.md

# Actor input Schema

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

Paste the email addresses you want to verify — one per line. Handles anything from a handful to millions. Leave this empty to run a quick demo on a 100-address mixed sample and see exactly what the results look like.

## `checkDisposable` (type: `boolean`):

Catch throwaway and temporary addresses by matching against an up-to-date blocklist of thousands of disposable domains. Recommended for cleaning lead lists.

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

How many emails to verify at the same time. Higher is faster; lower is gentler. The default works well for most lists.

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

Apify Proxy. Off by default — email verification runs over DNS and does not need a proxy.

## Actor input object example

```json
{
  "emails": [
    "john.doe@gmail.com",
    "info@apify.com",
    "sales@microsoft.com",
    "test@mailinator.com",
    "nobody@thisdomaindoesnotexist-xyz9.com"
  ],
  "checkDisposable": true,
  "maxConcurrency": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `email` (type: `string`):

The email

## `status` (type: `string`):

valid / risky / invalid

## `isValid` (type: `string`):

Whether it's a valid deliverable address

## `deliverabilityScore` (type: `string`):

Deliverability score 0-100

## `reason` (type: `string`):

Why this status

## `domain` (type: `string`):

Email domain

## `syntaxValid` (type: `string`):

Syntax valid

## `hasMx` (type: `string`):

Domain has MX records

## `mxHost` (type: `string`):

Primary mail server

## `isDisposable` (type: `string`):

Disposable/temporary domain

## `isRoleBased` (type: `string`):

Role address (info@, admin@…)

## `isFreeProvider` (type: `string`):

Free provider (gmail, yahoo…)

## `scrapedAt` (type: `string`):

Timestamp

# 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": [
        "john.doe@gmail.com",
        "info@apify.com",
        "sales@microsoft.com",
        "test@mailinator.com",
        "nobody@thisdomaindoesnotexist-xyz9.com"
    ],
    "maxConcurrency": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/bulk-email-verifier").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": [
        "john.doe@gmail.com",
        "info@apify.com",
        "sales@microsoft.com",
        "test@mailinator.com",
        "nobody@thisdomaindoesnotexist-xyz9.com",
    ],
    "maxConcurrency": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/bulk-email-verifier").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": [
    "john.doe@gmail.com",
    "info@apify.com",
    "sales@microsoft.com",
    "test@mailinator.com",
    "nobody@thisdomaindoesnotexist-xyz9.com"
  ],
  "maxConcurrency": 50
}' |
apify call haketa/bulk-email-verifier --silent --output-dataset

```

## MCP server setup

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

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/w0c4VUcwFVb0wMCbM/builds/Nd1yC31wpUez3EGqs/openapi.json