# Email Validator & Verifier - Bulk Email Checker (`vero-api/email-validator`) Actor

Clean any email list in seconds. Every address comes back valid, risky or invalid with a 0-100 score and a plain-English reason. Fixes typos, flags disposable and shared inboxes, shows the mail provider and SPF/DMARC behind each domain, and checks emails straight from a lead scraper's dataset.

- **URL**: https://apify.com/vero-api/email-validator.md
- **Developed by:** [VeroAPIs](https://apify.com/vero-api) (community)
- **Categories:** Lead generation, Developer tools, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 verified emails

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

## Email Validator & Verifier — bulk email checker that cleans your list before you send

Check any list of email addresses and get back a clear verdict for each one: valid, risky, or invalid. Catch typos, dead domains, throwaway addresses, and shared team inboxes before they cost you a campaign.

It is a fast, domain-level list cleaner: thousands of addresses in minutes, nothing ever sent to them, and you pay only for the addresses it checks.

### What you can do

- Score every address from 0 to 100 with a plain-English reason.
- Catch typos automatically — `jane@gmial.com` comes back as `jane@gmail.com`.
- Remove dead addresses: domains that don't exist or don't accept email come back invalid.
- Spot disposable addresses from a list of 120,000+ throwaway domains, including every subdomain of services like Mailinator.
- Flag shared inboxes like `info@` and `support@` that no single person reads.
- See who runs the mailbox: Gmail, Google Workspace, Microsoft 365, Outlook.com, Proton, Zoho, and nearly 40 more.
- Separate business addresses from free consumer ones like Gmail and Yahoo.
- See each domain's SPF and DMARC setup — a quick read on how well a company runs its email.
- Add public profile photos as proof a real person is behind an address.
- Check the emails a lead scraper just collected, straight from its dataset.

### Who uses it

- **Sales teams** cleaning cold-outreach lists before a sequence goes out.
- **Marketers** keeping newsletter and CRM lists free of dead and junk addresses.
- **Product teams** screening signups for throwaway and mistyped addresses.
- **Growth and data teams** cleaning leads collected with other Apify Actors.

### How to use it

1. Paste your email addresses — one per line. Names, angle brackets, and duplicates are cleaned up for you. Or pick a dataset from another run under **Check emails from another run**, and clear the sample addresses if you only want the dataset's emails checked.
2. Click **Start**.
3. Download your results as JSON, CSV, or Excel.

### Input example

```json
{
  "emails": ["jane.doe@gmail.com", "info@microsoft.com", "test@mailinator.com", "jane@gmial.com"],
  "checkGravatar": false
}
```

To check the emails another Actor collected, pass its dataset instead of (or as well as) a pasted list. `emailField` is the field that holds the addresses; a field that holds a list of addresses works too.

```json
{
  "inputDatasetId": "<DATASET_ID>",
  "emailField": "email"
}
```

### What you get

One row per address, ready to filter in a spreadsheet:

| email | status | score | reason | mailProvider | didYouMean |
|---|---|---|---|---|---|
| jane.doe@gmail.com | valid | 90 | Domain accepts mail (Gmail) | Gmail | |
| info@microsoft.com | risky | 60 | Shared team address, not a person | Microsoft 365 | |
| jane@gmial.com | risky | 45 | Domain looks like a typo — did you mean jane@gmail.com? | | jane@gmail.com |
| test@mailinator.com | risky | 20 | Disposable, throwaway address | Mailinator | |
| jane@no-such-domain-x9.com | invalid | 0 | Domain does not exist | | |
| nobody@example.com | invalid | 0 | Domain does not accept email | | |

```json
{
  "email": "jane.doe@gmail.com",
  "status": "valid",
  "isValid": true,
  "score": 90,
  "reason": "Domain accepts mail (Gmail)",
  "username": "jane.doe",
  "domain": "gmail.com",
  "hasMxRecords": true,
  "mxRecords": ["gmail-smtp-in.l.google.com", "alt1.gmail-smtp-in.l.google.com"],
  "mailProvider": "Gmail",
  "isFreeProvider": true,
  "isDisposable": false,
  "isRoleAccount": false,
  "hasSpf": true,
  "hasDmarc": true,
  "dmarcPolicy": "none",
  "checkedAt": "2026-10-25T10:00:00.000Z"
}
```

The Output tab has two ready-made tables: **Overview** for the verdicts, and **Domain health** for mail servers, SPF, and DMARC.

### What each status means

| Status | What it means | What to do |
|---|---|---|
| **valid** | The domain is real, accepts mail, and the address passes every risk check. | Keep it. |
| **risky** | The domain accepts mail, but the address shows a warning sign: a likely typo, a throwaway domain, a shared inbox, or no dedicated mail server. The `reason` says which. | Fix typos with `didYouMean`, drop throwaway addresses, and decide whether shared inboxes suit your campaign. |
| **invalid** | The domain doesn't exist or doesn't accept email. | Remove it. |

### Lines we couldn't check

Header rows like `email`, malformed addresses, and addresses whose domain didn't answer get no row in your results, so a blank never sits next to a real answer. Each one is listed with its reason in the **FAILED_EMAILS** record (the **Lines we couldn't check** link in the Output tab), and none of them are charged. The run's status message sums it all up: how many addresses were valid, risky, and invalid, and how many lines were skipped.

