# Clean Email Verifier (`corner_cutter/clean-email-verifier`) Actor

Professional email validation tool that checks deliverability and identifies risky or invalid addresses. Validate bulk email lists with detailed status reports. Ideal for lead validation, CRM cleaning, and email marketing campaigns.

- **URL**: https://apify.com/corner\_cutter/clean-email-verifier.md
- **Developed by:** [ReactRuby](https://apify.com/corner_cutter) (community)
- **Categories:** Developer tools
- **Stats:** 81 total users, 8 monthly users, 100.0% runs succeeded, 6 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.60 / 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?

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

## Clean Email Verifier

Clean Email Verifier is a **real-time email verification API** that checks whether an email address is valid and safe to send to. Paste a list of addresses and get back a clear, per-email result — deliverable, risky, or invalid — plus disposable, role, free-provider and catch-all signals and a typo suggestion, all in seconds.

Use it to **clean email lists, protect your sender reputation, cut bounce rates, and block fake sign-ups** before they ever reach your database.

### What does Clean Email Verifier do?

For every email address you provide, the Actor performs a live check — syntax, domain, MX records and mailbox — and returns a structured result:

- ✅ **Deliverable** — the mailbox exists and can receive email (`result: ok`).
- ⚠️ **Risky** — the address may accept mail but carries risk, e.g. **catch-all** domains, **disposable** addresses, or an **unknown** mailbox state.
- ❌ **Invalid** — the address is malformed, the domain has no mail server, or the mailbox does not exist.

It also tells you whether an address is a **free** provider (Gmail, Yahoo…), a **role** address (`info@`, `sales@`, `admin@`), and offers a **"did you mean"** correction for common typos such as `gmal.com → gmail.com`.

### Why use Clean Email Verifier?

- **Reduce bounces & protect deliverability** — remove invalid addresses before you send, keeping your bounce rate low and your domain reputation healthy.
- **Stop fake sign-ups** — reject disposable and invalid emails at registration.
- **Real-time results** — each address is verified live in about a second, not queued for hours.
- **Rich signals, not just yes/no** — catch-all, disposable, role, free and typo detection let you make smarter decisions.
- **Bulk-friendly** — verify one address or thousands of them in a single run.
- **Runs anywhere on Apify** — schedule it, call it from the API, chain it into workflows, or trigger it from Make, Zapier and n8n.

### What data do you get for each email?

Every verified address is stored as one row in the dataset:

| Field        | Type    | Description                                                                                             |
| ------------ | ------- | ------------------------------------------------------------------------------------------------------- |
| `email`      | string  | The email address that was checked.                                                                     |
| `result`     | string  | Verification outcome: `ok`, `catch_all`, `unknown`, `disposable`, `invalid`, or `error`.                |
| `resultcode` | integer | Numeric form of `result`: `1` ok, `2` catch\_all, `3` unknown, `4` error, `5` disposable, `6` invalid.   |
| `quality`    | string  | Simple quality grade: `good`, `risky`, or `bad`.                                                        |
| `subresult`  | string  | Technical detail behind the result, e.g. `ok`, `no_mailbox`, `dns_no_mx`, `mailbox_full`, `greylisted`. |
| `free`       | boolean | `true` if the domain is a free email provider (Gmail, Yahoo, Outlook…).                                 |
| `role`       | boolean | `true` if the address is a role/team inbox (`info@`, `support@`, `admin@`).                             |
| `didyoumean` | string  | Suggested correction for a likely typo, or empty if none.                                               |
| `error`      | string  | Error message when `result` is `error`, otherwise empty.                                                |

### How to verify emails

1. Open the Actor and go to the **Input** tab.
2. Add the email addresses you want to check into the **Email addresses** field — one per line.
3. (Optional) Open **Advanced settings** to change the per-address **timeout**.
4. Click **Start**.
5. Watch the live log as each address is verified, then open the **Output** tab (or **Storage → Dataset**) to see the results.
6. Export the results as **JSON, CSV, Excel or HTML**, or fetch them from the Apify API.

### How much does it cost?

Cost scales with how many addresses you verify. A single address is verified in roughly a second, so runs are fast and compute usage is minimal — the main cost driver is the number of emails on your list, not the run time. Verify a handful of addresses for a fraction of a cent, or clean lists of thousands in a single run. See the **Pricing** section on the Actor's Store page for the exact model.

### Input

Configure everything on the **Input** tab. See the input schema for all options.

| Field     | Type             | Default            | Description                                                                                  |
| --------- | ---------------- | ------------------ | -------------------------------------------------------------------------------------------- |
| `emails`  | array of strings | 3 sample addresses | The addresses to verify, one per line. Duplicates and blank lines are ignored. **Required.** |
| `timeout` | integer          | `60`               | Seconds to wait for the recipient mail server per address (2–60).                            |

#### Example input

```json
{
    "emails": ["karbontechstore@gmail.com", "test@gmail.com", "salim@karbon-tech.store"],
    "timeout": 20
}
```

### Output

Results are saved to the run's **dataset**, one item per email, and you can download them as JSON, CSV, Excel or HTML. Each item holds the verification result for one address.

```json
[
    {
        "email": "karbontechstore@gmail.com",
        "quality": "good",
        "result": "ok",
        "resultcode": 1,
        "subresult": "ok",
        "free": true,
        "role": false,
        "didyoumean": "",
        "error": ""
    },
    {
        "email": "someone@gmal.com",
        "quality": "bad",
        "result": "invalid",
        "resultcode": 6,
        "subresult": "bad_domain",
        "free": false,
        "role": false,
        "didyoumean": "someone@gmail.com",
        "error": ""
    }
]
```

A run **`SUMMARY`** is also written to the default key-value store, with totals broken down by `result` and `quality` and the remaining credit balance.

### Result reference

**Result codes**

| Code | Result       | Meaning                                                                   |
| ---- | ------------ | ------------------------------------------------------------------------- |
| `1`  | `ok`         | Valid, existing mailbox — safe to send.                                   |
| `2`  | `catch_all`  | Domain accepts all addresses; individual mailbox can't be confirmed.      |
| `3`  | `unknown`    | The mail server did not give a definitive answer (greylisting, timeout…). |
| `4`  | `error`      | The address could not be checked — see the `error` field.                 |
| `5`  | `disposable` | Temporary/throwaway address.                                              |
| `6`  | `invalid`    | Malformed address, dead domain, or non-existent mailbox.                  |

**Quality grades**

- `good` — safe to send.
- `risky` — send with caution (catch-all, unknown, disposable).
- `bad` — do not send.

### Integrate with the Apify API

Run the Actor from your own code and read back the results.

#### JavaScript / Node.js

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

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

const run = await client.actor('YOUR_USERNAME/clean-email-verifier').call({
    emails: ['john@example.com', 'sales@company.com', 'typo@gmal.com'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`${item.email}: ${item.result} (${item.quality})`);
}

// Keep only the addresses that are safe to send to.
const deliverable = items.filter((i) => i.result === 'ok').map((i) => i.email);
console.log('Deliverable:', deliverable);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~clean-email-verifier/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "emails": ["john@example.com", "sales@company.com"] }'
```

### Tips

- **Slow domains** — increase the **timeout** (up to 60s) so slow mail servers are given more time before being marked `unknown`.
- **Act on the signals** — treat `ok` as safe, drop `invalid` and `disposable`, and decide per campaign how to handle `catch_all` and `unknown`.
- **Fix typos automatically** — when `didyoumean` is set, offer the correction back to the user at sign-up.

### FAQ

**Do I need an API key or any external account to run this?**
No. Just add your email addresses and click Start — everything is handled for you.

**Can it verify a single email?**
Yes — add a single address. The Actor works for one email or thousands.

**Why did an address come back as `catch_all` or `unknown`?**
Some mail servers accept every address (`catch_all`) or refuse to confirm a mailbox (`unknown`, e.g. greylisting). These are graded `risky` — verify importance before sending.

**In what formats can I download the results?**
JSON, CSV, Excel and HTML from the Output tab, or via the Apify dataset API.

### Disclaimers & support

Only verify email addresses you have a legitimate reason to process. Email addresses are personal data protected by the GDPR in the European Union and by other regulations worldwide — make sure your use complies with applicable law. This Actor performs deliverability checks only and does not send email to the addresses it verifies.

Found a bug or have a feature request? Open a ticket on the **Issues** tab, and see the **API** tab for programmatic access.

# Actor input Schema

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

The email addresses you want to verify. Add one address per line. Duplicates and blank lines are ignored.

## `timeout` (type: `integer`):

How long to wait for the recipient mail server to respond before giving up on a single address. Allowed range is 2–60 seconds.

## Actor input object example

```json
{
  "emails": [
    "karbontechstore@gmail.com",
    "test@gmail.com",
    "salim@karbon-tech.store"
  ],
  "timeout": 60
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `overview` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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": [
        "karbontechstore@gmail.com",
        "test@gmail.com",
        "salim@karbon-tech.store"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("corner_cutter/clean-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": [
        "karbontechstore@gmail.com",
        "test@gmail.com",
        "salim@karbon-tech.store",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("corner_cutter/clean-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": [
    "karbontechstore@gmail.com",
    "test@gmail.com",
    "salim@karbon-tech.store"
  ]
}' |
apify call corner_cutter/clean-email-verifier --silent --output-dataset

```

## MCP server setup

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