# Email Address Validator — ZeroBounce Alternative (`khadinakbar/zerobounce-alternative`) Actor

Validate email addresses with syntax, MX, disposable-domain, role-account, typo, and optional SMTP signals. Export per-address results and scores for list hygiene, with the selected verification tier and limits made explicit.

- **URL**: https://apify.com/khadinakbar/zerobounce-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 email validateds

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

## Email Address Validator — ZeroBounce Alternative

Validate email addresses with syntax, MX, disposable-domain, role-account, typo, and optional SMTP signals. Export per-address results and scores for list hygiene, with the selected verification tier and limits made explicit. For list-hygiene teams, each dataset row represents one normalized email address with its selected verification signals.

### Workflow: put the results to work

Submit complete addresses and choose the verification tier appropriate to your list. Review syntax and DNS findings separately from optional SMTP signals, then route uncertain results for further checks. A successful syntax or MX check alone does not establish mailbox deliverability.

### Best fit and connected workflows

This Actor fits workflows that start with full email addresses and need a per-address validation result before sending, importing, or routing records. It is a focused standalone workflow: use the structured rows for a current list-hygiene decision, then pass the accepted records into the approved outreach or CRM process.

Common routing patterns include:

- cold outreach list cleanup, where each address is scored and labeled before it reaches an email platform
- signup or CRM hygiene, where role addresses, disposable addresses, and typo suggestions guide the next action
- lead-enrichment pipelines, where another Actor gathers contacts and this Actor validates the resulting addresses
- AI-agent workflows through Apify MCP, where a tool call returns one record per email for programmatic decisions
- instant lookup workflows through the Apify Standby HTTP API, where a request can validate addresses with low-friction API access

### How this workflow compares with ZeroBounce

This is a workflow-level alternative for validating a supplied list of complete email addresses. It covers the deterministic list-hygiene step and returns machine-readable rows; ZeroBounce remains a stronger fit when a workflow needs its broader activity, suppression, scoring, file-management, deliverability, or native-integration suite.

| Decision | This Actor | ZeroBounce | Best fit |
|---|---|---|---|
| Scope | Syntax, DNS MX, list-classification, typo, optional SMTP, and a score per input address | A broader email-validation and deliverability product | Use this Actor for the focused validation step; choose ZeroBounce when the surrounding suite is part of the requirement. |
| Billing | Pay per event plus Apify platform usage for the processed workflow | Credit- and subscription-based validation options | Compare the current prices against the same list size and required fields. |
| Input | A JSON array of full email addresses; no provider key is collected | Its batch API uses an API key and batch payload | Use this Actor for a bounded API/MCP run; use ZeroBounce when its authenticated service is already the chosen system. |
| Effective efficiency | One schema-complete dataset row is persisted for each accepted address, and normalized duplicates are removed before billing | Batch and file paths support its broader validation workflow | Compare elapsed time, usable rows, required fields, and operator steps for the same batch. |
| Output | Dataset rows expose `status`, `score`, `primaryReason`, MX, classification flags, and `validatedAt` | Its API documents additional proprietary status and activity-oriented fields | Choose the output contract that contains the fields needed by the next workflow step. |
| Automation | Run through Apify API, scheduled tasks, or MCP workflow tooling | API and native platform integrations | Choose the automation path already connected to the buyer's stack. |

ZeroBounce is a trademark of its owner. This independent Actor is not affiliated, associated, or endorsed by ZeroBounce.

### Input

Submit full email addresses as an array. Each item is normalized to lowercase before validation.

#### Input fields

| Field | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `emails` | array of string | Yes | - | One to 1,000 full email addresses. Pass a single address as a one-item array. Normalized duplicates are removed without a charge. |
| `verificationTier` | string | No | `standard` | `standard` uses the native pipeline. `premium` adds an owner-managed EmailListVerify result when the Premium email verified event is active. No BYOK is required. |
| `maxEmails` | integer | No | `1000` | Per-run processing cap from `1-1000`. Addresses beyond the cap are skipped and not charged. |
| `checkSmtp` | boolean | No | `false` | Run a live SMTP RCPT TO probe. When enabled, the Actor attempts mailbox verification in addition to syntax, MX, and classification checks. |
| `checkCatchAll` | boolean | No | `false` | Detect catch-all domains when `checkSmtp` is enabled. |
| `concurrency` | integer | No | `10` | Concurrent validations. Range: `1-50`. Recommended input guidance: `5-15` for most lists. |
| `timeoutMs` | integer | No | `8000` | SMTP timeout in milliseconds. Range: `1000-30000`. |

