# Bulk Email Validator — NeverBounce Alternative (`khadinakbar/neverbounce-alternative`) Actor

Validate up to 1,000 supplied email addresses with syntax, live DNS MX, disposable and role flags, typo suggestions, scores, and structured output. A focused preflight workflow, not a mailbox-existence claim.

- **URL**: https://apify.com/khadinakbar/neverbounce-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.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

## NeverBounce Alternative — Bulk Email Preflight

Validate up to 1,000 email addresses in one run before a CRM import, signup review, or outreach-list decision. Each input produces one structured row with syntax, DNS MX, disposable-domain, role-account, free-provider, typo, and optional best-effort SMTP signals.

This is a lightweight, workflow-level alternative for the preflight stage of email verification. It does not claim that a specific mailbox exists, belongs to a person, or will accept a delivered message.

### Best fit

Use this Actor when you already have full email addresses and need a bounded, machine-readable quality pass. It is useful for sales operations, CRM hygiene, signup screening, and lead-enrichment pipelines.

Use a vendor-managed verification service when the workflow requires mailbox ownership evidence, consent handling, or its product-specific delivery decision. Verification remains a data-quality signal rather than permission to contact anyone.

Then use [Email to LinkedIn Profile Scraper](https://apify.com/khadinakbar/email-to-linkedin-profile-scraper) after the preflight when your lawful workflow needs permitted profile enrichment from that email address.

### What each row contains

| Field | Meaning |
| --- | --- |
| `email` and `normalizedEmail` | The supplied address and its trimmed lowercase form. |
| `status`, `score`, `primaryReason`, `reasons` | A routing-oriented verdict and the signals behind it. |
| `isValidSyntax`, `hasMxRecord`, `mxRecords` | Address format and current DNS mail-routing evidence. |
| `isDisposable`, `isRoleBased`, `isFreeProvider` | Risk and segmentation flags. |
| `suggestedEmail` | A close common-provider correction when one is plausible. |
| `smtpCheck`, `smtpCode`, `smtpResponse`, `isCatchAll` | Optional SMTP-probe evidence. These fields can be `unknown` or absent when the probe is not available. |
| `verificationTier`, `verificationSource`, `providerStatus`, `providerCheckedAt`, `providerCreditCharged` | The selected tier and premium-verification metadata. Provider fields are `null` for standard rows. |
| `validatedAt` | When this Actor collected the signals. |

### Input

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

`emails` is required. Duplicates are removed before the `maxEmails` cap is applied. `verificationTier: "premium"` enables a deeper verification result and is capped at 100 unique addresses per run; standard remains available for up to 1,000. Keep `checkSmtp` off for the standard deterministic pass: cloud mail networks can block port 25, and an SMTP response is not proof of ownership or future delivery. `checkCatchAll` only applies when SMTP probing is enabled.

### Output example

```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,
  "isDisposable": false,
  "isRoleBased": false,
  "isFreeProvider": false,
  "suggestedEmail": "jane@gmail.com",
  "smtpCheck": "skipped"
}
```

### Pricing and cost cap

The live [Pricing tab](https://apify.com/khadinakbar/neverbounce-alternative/pricing) is authoritative. At the current live rate, standard rows are `$0.0009` each and credit-consuming premium rows are `$0.035` each, plus a `$0.00005` actor-start event; Apify platform usage is additional under Pay per event + usage.

Before processing, the Actor reports the maximum email-event charge implied by `maxEmails`. It persists and charges a row together, then records charged-event counts in `OUTPUT` and `RUN_SUMMARY`.

### How this email-validation workflow compares with NeverBounce

This independent Actor is not affiliated, associated, or endorsed by NeverBounce. The comparison is deliberately limited to a supplied-list preflight workflow; it is not a claim of full-suite or mailbox-verification parity.

| Decision | This Actor | NeverBounce | Best fit |
| --- | --- | --- | --- |
| Scope and workflow | Syntax, DNS MX, risk flags, typo signals, and optional SMTP probing for supplied addresses. | Broader vendor-managed verification and list-cleaning product. | Use this Actor for a bounded preflight; use NeverBounce for its managed product workflow. |
| Billing and same-job cost | Listed email events are `$0.90` for 1,000 rows plus `$0.00005` start and platform usage. | Its observed pay-as-you-go page lists `$8` per 1,000 credits. | Compare only the stated 1,000-address non-SMTP preflight, not feature parity. |
| Effective efficiency | One Apify run returns one structured dataset row per processed address. | Offers real-time verification and list-cleaning flows. | Choose the path whose output and decision depth match the job. |
| Input friction | A bounded `emails` array; no NeverBounce credential. | Its account and API or product workflow. | Use this Actor for an existing Apify flow; use NeverBounce when you operate its account workflow. |
| Output contract | Declared rows include verdict, reasons, MX state, risk flags, score, and timestamp. | Documents a single-email check API within its product. | Use this Actor when a dataset contract is the downstream integration boundary. |
| Integrations and automation | Apify API, schedules, and dataset retrieval support recurring run-based workflows. | The observed pricing page names product integrations and sync options by plan. | Evaluate the exact required integration and plan rather than assuming equivalence. |
| Freshness and provenance | Every row includes `validatedAt` and the signals this Actor used. | Its pricing page describes real-time verification. | Treat the two evidence models separately; this Actor does not claim field-level parity. |

### API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/neverbounce-alternative').call({
  emails: ['jane@example.com', 'info@acme.io'],
  maxEmails: 1000,
  verificationTier: 'standard',
  checkSmtp: false
});

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

