# Superclean Emails (`superlativetech/superclean-emails`) Actor

Validate and clean email addresses from lead lists. Fix domain typos (gmial.com → gmail.com), detect disposable addresses, flag free providers (Gmail, Yahoo), verify MX records. No external API needed. Bulk or instant Standby API. For CRM cleanup, cold email, and bounce prevention.

- **URL**: https://apify.com/superlativetech/superclean-emails.md
- **Developed by:** [Superlative](https://apify.com/superlativetech) (community)
- **Categories:** Automation, Lead generation, Open source
- **Stats:** 13 total users, 2 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Superclean Emails

Validate and clean email addresses from lead exports, CRM records, and web scraping.

### What does Superclean Emails do?

Superclean Emails validates email addresses and detects common problems using rule-based checks (no AI/LLM required).

- **Validates syntax** — RFC 5322 compliant email format checking
- **Strips scraping artifacts** — Removes URL-encoded residue like `%20`, `%0A` before validation
- **Fixes domain typos** — "gmial.com" becomes "gmail.com", "yahooo.com" becomes "yahoo.com"
- **Detects disposable emails** — Flags temporary/throwaway providers like Mailinator and Guerrilla Mail
- **Flags free providers** — Identifies Gmail, Yahoo, Hotmail, Outlook, ProtonMail, Libero, Web.de, Orange.fr, and 80+ others
- **Verifies MX records** — Confirms the domain can actually receive email via DNS lookup
- **[Instant API mode](#standby-mode-instant-api)** — Sub-second single-email validation via Standby HTTP server

### Use with AI Agents

Available as an MCP tool via the [Apify MCP Server](https://mcp.apify.com).

| Property | Value |
| --- | --- |
| Actor ID | `superlativetech/superclean-emails` |
| Standby URL | `https://superlativetech--superclean-emails.apify.actor` |
| Input | `items` (string\[]) or `item` (string) |
| Output | `{id, input, output, isValid, domain, hasMx, isDisposable, isFreeProvider, suggestedFix, confidence}` per item |
| Pricing | Free — you only pay standard Apify platform usage |
| Idempotent | Yes — same input always produces same output |

#### Output schema

```json
{ "id": 1, "input": "USER@GMIAL.COM", "output": "user@gmail.com", "isValid": true, "domain": "gmail.com", "hasMx": true, "isDisposable": false, "isFreeProvider": true, "suggestedFix": "gmial.com → gmail.com", "confidence": 0.85 }
```

#### Pipeline composability

This actor works in data cleaning pipelines:

1. **Scrape** → 2. **Clean** (this actor) → 3. **Enrich** (DNS/WHOIS) → 4. **Score** (ICP Scorer)

#### Standby (instant API)

```
GET https://superlativetech--superclean-emails.apify.actor?token=TOKEN&input=user@gmail.com
```

### What else can Superclean do?

If you're cleaning lead data, you might also need:

- **[Superclean Company Names](https://apify.com/superlativetech/superclean-company-names?fpr=8e9l1)** — Clean messy company names for cold emails and CRM
- **[Superclean Person Names](https://apify.com/superlativetech/superclean-person-names?fpr=8e9l1)** — Clean person names for cold email personalization
- **[Superclean Job Titles](https://apify.com/superlativetech/superclean-job-titles?fpr=8e9l1)** — Normalize job titles for lead scoring and personalization
- **[Superclean Product Names](https://apify.com/superlativetech/superclean-product-names?fpr=8e9l1)** — Clean product names from e-commerce data
- **[Superclean Places](https://apify.com/superlativetech/superclean-places?fpr=8e9l1)** — Parse and normalize location data from lead exports
- **[Superclean URLs](https://apify.com/superlativetech/superclean-urls?fpr=8e9l1)** — Clean and normalize URLs from lead data
- **[Superclean Phone Numbers](https://apify.com/superlativetech/superclean-phone-numbers?fpr=8e9l1)** — Format and validate phone numbers
- **[Superlead ICP Scorer](https://apify.com/superlativetech/superlead-icp-scorer?fpr=8e9l1)** — Score leads against your Ideal Customer Profile with AI

### Why validate email addresses?

Your lead data comes from many sources with email quality problems:

- "USER@GMIAL.COM" — domain typo, wrong casing
- "test@mailinator.com" — disposable throwaway address
- "contact@defunct-company.xyz" — domain has no MX records
- "  jane@gmail.com  " — extra whitespace

Clean emails mean better:

- **Deliverability** — Catch typos and dead domains before sending
- **Bounce prevention** — Verify MX records to avoid hard bounces
- **Lead quality** — Filter disposable and temporary addresses
- **B2B targeting** — Separate business emails from free provider addresses

### How to use Superclean Emails

1. Paste your email addresses into the input field (one per line)
2. Click **Start** and download your validated results

Each email is checked for syntax, domain typos, disposable providers, free providers, and MX records — all automatically.

### Standby mode (instant API)

Standby mode keeps a warm container running so you get instant email validation without cold-start delays. Instead of starting a full Actor run, you make a simple HTTP GET request and get results in milliseconds.

This is ideal for:

- **Clay enrichment steps** — single-email validation inline
- **Make / n8n HTTP modules** — real-time email checking in workflows
- **MCP agents** — AI tools that need instant email validation

#### Standby URL

```
https://superlativetech--superclean-emails.apify.actor?token=YOUR_API_TOKEN
```

Or use a Bearer token in the `Authorization` header instead of the `token` query parameter.

#### Validate an email

```bash
curl "https://superlativetech--superclean-emails.apify.actor?token=YOUR_API_TOKEN&input=user@gmail.com"
```

#### Detect a typo

```bash
curl "https://superlativetech--superclean-emails.apify.actor?token=YOUR_API_TOKEN&input=user@gmial.com"
```

#### Query parameters

| Parameter | Required | Description |
| --- | --- | --- |
| `input` | Yes | Email address to validate |

#### Response format

```json
{
  "id": 1,
  "input": "user@gmial.com",
  "output": "user@gmail.com",
  "isValid": true,
  "domain": "gmail.com",
  "hasMx": true,
  "isDisposable": false,
  "isFreeProvider": true,
  "suggestedFix": "gmial.com → gmail.com",
  "confidence": 0.85
}
```

#### Error responses

| Code | Cause |
| --- | --- |
| 400 | Missing `input` parameter |
| 405 | Non-GET request |
| 500 | Unexpected server error |

### What gets checked?

#### Syntax validation

- RFC 5322 format: `local@domain.tld`
- Rejects missing @, double @, spaces, missing domain or TLD

#### Domain typo detection

- gmial.com, gmai.com, gamil.com, gnail.com → gmail.com
- yahooo.com, yaho.com, yhoo.com → yahoo.com
- hotmial.com, hotmal.com, hotamil.com → hotmail.com
- outlok.com, outllook.com, outlool.com → outlook.com
- protonmal.com, protonmial.com → protonmail.com
- icloud.co, icoud.com → icloud.com

#### Disposable domain detection

Flags 3,000+ known disposable/temporary email providers including Mailinator, Guerrilla Mail, Temp Mail, and many more. Also detects subdomains of disposable providers.

#### Free provider detection

Identifies 80+ free email providers across 15+ countries: Gmail, Yahoo, Hotmail, Outlook, ProtonMail, iCloud, AOL, Zoho, Yandex, Mail.ru, GMX, Fastmail, Tutanota, Libero.it, Web.de, Orange.fr, WP.pl, Seznam.cz, and regional variants.

#### MX record verification

DNS lookup confirms the domain has mail exchange (MX) records configured. Domains without MX records cannot receive email.

### How many emails can you validate?

There's no limit. Process as many emails as you need — from a handful to hundreds of thousands. The Actor scales automatically.

For best performance, batch your requests. Processing 1,000 emails at once is more efficient than 10 separate runs of 100 emails each.

### How much will it cost you?

This Actor is **free to use** — there are no per-result charges. You only pay for the Apify platform compute your runs consume, which is typically negligible.

### Input parameters

| Parameter | Type | Description |
| --- | --- | --- |
| `items` | array | List of email addresses to validate (one per line in the UI, or JSON array) |
| `item` | string | Single email to validate — API shorthand for integration callers (Clay, Make, n8n). If both `item` and `items` are provided, `item` is prepended to the list |

#### Input example

```json
{
  "items": [
    "user@gmail.com",
    "USER@GMIAL.COM",
    "test@mailinator.com",
    "contact@acme-corp.com",
    "bad-email-no-at-sign",
    "jane@defunct-company.xyz"
  ]
}
```

`items` also accepts objects, which is useful for API and MCP integrations:

```json
{
  "items": [
    { "input": "user@gmail.com" },
    { "input": "test@mailinator.com" }
  ]
}
```

For API and integration callers who want to validate a single email without wrapping it in an array, use the `item` shorthand:

```json
{
  "item": "user@gmail.com"
}
```

### During the Actor run

The Actor processes emails quickly using rule-based validation with DNS lookups for MX verification. You'll see progress updates as items are processed.

If you provide invalid input (e.g., an empty list), the Actor will stop immediately with an error message explaining what went wrong.

Results are available in real-time — you can start downloading validated emails before the full run completes.

### Output format

Results are saved to the default dataset. Each validated email is a separate item.

You can export results as JSON, CSV, Excel, or other formats directly from Apify Console. Or access them programmatically via the API.

#### Output example

```json
[
  {
    "id": 1,
    "input": "user@gmail.com",
    "output": "user@gmail.com",
    "isValid": true,
    "domain": "gmail.com",
    "hasMx": true,
    "isDisposable": false,
    "isFreeProvider": true,
    "suggestedFix": null,
    "confidence": 0.95
  },
  {
    "id": 2,
    "input": "USER@GMIAL.COM",
    "output": "user@gmail.com",
    "isValid": true,
    "domain": "gmail.com",
    "hasMx": true,
    "isDisposable": false,
    "isFreeProvider": true,
    "suggestedFix": "gmial.com → gmail.com",
    "confidence": 0.85
  },
  {
    "id": 3,
    "input": "test@mailinator.com",
    "output": "test@mailinator.com",
    "isValid": true,
    "domain": "mailinator.com",
    "hasMx": true,
    "isDisposable": true,
    "isFreeProvider": false,
    "suggestedFix": null,
    "confidence": 0.95
  }
]
```

| Field | Description |
| --- | --- |
| `id` | Row number (1-based, matches Apify's displayed row numbers) |
| `input` | Original email string before cleaning |
| `output` | Cleaned email string (lowercased, typos corrected) |
| `isValid` | Whether the email has valid RFC 5322 syntax |
| `domain` | Extracted domain part (null if invalid syntax) |
| `hasMx` | Whether the domain has MX records (null if invalid syntax) |
| `isDisposable` | Whether the domain is a known disposable/temporary provider |
| `isFreeProvider` | Whether the domain is a free email provider (Gmail, Yahoo, etc.) |
| `suggestedFix` | Suggested domain correction if a typo was detected (null if no typo) |
| `confidence` | Confidence score from 0 to 1 (lower scores may need manual review) |

#### Confidence scores

Each result includes a confidence score from 0 to 1:

- **0.95** — Valid syntax, MX records confirmed, no corrections needed
- **0.85** — Valid but a domain typo was auto-corrected
- **0.70** — Valid syntax but no MX records found (domain may not receive email)
- **0.30** — Invalid email syntax
- **0** — Empty or null input

### Limitations

- Does not perform SMTP mailbox verification (too slow and risks IP blacklisting)
- Typo detection covers major providers only — niche domain typos may not be caught
- MX lookups depend on DNS availability and may timeout for slow-responding nameservers
- Does not validate whether the specific mailbox exists, only whether the domain accepts email

### Integrations

Superclean Emails works with any tool that can call Apify Actors:

- **Clay** — Add as an enrichment step in your Clay tables
- **Make** — Use the Apify module to run the Actor
- **Zapier** — Trigger runs and retrieve results automatically
- **n8n** — Self-hosted workflow automation

You can also use webhooks to trigger actions when a run completes — for example, send a Slack notification or automatically import results into your CRM.

### Using Superclean Emails with the Apify API

The Apify API gives you programmatic access to run Actors, retrieve results, and manage datasets.

**Node.js:**

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

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

const run = await client.actor('superlativetech/superclean-emails').call({
  items: ['user@gmail.com', 'USER@GMIAL.COM', 'test@mailinator.com']
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('superlativetech/superclean-emails').call(run_input={
    'items': ['user@gmail.com', 'USER@GMIAL.COM', 'test@mailinator.com']
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Check out the [Apify API reference](https://docs.apify.com/api) for full details, or click the **API** tab above for more code examples.

### Your feedback

We're always improving Superclean Actors. If you have feature requests, find a bug, or need help with a specific use case, please open an issue in the Actor's Issues tab.

When Apify asks to share your run data with us, we encourage you to opt in — it's the fastest way for us to spot edge cases and improve results. Sharing is completely optional (you can toggle it anytime under [Account Settings → Privacy](https://console.apify.com/account#/privacy)), and shared runs are automatically deleted by Apify based on your plan's data retention period. We only use shared data to debug issues and improve this Actor.

### Leave a review

If Superclean Emails saves you time or improves your lead data, please leave a review. Your feedback helps other users discover the tool and helps us understand what's working well.

***

Built by Superlative

# Actor input Schema

## `items` (type: `array`):

Array of email addresses to validate (e.g., "user@gmail.com", "jane@company.co")

## `item` (type: `string`):

Single email to validate — shorthand for API/integration callers. If both 'item' and 'items' are provided, 'item' is prepended to the list.

## Actor input object example

```json
{
  "items": [
    "test@gmail.com"
  ]
}
```

# Actor output Schema

## `allResults` (type: `string`):

All validated emails with before/after values, domain analysis, and confidence scores

# 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 = {
    "items": [
        "test@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("superlativetech/superclean-emails").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 = { "items": ["test@gmail.com"] }

# Run the Actor and wait for it to finish
run = client.actor("superlativetech/superclean-emails").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 '{
  "items": [
    "test@gmail.com"
  ]
}' |
apify call superlativetech/superclean-emails --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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