#### Valid focused JSON example

```json
{
  "emails": [
    "jane@example.com",
    "info@acme.io",
    "fake@thisdomaindoesnotexist123.io"
  ],
  "checkSmtp": false,
  "checkCatchAll": false,
  "verificationTier": "standard",
  "maxEmails": 1000,
  "concurrency": 10,
  "timeoutMs": 8000
}
```

### Output

Each dataset row represents one validated email address.

#### Output fields

| Field | Type | Description |
|---|---|---|
| `email` | string | Original email address supplied in input. |
| `normalizedEmail` | string or null | Trimmed, lowercased address. Null when syntax is invalid. |
| `status` | string | Verdict bucket: `valid`, `invalid`, `risky`, or `unknown`. |
| `score` | integer | Deliverability score from 0 to 100. |
| `primaryReason` | string | Most important reason for the verdict. |
| `reasons` | array of string | Reason codes in pipeline order. |
| `isValidSyntax` | boolean | RFC 5322 structure and length check result. |
| `hasMxRecord` | boolean | Indicates whether the domain resolves to MX records. |
| `smtpCheck` | string | `accepted`, `rejected`, `unknown`, or `skipped`. |
| `smtpCode` | integer or null | Final SMTP response code, when present. |
| `smtpResponse` | string or null | Raw SMTP response line, when present. |
| `isFreeProvider` | boolean | Marks public free email providers. |
| `isRoleBased` | boolean | Marks role addresses such as `info@` or `sales@`. |
| `isDisposable` | boolean | Marks disposable email domains. |
| `isCatchAll` | boolean or null | Indicates catch-all domains when checked. |
| `suggestedEmail` | string or null | Typo suggestion, when available. |
| `domain` | string or null | Lowercased domain part after `@`. |
| `localPart` | string or null | Lowercased local part before `@`. |
| `mxRecords` | array | Resolved MX records sorted by priority. |
| `verificationTier` | string | Requested `standard` or `premium` tier. |
| `verificationSource` | string | `native` for standard validation or `emaillistverify` when a provider verdict was used. |
| `providerStatus` | string or null | Provider response for a premium record; null on standard records. |
| `providerCheckedAt` | string or null | Provider response timestamp for a premium record; null on standard records. |
| `providerCreditCharged` | boolean or null | Whether the provider documents that returned premium status as credit-consuming; null on standard records. |
| `validatedAt` | string | ISO 8601 timestamp. |

#### Illustrative JSON record

```json
{
  "email": "jane@gmial.com",
  "normalizedEmail": "jane@gmial.com",
  "status": "invalid",
  "score": 5,
  "primaryReason": "mx_not_found",
  "reasons": [
    "syntax_valid",
    "typo_suggestion",
    "mx_not_found"
  ],
  "isValidSyntax": true,
  "hasMxRecord": false,
  "smtpCheck": "skipped",
  "smtpCode": null,
  "smtpResponse": null,
  "isFreeProvider": false,
  "isRoleBased": false,
  "isDisposable": false,
  "isCatchAll": null,
  "suggestedEmail": "jane@gmail.com",
  "domain": "gmial.com",
  "localPart": "jane",
  "mxRecords": [],
  "validatedAt": "2026-05-03T20:00:00.000Z"
}
```

### How it works

The Actor follows the validation pipeline defined in the supplied contract:

1. It checks RFC 5322 syntax and length.
2. It parses the local part and domain.
3. It resolves DNS MX records.
4. It classifies the address using disposable, role-based, free-provider, and typo-suggestion signals.
5. It can optionally run SMTP RCPT TO verification and catch-all detection.
6. It writes one dataset record per email with verdict, score, and supporting signals.

The overview dataset view presents each row as one validated address with the key signals surfaced for review.

### Interactive API endpoints

This Standby-enabled Actor also exposes an interactive API surface. Use the live Endpoints/Standby tab in the Apify Console for the current request format, response shape, and endpoint details.

### Use with AI agents (MCP)

This Actor is an Apify Actor usable through Apify MCP. The exact Actor identity is `khadinakbar/zerobounce-alternative`.