### Agent prompt card

> Validate the supplied email addresses with `khadinakbar/neverbounce-alternative`. Return the dataset rows and group them by `status`. Treat `unknown`, `risky`, and optional SMTP results as review signals, not proof that a mailbox exists or that outreach is permitted.

### Use with Apify MCP

This regular Actor can be discovered and called through Apify MCP. Use it for an already-supplied email list when you need flat rows with `status`, `primaryReason`, `score`, MX state, risk flags, and `validatedAt`. For mailbox-ownership proof, consent review, or a vendor-managed verification result, choose the service designed for that decision.

For large batches, ask the client to retrieve the default dataset in pages after execution completes. `OUTPUT` and `RUN_SUMMARY` state whether processing was complete, partial, needs corrected input, or should be retried later; they keep the dataset to validated email rows.

### Interactive API endpoints

The Actor also has a Standby HTTP surface for short, interactive checks. Open its live Endpoints/Standby tab for the current request schema and endpoint behavior. The run-mode API example above is the preferred path for bounded lists and audit-friendly dataset output.

### Freshness and provenance

DNS and classification values are collected during each run, and `validatedAt` identifies the collection time for every row. The private alternative dossier retains the comparison sources, cost boundaries, and release-evidence records while public copy stays evergreen.

### Builder's note

I designed the result contract around one flat row per supplied email so an operator or automation can make its next routing decision without parsing a dashboard. The optional SMTP fields remain separate from the deterministic syntax, DNS, and classification signals because cloud mail-network behavior is not a durable proof of a mailbox.

### Outcomes and limits

- `COMPLETE`: every requested, bounded address produced a persisted row.
- `PARTIAL`: useful rows were persisted and `RUN_SUMMARY` provides the next action for the remaining batch.
- `INVALID_INPUT`: fix the email array and retry; no rows are fabricated.
- `UPSTREAM_FAILED`: retry later with the same valid input when no rows were persisted.

`OUTPUT` is the compact machine contract. `RUN_SUMMARY` includes input, deduplication, validation, persistence, warning, and charge counters. Read large outputs from the default dataset in pages.

### Responsible use

Email addresses can be personal data. Use this Actor only where you have a lawful basis and comply with applicable privacy and anti-spam rules. A validation result does not create consent, override an opt-out, or authorize outreach.

# Actor input Schema

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

List of email addresses to validate. Pass a single address as a one-item array. Each entry is normalized to lowercase before validation. Example: \["jane@example.com", "info@acme.io"]. NOT a CSV file path or a domain — supply individual full addresses.

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

Hard cap for unique emails processed and charged in this run. Use 1000 for the largest supported batch or a smaller number to control event cost. Defaults to 1000. NOT a pagination offset; duplicate addresses are removed before this cap is applied.

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

Choose standard for the built-in preflight signals or premium for a deeper, owner-managed verification result. Premium runs are capped at 100 unique emails to keep the maximum charge predictable.

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

When true, attempts a live SMTP RCPT TO probe to confirm the mailbox accepts mail. NOTE: most cloud platforms (Apify included, since it runs on AWS) block outbound port 25, so SMTP probes from Apify usually return 'unknown'. The actor still works perfectly without SMTP — syntax + MX + disposable/role/free/typo checks already catch 60–80% of bad addresses. Leave OFF unless you self-host. Default: false.

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

When true and checkSmtp=true, probes a random non-existent address on the same domain to detect catch-all servers. Same cloud-port-25 caveat applies as checkSmtp. Default: false.

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

How many emails to validate in parallel. Higher = faster but may hit per-host rate limits and cause 'unknown' SMTP results. Recommended 5–15 for most lists. Maximum 50. Default: 10.

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

Per-connection timeout for the SMTP probe. Strict mailservers can take 5–10s. Lower values increase 'unknown' verdicts; higher values increase run time. Default: 8000 (8 seconds). Range: 1000–30000.

## Actor input object example

```json
{
  "emails": [
    "test@gmail.com",
    "ceo@apify.com",
    "fake@thisdomaindoesnotexist123.io",
    "admin@10minutemail.com"
  ],
  "maxEmails": 1000,
  "verificationTier": "standard",
  "checkSmtp": false,
  "checkCatchAll": false,
  "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 (input payload, summary).

## `output` (type: `string`):

Machine-readable terminal outcome, item counts, warnings, and charged-event counts.

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

Detailed terminal diagnostics with input, persistence, warning, and billing counters.

## `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"
    ],
    "verificationTier": "standard"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/neverbounce-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",
    ],
    "verificationTier": "standard",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/neverbounce-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"
  ],
  "verificationTier": "standard"
}' |
apify call khadinakbar/neverbounce-alternative --silent --output-dataset

```

## MCP server setup

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