# ✅ Bulk Email Validator — Verify & Clean Lists (`nexgendata/email-validator`) Actor

Validate thousands of emails in bulk with DNS MX verification, syntax checking, disposable detection & free provider ID. Cheaper than ZeroBounce ($0.005 vs $0.008/email). Clean lists before campaigns to protect sender reputation.

- **URL**: https://apify.com/nexgendata/email-validator.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 27 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 email validations

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## ✅ Bulk Email Validator — Verify & Clean Lists

Validate thousands of email addresses in bulk with DNS MX record verification, syntax checking, disposable email detection, and free provider identification. Clean your email lists before sending campaigns to improve deliverability and protect your sender reputation.

### What Checks Are Performed?

Every email address goes through four validation layers:

- **Syntax validation**: RFC-compliant regex check catches typos and malformed addresses
- **DNS MX lookup**: Verifies the domain has active mail servers that can receive email
- **Disposable detection**: Flags temporary/throwaway emails (Mailinator, Guerrilla Mail, etc.)
- **Free provider check**: Identifies Gmail, Yahoo, Outlook, and other free providers vs. business domains

### Use Cases

- **Email list cleaning**: Remove invalid and risky addresses before campaigns to boost deliverability
- **Lead qualification**: Separate business emails from free providers for B2B outreach
- **CRM hygiene**: Regularly validate your contact database to maintain data quality
- **Signup verification**: Validate user emails during onboarding to prevent fake registrations
- **Data enrichment**: Add validation status, domain type, and MX records to existing contact lists
- **Bounce prevention**: Eliminate hard bounces before they damage your sender score

### Quick Start