### Integrations

- **Chain it after any lead scraper.** Pick the scraper's dataset under **Emails from a dataset**, or start this Actor automatically when the scraper finishes with an Apify Actor-to-Actor integration.
- **Send results anywhere.** Push them to Google Sheets, Zapier, Make, n8n, Slack, or any webhook with Apify integrations.
- **Export in any format.** JSON, CSV, Excel, XML, or HTML.

### Use it as an email validation API

Call it from your own code and get the verdicts back as JSON. In Python, with the Apify client (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("vero-api/email-validator").call(run_input={
    "emails": ["jane.doe@gmail.com", "jane@gmial.com"],
})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["email"], item["status"], item["reason"])
```

Or get the results in a single HTTP call:

```bash
curl -X POST "https://api.apify.com/v2/acts/vero-api~email-validator/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"emails": ["jane.doe@gmail.com", "jane@gmial.com"]}'
```

Your token is under **Settings → API & Integrations** in Apify Console.

### Use it from your AI assistant (MCP)

Ask Claude, Cursor, VS Code, or any assistant that supports MCP to check addresses in plain words. Add this server to its MCP settings:

```json
{
  "mcpServers": {
    "email-validator": {
      "url": "https://mcp.apify.com?tools=vero-api/email-validator"
    }
  }
}
```

Then just ask, for example:

- *"Which of these signup emails are throwaway addresses?"*
- *"Clean this list and tell me which addresses have typos."*
- *"Which of these company domains have DMARC set to reject?"*

### Pricing

You pay only for the addresses you check — no subscriptions, no surprises. Every check is included in that one price: typos, disposable and shared-inbox flags, mail provider, SPF and DMARC, and profile photos. Duplicates, lines that aren't email addresses, and addresses whose domain didn't answer are never charged.

### FAQ

**What does "valid" mean?** The domain is real, accepts mail, and the address passes every risk check: no typo, no throwaway domain, no shared inbox. Every check runs at the domain level, so it finishes in seconds and never contacts the mailbox — the fastest way to strip dead and junk addresses from a list.

**Does anything get sent to the addresses?** No. Every check is read-only, so your sending reputation stays untouched and nobody receives a test message.

**How fast is it?** A list of a thousand addresses finishes in about two minutes.

**What does the score mean?** 90 is a clean address on a domain that accepts mail, and a public profile photo (when you turn that check on) lifts it to 100. Anything at 60 or below is worth a second look — the `reason` field tells you exactly why.

**Can I filter out free Gmail and Yahoo addresses?** Yes. Sort or filter on `isFreeProvider` to keep only business domains.

**Can I check the emails a lead scraper collected?** Yes. Pick the scraper's run dataset under **Emails from a dataset** and set **Email field** to the field that holds the addresses. Pasted addresses and dataset addresses can be combined in one run, and duplicates count once.

**What happens to header rows and lines that aren't email addresses?** They're skipped, listed in the `FAILED_EMAILS` record with the reason for each, and never charged.

**What do SPF and DMARC tell me?** SPF lists the servers allowed to send mail for a domain, and DMARC tells inboxes what to do with mail that fails that check. A business domain with both in place — especially DMARC at `quarantine` or `reject` — runs its email properly.

**Can I cap what a run costs?** Yes. Set a spending limit on the run: it stops cleanly when the limit is reached and tells you so in the status message.

**Do I need an API key for anything?** No. Paste your addresses and run it — there is nothing to sign up for.

**Can I call it from my app?** Yes — start a run through the Apify API and read the results from its dataset. See [Use it as an email validation API](#use-it-as-an-email-validation-api) above.

### More tools from us

- [DNS Tools](https://apify.com/vero-api/dns-tools) — WHOIS, domain age, and DNS records for any list of domains.
- [Phone Number Carrier Lookup](https://apify.com/vero-api/phone-carrier-lookup) — carrier, line type, country, and time zone for phone numbers.
- [WhatsApp Number Checker](https://apify.com/vero-api/whatsapp-number-checker) — find out which numbers in your list have WhatsApp.
- [WhatsApp Profile Scraper](https://apify.com/vero-api/whatsapp-scraper) — profile picture, about text, and business details for phone numbers.
- [Telegram Username Checker](https://apify.com/vero-api/telegram-username-checker) — profiles, channels, groups, and bots by username.

# Actor input Schema

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

The email addresses to check, one per line. Paste them straight from a spreadsheet or CSV: names, angle brackets and duplicates are cleaned up for you, and header lines like "email" are skipped free of charge.

## `checkGravatar` (type: `boolean`):

Turn on to check each address for a public Gravatar profile photo. A public photo is strong evidence a real person uses the address, and lifts a clean address's score from 90 to 100.

## `inputDatasetId` (type: `string`):

Pick a dataset from another run, such as a lead scraper's results, to check every email address in it. Works on its own or together with the addresses above. To check only this dataset, clear the sample addresses above.

## `emailField` (type: `string`):

The field in that dataset that holds the email addresses, such as email or emails. A field that holds a list of addresses works too. Use a top-level field, not a nested one like contact.email.

## Actor input object example

```json
{
  "emails": [
    "jane.doe@gmail.com",
    "jane@gmial.com"
  ],
  "checkGravatar": false,
  "emailField": "email"
}
```

# Actor output Schema

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

One row per email address: status (valid, risky or invalid), score, reason, didYouMean, mailProvider, isDisposable, isRoleAccount, isFreeProvider, SPF and DMARC.

## `failed` (type: `string`):

Lines that weren't valid email addresses, and addresses whose domain didn't answer, each with its reason. Never charged.

# 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": [
        "jane.doe@gmail.com",
        "info@microsoft.com",
        "test@mailinator.com",
        "jane@gmial.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vero-api/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 = { "emails": [
        "jane.doe@gmail.com",
        "info@microsoft.com",
        "test@mailinator.com",
        "jane@gmial.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("vero-api/email-validator").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": [
    "jane.doe@gmail.com",
    "info@microsoft.com",
    "test@mailinator.com",
    "jane@gmial.com"
  ]
}' |
apify call vero-api/email-validator --silent --output-dataset

```

## MCP server setup

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

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/MVb5t9JT7901db5dN/builds/W3BNPUQ9c5EVJSLTA/openapi.json