# Bulk Email Verifier & List Cleaner (`fit_melon/bulk-email-verifier-list-cleaner`) Actor

Verify email lists in bulk: syntax check, MX/DNS validation, disposable & role-based detection, typo suggestions, smart deduplication. Clean your list before every campaign — protect your sender reputation and cut your bounce rate. No SMTP pings, no blacklist risk.

- **URL**: https://apify.com/fit\_melon/bulk-email-verifier-list-cleaner.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Bulk Email Verifier & List Cleaner 📧✅

Verify and clean email lists in bulk **before** you hit send. This Actor checks syntax, DNS/MX records, disposable domains, role-based addresses and common typos — then deduplicates everything — so your campaigns land in the inbox instead of burning your sender reputation.

**One clean list in, one scored list out. No SMTP spoofing, no gray-zone tricks — just fast, reliable checks.**

### Why clean your list?

- 📉 **Bounce rates above 2–3% get your domain flagged** by Gmail and Outlook. One dirty campaign can hurt deliverability for months.
- 🗑️ **Disposable addresses** (yopmail, mailinator, temp-mail…) never convert and pollute your CRM.
- 👥 **Role-based addresses** (contact@, info@, support@) trigger spam filters in cold outreach.
- ✍️ **Typos** (gmial.com, hotmial.com…) are silent bounces — this Actor suggests the fix (`didYouMean`).
- 🔁 **Duplicates** (case differences, Gmail dots, +tags) inflate your costs and annoy recipients.

### What it checks

| Check | Description |
|---|---|
| **Syntax** | RFC-compliant validation of the address format |
| **MX / DNS** | Does the domain actually have mail servers? Catches dead domains and typos |
| **Disposable** | 100+ temporary email providers (including French ones: yopmail.fr, jetable.org…) |
| **Role-based** | Generic addresses in English **and French** (contact, info, compta, rh, nepasrepondre…) |
| **Free provider** | Flags gmail.com, orange.fr, free.fr, laposte.net… — useful to segment B2B vs B2C |
| **Typo suggestions** | `marie@gmial.com` → `didYouMean: marie@gmail.com` |
| **Normalization & dedup** | Lowercase, +tag stripping, Gmail dot folding — duplicates are skipped and **never billed** |

### Output

Each email returns one dataset item:

```json
{
    "email": "Jean.Dupont+news@gmail.com",
    "normalizedEmail": "jeandupont@gmail.com",
    "status": "valid",
    "reason": "deliverable_checks_passed",
    "syntaxValid": true,
    "mxFound": true,
    "mxRecords": ["gmail-smtp-in.l.google.com"],
    "domain": "gmail.com",
    "disposable": false,
    "roleBased": false,
    "freeProvider": true,
    "didYouMean": null
}
```

**Statuses:**

- `valid` — safe to send
- `risky` — deliverable but handle with care (disposable domain or role-based address)
- `invalid` — do not send (bad syntax or no mail server)

A run **SUMMARY** (counts + deliverability rate) is stored in the key-value store.

### Input

Paste your list as an array or as raw text (one email per line, or comma/semicolon-separated). You can also pipe another Actor's dataset — objects with an `email` field are accepted as-is.

```json
{
    "emails": ["jean.dupont@gmail.com", "contact@yopmail.com"],
    "checkMxRecords": true,
    "removeDuplicates": true
}
```

### Typical use cases

- Clean a prospect list before a cold email campaign (émailing, prospection B2B)
- Validate sign-up emails and block disposable addresses
- Deduplicate and normalize a CRM export
- Filter role-based addresses out of outreach lists
- Vérification d'emails en masse / nettoyage de liste email / validation email marketing

### 🇫🇷 Works great with our French company data suite

This Actor is part of a toolkit for French business data — find, enrich, verify:

- **[French Legal Notices Scraper](LIEN_ACTEUR_1)** — extract company info (SIREN, owner, contact email) from any French website's mentions légales
- **[French Company Data Enricher](LIEN_ACTEUR_2)** — enrich a SIREN with official government data: directors, address, activity, status

Typical pipeline: scrape contact emails from legal notices → **verify them here** → launch your campaign with a 98% deliverability rate.

### FAQ