#### Python SDK
```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("nexgendata/email-validator").call(
    run_input={
        "emails": [
            "test@gmail.com",
            "fake@nonexistentdomain12345.com",
            "info@apple.com"
        ]
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['email']}: {item['status']} (MX: {item['hasMx']})")
````

#### cURL

```bash
curl "https://api.apify.com/v2/acts/nexgendata~email-validator/runs?token=YOUR_API_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"emails": ["test@gmail.com", "fake@invalid.xyz"]}'
```

### Example Output

```json
{
  "email": "info@apple.com",
  "status": "valid",
  "syntaxValid": true,
  "hasMx": true,
  "mxRecords": ["mx1.apple.com", "mx2.apple.com"],
  "isDisposable": false,
  "isFreeProvider": false,
  "domain": "apple.com"
}
```

### Input Parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `emails` | array | List of email addresses to validate |

### Pricing

Pay only for what you validate — no monthly fees:

- **$0.005 per email** validated
- Example: 1,000 emails = $5.00
- Compare: ZeroBounce charges $0.008/email, NeverBounce $0.008/email

### Why Use This Over ZeroBounce or NeverBounce?

| Feature | This Actor | ZeroBounce | NeverBounce |
|---------|-----------|------------|-------------|
| Price per email | $0.005 | $0.008 | $0.008 |
| Minimum purchase | None | $16 | $8 |
| API integration | Apify SDK, Zapier, Make | Custom API | Custom API |
| Bulk processing | Unlimited | Plan-based | Plan-based |
| MX record data | Included | Extra | Not included |

### FAQ

**How accurate is the validation?**
Syntax + DNS MX checking catches 95%+ of invalid addresses. This validates that the domain can receive email, which is the most reliable server-side check available without actually sending a test email.

**Can I validate thousands of emails at once?**
Yes — pass your entire list in one run. The actor processes emails in parallel for fast throughput.

**Does this check if the specific mailbox exists?**
It verifies the domain has working mail servers (MX records). Full mailbox verification (SMTP check) is not included as many mail servers block these probes.

**Can I schedule regular list cleaning?**
Yes — use Apify Schedules to validate your lists weekly or monthly automatically.

**What format should my email list be in?**
Pass emails as a JSON array. For CSV files, use Apify's dataset import to convert first.

### Integrations

Connect to your CRM and marketing tools with [Zapier](https://zapier.com), [Make.com](https://make.com), or the [Apify API](https://docs.apify.com/api/v2). Export results as JSON, CSV, or Excel for direct import into Mailchimp, HubSpot, Salesforce, or any platform.

[Validate your emails now on Apify](https://apify.com/nexgendata/email-validator?fpr=2ayu9b)

### Related tools

- [Lead List Enricher — Emails, Phones & Social from Any Domain](https://apify.com/nexgendata/lead-list-enricher?fpr=2ayu9b)
- [Company Email Finder — B2B Contact Scraper](https://apify.com/nexgendata/company-email-finder?fpr=2ayu9b)
- [LinkedIn Jobs Scraper — Extract Listings Free](https://apify.com/nexgendata/linkedin-jobs-scraper?fpr=2ayu9b)
- [Yellow Pages Scraper — Local Business Leads](https://apify.com/nexgendata/yellow-pages-scraper?fpr=2ayu9b)

### 💰 Pricing Example

This actor uses Pay-Per-Event pricing — you only pay for results.

- **Typical run (small):** 100 results × $0.05 = **$5.00**
- **Medium run:** 500 results × $0.05 = **$25.00**
- **Large run (power user):** 2,000 results × $0.05 = **$100.00**

Free Apify accounts get $5/mo in platform credit. A typical email deliverability workflow at this scale typically exceeds the free credit — upgrade to a paid Apify plan for unrestricted use.

### 🔗 Related Actors

Pair with these for a complete workflow:

- [📧 Email Verification Tool — Deliverability Checker](https://apify.com/nexgendata/email-verification-tool) — advanced email verification with MX + SMTP + role detection
- [📋 Email DMARC Auditor — SPF/DKIM/DMARC Bulk Check](https://apify.com/nexgendata/email-dmarc-auditor) — DMARC + SPF + DKIM auditor for any domain
- [📧 Email RBL Bulk Checker — MXToolbox Alternative](https://apify.com/nexgendata/email-rbl-checker) — check IPs + domains against 80+ DNS-based blocklists
- [📧 Website Email Extractor — Bulk Contact Scraper](https://apify.com/nexgendata/website-email-extractor) — crawl websites to harvest email addresses
- [📧 Company Email Finder — B2B Contact Scraper](https://apify.com/nexgendata/company-email-finder) — find decision-maker emails by job title + seniority

### Related NexGenData actors

Part of the **3. Lead Generation & Enrichment** workflow. Related NexGenData actors:

- [Company Email Finder — B2B Contact Scraper](https://apify.com/nexgendata/company-email-finder?fpr=2ayu9b)
- [B2B Leads Finder — Apollo Alternative | Emails](https://apify.com/nexgendata/b2b-leads-finder?fpr=2ayu9b)
- [Company Enrichment — Domain & Contact Finder](https://apify.com/nexgendata/company-enrichment-tool?fpr=2ayu9b)
- [Lead List Enricher — Emails, Phones & Social from Any Domain](https://apify.com/nexgendata/lead-list-enricher?fpr=2ayu9b)
- [Email Verification Tool — Deliverability Checker](https://apify.com/nexgendata/email-verification-tool?fpr=2ayu9b)

Browse the full [NexGenData storefront by workflow](https://thenextgennexus.com/actors-by-workflow/) or the [Lead Generation & Enrichment cluster guide](https://thenextgennexus.com/lead-generation-data-tools/).

# Actor input Schema

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

Email addresses to validate. Accepts either a JSON array (recommended) or a string with one email per line / comma-separated.

## `singleEmail` (type: `string`):

Convenience field to validate a single email address

## Actor input object example

```json
{
  "emails": [],
  "singleEmail": ""
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/email-validator").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/email-validator").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 '{}' |
apify call nexgendata/email-validator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "✅ Bulk Email Validator — Verify & Clean Lists",
        "description": "Validate thousands of emails in bulk with DNS MX verification, syntax checking, disposable detection & free provider ID. Cheaper than ZeroBounce ($0.005 vs $0.008/email). Clean lists before campaigns to protect sender reputation.",
        "version": "0.0",
        "x-build-id": "TVhntmZnNz3enHgbC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~email-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-email-validator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~email-validator/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-email-validator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~email-validator/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-email-validator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "emails": {
                        "title": "Email Addresses",
                        "type": "array",
                        "description": "Email addresses to validate. Accepts either a JSON array (recommended) or a string with one email per line / comma-separated.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "singleEmail": {
                        "title": "Single Email Address (optional)",
                        "type": "string",
                        "description": "Convenience field to validate a single email address",
                        "default": ""
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```