Tool description: validate one or many email addresses and return one dataset record per input address, including syntax, MX, optional SMTP probe results, disposable and role tags, typo suggestions, catch-all status, and a 0-100 score.

> Validate these email addresses with the Apify Actor `khadinakbar/zerobounce-alternative`. Return the dataset rows and summarize which addresses are valid, risky, invalid, or unknown. Use the returned score, MX data, disposable flag, role flag, typo suggestion, and premium provider provenance when selected to help me decide what to send next.

Output interpretation:

- `status` groups the address into `valid`, `invalid`, `risky`, or `unknown`
- `score` provides the 0-100 deliverability signal used in the dataset contract
- `primaryReason` explains the main verdict driver
- `suggestedEmail` can point to a likely typo correction
- `smtpCheck` may be `skipped` when SMTP probing is off, and may be `unknown` when live probing is inconclusive

Provenance and scope:

- each dataset item corresponds to one input email
- the input email is preserved in `email`
- the normalized form is returned in `normalizedEmail`
- MX and SMTP fields reflect the validation pipeline exposed by the schema
- if SMTP probing is enabled, the returned record includes the SMTP response fields supported by the dataset contract

Pagination and cost guidance:

- read the default dataset items endpoint returned by the run output
- if you validate a large list, fetch dataset items in batches as needed
- each standard or provider-non-credit result maps to one charged `Email validated` event
- a provider-credit-consuming premium result maps to the separately priced `Premium email verified` event once that event is active

### Apify API example

JavaScript example with token and dataset readback:

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/zerobounce-alternative').call({
  emails: ['jane@example.com', 'info@acme.io'],
  checkSmtp: false,
  checkCatchAll: false,
  concurrency: 10,
  timeoutMs: 8000,
});

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

### Best results and outcome guidance

Use full email addresses as input, not domains or CSV paths. Keep `checkSmtp` off for routine validation, and turn it on when you need the optional SMTP fields supported by the schema. Review `score`, `status`, `primaryReason`, and `suggestedEmail` together, since those fields form the clearest decision set in the dataset view. For larger lists, split inputs into runs of up to 1,000 addresses and use concurrency from 5 to 15 unless the receiving mail hosts have been assessed for higher rates. When you want a quick quality pass, the non-SMTP signals cover syntax, MX, disposable, role, free-provider, and typo checks.

### Continue the workflow

- Start upstream with Bulk Website Contact Extractor when the workflow needs to collect public contact details before this validation step.
- Then pass accepted records downstream to LinkedIn Profile Email Scraper only when the next approved workflow needs a public-profile email lookup rather than another validation pass.

### Design note

I designed the dataset around one decision-ready row per validated address: `email`, `status`, `score`, `primaryReason`, `smtpCheck`, and the classification flags are directly visible, while the full result remains available for API and CSV readback.

### FAQ

#### What kind of input fits the workflow here?

A list of complete email addresses in the `emails` array fits the workflow, including single-address runs wrapped as a one-item array.

#### How does this Actor fit with lead-generation workflows?

It fits after any workflow that extracts or enriches email addresses, because it returns validation fields that help you route addresses before outreach or CRM import.

#### What does `risky` mean in the output?

`risky` is the verdict bucket for catch-all, role-based, or disposable addresses in the dataset contract.

#### Can I use this through Apify MCP?

Yes. This Actor is MCP-ready and designed to be called as `khadinakbar/zerobounce-alternative`.

#### Where do I check pricing details?

Use the live Pricing tab for current Pay per event pricing and Apify platform usage information.

#### Do I need my own EmailListVerify API key for premium verification?

No. Premium uses the Actor owner's encrypted provider credential. If the Premium email verified event is not active on the live Pricing tab yet, the Actor returns an availability result instead of making a provider request; normal Actor Start and platform usage can still apply.

#### Where do I find the instant lookup interface?

Use the live Endpoints/Standby tab for the Standby HTTP API surface and request details.

### Responsible use

This Actor performs protocol-level email validation and returns deliverability signals for legitimate list hygiene, signup checks, CRM cleanup, and similar workflows. Use it in ways that respect applicable privacy, anti-spam, and data-protection rules for your use case and jurisdiction.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/zerobounce-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `email-validated` | Email validated | Charged for each email address fully processed and pushed to the dataset using the native validation workflow. |
| `email-premium-verified` | Premium email verified | Charged for each provider-credit-consuming EmailListVerify verification completed and pushed to the dataset. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

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