**Does it do SMTP verification (mailbox ping)?**
No, by design. SMTP pings are unreliable (most providers block or tarpit them), can get IPs blacklisted, and produce false negatives on catch-all domains. Syntax + MX + reputation lists catch the vast majority of bounces without any of those risks.

**Is my data stored?**
Emails are processed in memory and written only to **your** dataset, in your Apify account. Nothing is shared or retained by the Actor.

**How fast is it?**
DNS results are cached per domain, so a 10,000-email list with a few hundred distinct domains runs in a couple of minutes.

### 🔗 Works well with

Build a complete French B2B data pipeline with the other Actors in this collection:

- **[New French Companies Finder (SIRENE)](https://apify.com/fit_melon/new-french-companies-finder-sirene)** — find newly registered companies, then verify the contact emails you collect for them here.
- **[French Company Data Enricher (SIREN)](https://apify.com/fit_melon/french-company-data-enricher-siren-dirigeants-sirene)** — enrich a SIREN/SIRET with legal data and directors; pair with this Actor to keep the outreach list clean.
- **[French Legal Notices Scraper](https://apify.com/fit_melon/french-legal-notices-scraper-mentions-legales)** — pull legal / `mentions légales` pages (a common source of contact emails worth verifying before use).
- **[EU VAT Number Validator (VIES)](https://apify.com/fit_melon/eu-vat-number-validator-vies)** — validate VAT numbers for the same accounts you're emailing.

Typical flow: **Find** companies → **Enrich** them → **Verify** the emails (you are here) → send. Each step is a separate Actor, so you only pay for what you use.

# Actor input Schema

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

List of email addresses to verify. Each item can be a plain string or an object with an `email` field (handy when piping data from another Actor's dataset).

## `emailsText` (type: `string`):

Alternative input: paste emails separated by new lines, commas or semicolons. Merged with the list above.

## `checkMxRecords` (type: `boolean`):

Verify that the email's domain has mail servers (MX records). Strongly recommended — this is what catches dead domains and typos.

## `flagRoleBased` (type: `boolean`):

Mark generic addresses (contact@, info@, support@…) as `risky`. They hurt deliverability in cold outreach. Disable if role addresses are your actual targets.

## `removeDuplicates` (type: `boolean`):

Deduplicate on the normalized form (case-insensitive, +tags stripped, Gmail dots ignored). Duplicates are skipped and never billed.

## `outputInvalid` (type: `boolean`):

Keep invalid emails in the dataset (with the reason). Disable to get a clean, ready-to-import list only.

## `concurrency` (type: `integer`):

Number of parallel DNS checks (1–50).

## `mxTimeoutMs` (type: `integer`):

Timeout per DNS lookup in milliseconds.

## Actor input object example

```json
{
  "emails": [
    "jean.dupont@gmail.com",
    "Jean.Dupont+newsletter@gmail.com",
    "contact@orange.fr",
    "test@yopmail.com",
    "marie@gmial.com",
    "not-an-email",
    "sophie@domaine-inexistant-xyz-98765.fr"
  ],
  "checkMxRecords": true,
  "flagRoleBased": true,
  "removeDuplicates": true,
  "outputInvalid": true,
  "concurrency": 10,
  "mxTimeoutMs": 5000
}
```

# 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": [
        "jean.dupont@gmail.com",
        "Jean.Dupont+newsletter@gmail.com",
        "contact@orange.fr",
        "test@yopmail.com",
        "marie@gmial.com",
        "not-an-email",
        "sophie@domaine-inexistant-xyz-98765.fr"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/bulk-email-verifier-list-cleaner").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": [
        "jean.dupont@gmail.com",
        "Jean.Dupont+newsletter@gmail.com",
        "contact@orange.fr",
        "test@yopmail.com",
        "marie@gmial.com",
        "not-an-email",
        "sophie@domaine-inexistant-xyz-98765.fr",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/bulk-email-verifier-list-cleaner").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 '{
  "emails": [
    "jean.dupont@gmail.com",
    "Jean.Dupont+newsletter@gmail.com",
    "contact@orange.fr",
    "test@yopmail.com",
    "marie@gmial.com",
    "not-an-email",
    "sophie@domaine-inexistant-xyz-98765.fr"
  ]
}' |
apify call fit_melon/bulk-email-verifier-list-cleaner --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Fv2IDs4JcFRcNn3Hf/builds/lDdte5H6s9cNR8ChZ/openapi.json