# ✅ Email Verifier - Bulk MX, Syntax & Disposable Check (`renzomacar/email-verifier`) Actor

Bulk email verifier with no API key: RFC syntax, live DNS MX record + provider (Google/Microsoft...), disposable-domain and role-based detection, free-provider flag, and a 0-100 deliverability score. Clean your lead list and cut bounces before cold outreach. Keyless ZeroBounce alternative.

- **URL**: https://apify.com/renzomacar/email-verifier.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.86 / 1,000 email verifieds

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

## ✅ Bulk Email Verifier — Clean Your List Before You Send

Paste any list of email addresses and get back each one labeled `valid` / `risky` / `invalid` with a 0–100 deliverability score — RFC syntax, live DNS MX lookup, mailbox provider, disposable/role/free detection. Made for anyone about to run cold outreach or import a list into a CRM/ESP.
**Pricing: $0.002 per email verified** (a 10,000-address list ≈ $20). No API key, no signup with a verification service.

### What every field tells you

| Field | Signal |
|---|---|
| `syntaxValid` | Pragmatic RFC validation — catches `john@@stripe`, leading/trailing dots, length violations. |
| `hasMx` | Live **DNS MX record** on the domain (Node's native resolver), with RFC 5321 A-record fallback flagged as weaker. |
| `mxProvider` | Who runs the mailbox: Google Workspace, Microsoft 365, Zoho, Proofpoint, Mimecast, GoDaddy, Amazon SES, Yahoo, Yandex, Proton, transactional ESPs and more. |
| `isDisposable` | Known throwaway/temp-mail domain (Mailinator, Guerrilla Mail, YOPmail, ~100 more). |
| `isRoleBased` | Alias, not a person: `info@`, `support@`, `sales@`, `noreply@`… Higher bounce/complaint risk. |
| `isFreeProvider` | Consumer inbox (gmail.com, yahoo.com, outlook.com…) — deliverable but usually not a B2B contact. |
| `status` | Roll-up: **valid** / **risky** / **invalid**, or **unknown** when DNS did not answer after a retry. An `unknown` row is returned and not charged. |
| `score` | 0–100 deliverability score. Sort your entire list by this column. |
| `reason` | Machine-readable cause: `no-mx-record`, `disposable-domain`, `role-based`, `ok`… |

### 🎥 Video walkthrough

https://youtu.be/t2AcrC6mQ5c

### Email verifier without an API key: bulk MX, syntax & disposable checks

Most bulk email verification tools (ZeroBounce, NeverBounce, Hunter's verifier) put the same checks behind an account, credits and an API key. This Actor runs them keyless directly from Apify: you paste the list (or POST it via API), it queries DNS itself, and the disposable/role/free lists ship bundled. Nothing to sign up for, and at $0.002/check it's priced below typical per-credit rates — you keep the output dataset in JSON/CSV/Excel.

Long-tail jobs it covers: verify email addresses in bulk before a cold campaign, check MX records for a list of domains, detect disposable emails in sign-ups, clean a purchased list, split B2B vs consumer addresses.

#### Why cleaning matters

Mailbox providers watch your bounce rate and spam-trap hits. Sending to dead, fake or throwaway addresses gets your *good* mail junked. The pipeline that works:

1. Collect (scraped, exported, purchased — however you got the list).
2. **Verify here** → keep `valid`, review `risky`, drop `invalid`.
3. Send through your ESP with a protected sender reputation.

### Input → Output

```json
{
  "emails": ["john@stripe.com", "test@mailinator.com", "info@notion.so"],
  "maxConcurrency": 5
}
```

`emails` is required; `maxConcurrency` (1–25, default 5) sets parallelism. The input list is de-duplicated case-insensitively before verification.

```json
{
  "email": "test@mailinator.com",
  "syntaxValid": true,
  "hasMx": false,
  "mxProvider": null,
  "isDisposable": true,
  "isRoleBased": false,
  "isFreeProvider": false,
  "status": "invalid",
  "score": 5,
  "reason": "disposable-domain",
  "checkedAt": "2026-07-02T00:00:00.000Z"
}
```

The dataset ships with a ready table view and exports to CSV, JSON, Excel or the API.

### Straight talk: MX + heuristics, not SMTP pings

We deliberately do **not** claim to "ping the mailbox" over SMTP — and you should distrust cloud services that do. Outbound port 25 is blocked or throttled by cloud providers; greylisting corrupts results; catch-all domains answer "yes" to every address; aggressive probing gets IPs blacklisted. Syntax + live MX + disposable/role/free heuristics catch the overwhelming majority of bad addresses (typos, dead domains, throwaways) with zero pretend-certainty. `risky` is the honest label for "deliverable domain — check the mailbox yourself before a high-stakes send."

### FAQ

**How do I verify email addresses in bulk without an API key?**
Paste the list into this Actor's input (or POST it via the Apify API) and run. DNS is queried directly and all detection lists are bundled — there is no third-party service or key involved.

**Does it do a real SMTP mailbox check?**
No, by design — see above. No cloud tool can do that reliably or honestly.

**Can it prove an address definitely exists?**
No (catch-all domains accept everything). It proves the domain can receive mail and flags everything that makes an address fake or low-quality.

**Should I email the `risky` ones?**
Deliverable domain but lower-quality target — a role alias, free consumer inbox, or A-record-only domain. Fine for some sends; review before high-stakes outreach.

**How much does 10,000 emails cost and how long does it take?**
About $20 at $0.002 each. Checks run in parallel (default 5, up to 25) — thousands of addresses complete in minutes.

**Will it lower my bounce rate?**
It removes the addresses that cause hard bounces (bad syntax, no MX, disposable domains) before you send — the main drivers of bounce-rate damage. What remains depends on your list source.

**Can I automate re-verification?**
Yes — schedule the Actor in Apify Console, or chain it: [Website Contact Finder](https://apify.com/renzomacar/website-contact-finder) → this verifier → export `valid` rows to your outreach tool. Results pipe to Sheets, Slack, Zapier, Make or a webhook.

**What about emails my [Email Finder](https://apify.com/renzomacar/email-finder) guessed?**
That's the intended pipeline: feed its `bestEmail` column here for the full deliverability read before sending.

# Actor input Schema

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

One email address per line. Each is checked for syntax, a live DNS MX record (with provider classification), disposable/throwaway domains, role-based mailboxes (info@, support@…) and free consumer providers (gmail.com…). One clean record is returned per email. No live-SMTP probing (see the README for why).

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

How many emails to verify in parallel. Higher = faster on big lists; the default is a friendly value for public DNS resolvers.

## Actor input object example

```json
{
  "emails": [
    "john@stripe.com",
    "test@mailinator.com",
    "info@notion.so"
  ],
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Rows produced by Email Verifier, one item per result in the default dataset.

# 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@stripe.com",
        "test@mailinator.com",
        "info@notion.so"
    ],
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/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@stripe.com",
        "test@mailinator.com",
        "info@notion.so",
    ],
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/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@stripe.com",
    "test@mailinator.com",
    "info@notion.so"
  ],
  "maxConcurrency": 5
}' |
apify call renzomacar/email-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,renzomacar/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/oB9weNZCGEfAmqugh/builds/qCrddV9Z8CHRvC5Pk/openapi.json