List of 1–1,000 full email addresses to validate. Use a JSON array such as \["jane@example.com", "info@acme.io"] and pass a single address as a one-item array. Entries are normalized to lowercase and normalized duplicates are removed without a charge. This field is not a CSV path, a domain list, or a mailbox-login credential.

## `checkSmtp` (type: `boolean`):

When enabled, the Actor attempts an SMTP RCPT TO probe after syntax and MX checks. Set true only when you need the additional SMTP signal; the default is false. Cloud hosts commonly restrict port 25, so an attempted probe can truthfully return unknown rather than a mailbox verdict. This toggle does not send email and does not provide proprietary deliverability, trap, or activity data.

## `checkCatchAll` (type: `boolean`):

When enabled with the SMTP probe, the Actor tests a random address at the same domain for catch-all behavior. Set true only with checkSmtp=true; the default is false. Inconclusive SMTP responses remain null rather than being inferred as catch-all. This control does not identify individual mailbox owners or recipient engagement.

## `verificationTier` (type: `string`):

standard uses this Actor's native syntax, DNS, classification, typo, and optional SMTP signals. premium uses an owner-managed EmailListVerify credential and adds a provider verdict when the Actor's Premium email verified event is active. No provider key is requested from you. Until the Premium event appears as active on this Actor's Pricing tab, premium returns an availability message and does not contact the provider; normal Actor Start and platform-usage billing can still apply.

## `maxEmails` (type: `integer`):

Optional per-run cap from 1 to 1,000. The Actor processes the first normalized unique addresses only; later addresses are skipped and not charged.

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

Number of addresses validated concurrently, from 1 to 50. Use 5–15 for routine lists; the default is 10. Higher settings can produce more inconclusive SMTP responses when a mail host rate-limits probes. This value is not a result limit or a way to exceed the 1,000-address run cap.

## `timeoutMs` (type: `integer`):

Maximum wait per SMTP connection, from 1,000 to 30,000 milliseconds. Use 8,000 milliseconds by default; strict mail servers can take 5–10 seconds. Lower values can produce more unknown SMTP outcomes, while higher values extend run time. This setting affects only the optional SMTP probe, not syntax or MX lookup.

## Actor input object example

```json
{
  "emails": [
    "test@gmail.com",
    "ceo@apify.com",
    "fake@thisdomaindoesnotexist123.io",
    "admin@10minutemail.com"
  ],
  "checkSmtp": false,
  "checkCatchAll": false,
  "verificationTier": "standard",
  "maxEmails": 1000,
  "concurrency": 10,
  "timeoutMs": 8000
}
```

# Actor output Schema

## `validationResults` (type: `string`):

One row per validated email — status, score, MX, disposable, role, free, typo suggestion.

## `validationResultsCsv` (type: `string`):

Same dataset exported as CSV — drop into Excel / Sheets / your CRM.

## `summaryFiles` (type: `string`):

Key-value store entries, including INPUT, OUTPUT and RUN\_SUMMARY terminal records.

## `terminalOutput` (type: `string`):

Compact run outcome, persisted-item count, charged events and safe warnings.

## `runSummary` (type: `string`):

Detailed terminal diagnostics, including duplicate, failed and charged-event counts.

## `publicRunLink` (type: `string`):

No description

## `consoleRunLink` (type: `string`):

No description

## `apiRunLink` (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": [
        "test@gmail.com",
        "ceo@apify.com",
        "fake@thisdomaindoesnotexist123.io",
        "admin@10minutemail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/zerobounce-alternative").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": [
        "test@gmail.com",
        "ceo@apify.com",
        "fake@thisdomaindoesnotexist123.io",
        "admin@10minutemail.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/zerobounce-alternative").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": [
    "test@gmail.com",
    "ceo@apify.com",
    "fake@thisdomaindoesnotexist123.io",
    "admin@10minutemail.com"
  ]
}' |
apify call khadinakbar/zerobounce-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/zerobounce-alternative"
        }
    }
}
```

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/kyarba8cynnNfvtBc/builds/EaJZG9JtPtoZAW7S6/openapi.json