# Bulk Email Verifier & Validator - $0.59/1K, No API Key (`mailveri/email-verifier-validator`) Actor

Verify email lists from Apollo, Google Maps, LinkedIn, or CSVs with 99% accuracy and keep your bounce rate under 2%. Pay-Per-Event with no API key required ($0.59-$0.75/1K on paid Apify plans; UNKNOWN, invalid syntax, and duplicates are $0).

- **URL**: https://apify.com/mailveri/email-verifier-validator.md
- **Developed by:** [MailVeri](https://apify.com/mailveri) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.59 / 1,000 verified emails

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Verify scraped email lists directly from **Google Maps, Apollo, LinkedIn, or CSV datasets** inside Apify with our bulk email verifier and email validator - **no signup or external API key required**, **99% accuracy**, and built to keep your **bounce rate under 2%**. Pay only through your Apify account via Pay-Per-Event billing (`$0.59-$0.75 / 1,000` on paid plans, or up to `~1,000` free test checks within Apify's `$5` monthly free credit), with **`$0` charged on `UNKNOWN`, duplicates, or syntax errors**.

***

### Why use this Bulk Email Verifier?

- **Zero Setup Friction:** Paste emails or chain any upstream scraper dataset and click **Start**. No external account signup or API key management is needed.
- **Protect Sender Reputation (<2% Bounce Target):** Accurately classifies `VALID`, `INVALID`, `CATCH_ALL`, `DISPOSABLE`, `ROLE_ACCOUNT`, `FULL_INBOX`, and `UNKNOWN` addresses so cold outreach campaigns avoid hard bounces.
- **1-Click Scraper Dataset Chaining:** Point **Input Dataset** (`sourceDatasetId`) directly to any Apify scraper output and keep all lead columns (company, name, phone, website, LinkedIn URL). Pre-existing `status` and `error` columns are safely preserved as `source_status` and `source_error`.
- **Automatic Duplicate Savings:** Repeated addresses inside the same run are verified once and applied across all matching rows for **`$0` extra charge**.
- **Verify Before You Charge:** Each address incurs one `email-verified` event only after a decisive verdict is returned and before the result row is written to your dataset.
- **Budget Safe (`maxTotalChargeUsd`) & Clean Stops:** Checks your remaining Apify run budget before every check (at fixed concurrency `3`) and stops cleanly after `20` consecutive service errors without charging or pushing failed rows.

***

### Pricing and cost estimate

You pay transparently through your existing Apify subscription tier, with zero charges for unverifiable or malformed rows:

| Apify Plan Tier | Verified Email (`email-verified`) | Actor Start | `UNKNOWN` / Syntax Errors / Duplicates | Estimated Cost for 10,000 Emails |
| :--- | :--- | :--- | :--- | :--- |
| **Gold / Platinum / Diamond** | **$0.59 / 1,000** | `$0.0002 / run` | **$0.00 (Free)** | **~$5.90** |
| **Silver** | **$0.65 / 1,000** | `$0.0002 / run` | **$0.00 (Free)** | **~$6.50** |
| **Bronze** | **$0.75 / 1,000** | `$0.0002 / run` | **$0.00 (Free)** | **~$7.50** |
| **Free** | **$5.00 / 1,000** *(covers ~1,000 test checks within Apify's $5 monthly credit)* | `$0.0002 / run` | **$0.00 (Free)** | Use Free plan for up to `1,000` test emails |

- **Non-billable rows (`charged: false`):** `UNKNOWN` results, duplicate occurrences in the same run, missing email rows, and invalid syntax rows are **never charged**.
- **Need `$0.30 / 1,000` for high-volume lists (`500K`-`1M+`)?** Claim `1,000` free credits at <https://app.mailveri.com/api-keys/> and use our [MailVeri Email Verifier (Own API Key)](https://apify.com/mailveri/mailveri-email-verifier) Actor with non-expiring packs (`$9 / 10K`, `$39 / 60K`, `$59 / 100K`, `$199 / 500K`, `$299 / 1M`).

***

### How to use (Quick start)

1. **Choose your input source:**
   - Enter email addresses directly under **Emails to Verify** (`emails`), **or**
   - Pick an existing scraper dataset under **Input Dataset (Chain from Scraper)** (`sourceDatasetId`).
2. **Adjust optional filters:**
   - Keep **Dataset Email Field** (`emailField`) on `auto` (or set a nested path like `contact.email`).
   - Enable **Output Deliverable Emails Only** (`onlyDeliverable`) if you only want `VALID` and `ROLE_ACCOUNT` rows saved to your output dataset. *(Every decisive verdict is still charged; this option only filters which rows are saved.)*
3. **Run & export:** Set an optional max cost limit, click **Start**, and download clean results as **CSV, Excel, or JSON**.

***

### Input configuration

| Field | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `emails` | String List | - | Direct list of emails (Console prefill: `["support@mailveri.com"]`; leave empty when reading from an Input Dataset; supports comma/semicolon/newline-separated rows). |
| `sourceDatasetId` | Dataset ID | - | Apify Dataset ID from an upstream Google Maps, Apollo, or LinkedIn scraper run. |
| `emailField` | String | `"auto"` | Field path in dataset items (`email`, `contact.email`, `emails[0]`, or `auto` for case-insensitive detection). |
| `onlyDeliverable` | Boolean | `false` | Save only `VALID` and `ROLE_ACCOUNT` leads in the output dataset. |
| `includeInputFields` | Boolean | `true` | Preserve all original scraper columns alongside verification results. |

#### Example 1: Verify a direct list of emails

```json
{
  "emails": [
    "founder@acme.com",
    "support@mailveri.com",
    "name@company.com"
  ],
  "onlyDeliverable": false,
  "includeInputFields": true
}
```

#### Example 2: Clean leads from a Google Maps or Apollo scraper dataset

```json
{
  "sourceDatasetId": "YOUR_SCRAPER_DATASET_ID",
  "emailField": "auto",
  "onlyDeliverable": true,
  "includeInputFields": true
}
```

***

### Output and verification statuses

Results are written to the default Dataset with table views (**Overview**) and full JSON objects. When `includeInputFields` is `true`, your original lead columns are preserved inline:

```json
{
  "company": "Acme Corp",
  "email": "founder@acme.com",
  "source_status": "OPERATIONAL",
  "status": "VALID",
  "is_valid": true,
  "is_deliverable": true,
  "charged": true,
  "quality_score": 95,
  "is_forwarding": false,
  "verification_mode": "realtime"
}
```

#### Verification statuses reference

| Status | Meaning | `is_deliverable` | Billed Event? |
| :--- | :--- | :--- | :--- |
| `VALID` | Mailbox exists and is safe to email. | `true` | Yes (`1` event) |
| `ROLE_ACCOUNT` | Role-based inbox (`support@`, `info@`, `sales@`) verified as reachable. | `true` | Yes (`1` event) |
| `CATCH_ALL` | Domain accepts mail for any address; higher risk for cold outreach. | `false` | Yes (`1` event) |
| `DISPOSABLE` | Temporary or burner email provider. | `false` | Yes (`1` event) |
| `FULL_INBOX` | Recipient mailbox is full and cannot receive new messages. | `false` | Yes (`1` event) |
| `INVALID` | Domain or mailbox does not exist (syntactically invalid rows skip billing). | `false` | Yes after service check (`$0` if invalid syntax) |
| `UNKNOWN` | Could not verify definitively due to temporary remote mail server limits. | `false` | **No (`$0.00`, free)** |

A complete run breakdown is also stored in the default Key-Value Store under **`SUMMARY`** (`status`, `billing_model`, `total_input_rows`, `unique_valid_emails`, `unique_emails_processed`, `skipped_unprocessed_emails`, `output_rows_written`, `missing_email_rows`, `invalid_syntax_rows`, `duplicate_rows_saved`, `events_charged`, `free_rows_count`, `charge_limit_reached`, `free_tier_cap_reached`, `input_row_cap_reached`, `stop_reason`, `notice`, and `counts_by_status`).

***

### Integrations, API, and automation

Because this Actor runs on the Apify platform, you can connect it directly into your outbound and enrichment stack:

- **Apify REST API & SDKs:** Trigger verification programmatically via HTTP, Python (`apify-client`), or Node.js (`apify-client`) and fetch cleaned leads as JSON, CSV, or Excel.
- **Scraper Webhooks & Pipelines:** Attach a webhook to your Google Maps, Apollo, or LinkedIn scraper run so every completed scrape automatically triggers this verifier.
- **Scheduled CRM Hygiene:** Use Apify Schedules to periodically re-validate exported lead lists.
- **No-Code Workflows:** Connect Apify run datasets to **Make, Zapier, n8n, or Google Sheets** without managing extra credentials.

***

### Limits and troubleshooting

- **Per-Run Volume Caps (Unique Emails & Input Rows):**
  - **Paid Apify plans:** Up to **100,000 unique valid emails** and **500,000 total input rows** per run.
  - **Free Apify plan:** Up to **1,000 unique valid emails** and **5,000 total input rows** per run.
  - When a run reaches either cap, it finishes cleanly as `SUCCEEDED` (`stop_reason: "free_tier_cap_reached"`, `"max_emails_cap_reached"`, or `"input_row_cap_reached"`) and preserves all verified rows.
- **Non-Resumable Runs:** An interrupted run is not resumed; start a new run for the remaining emails so rows are never double-billed.
- **Memory (`256 MB` Default):** Datasets stream in `100`-row pages inside `256 MB` RAM. If your upstream scraper dataset has very large nested fields per item (e.g., long review arrays), increase run memory up to `1,024 MB`.
- **"No email addresses were found":** Check `emailField` if your dataset stores emails in a non-standard property name or nested path (for example `contact.work_email`). Rows with empty email values in mixed datasets are kept safely as `status: null`, `verification_mode: "missing"`.

***

### Related MailVeri Actors

| Feature | This Actor (`No API Key`, Pay-Per-Event) | [MailVeri Email Verifier (`Own API Key`)](https://apify.com/mailveri/mailveri-email-verifier) |
| :--- | :--- | :--- |
| **Account / Key Setup** | None required (runs immediately on Apify) | Requires your MailVeri API key (`1,000` free credits) |
| **Price per 1,000 Emails** | `$0.59-$0.75` paid Apify plans (`$5.00` Free plan) | From **`$0.30 / 1K`** (`$299/1M`, `$59/100K`, `$39/60K`, `$9/10K`) |
| **UNKNOWN & Duplicates** | `$0.00` (Free) | `0` credits |
| **High-Volume Mode (`>25` emails)** | Real-time verification (`concurrency: 3`) | High-volume asynchronous list processing + checkpoint resume (`up to 100K`) |
| **Best For** | Instant plug-and-play runs and Apify billing | High-volume outreach (`500K-1M+`) at lowest cost |

***

### FAQ

#### How much does it cost to verify 10,000 emails?

On Apify **Gold / Platinum / Diamond**, 10,000 decisive checks cost **~$5.90** (`$0.59 / 1,000` plus `$0.0002` Actor start). On Silver it is ~$6.50, and on Bronze ~$7.50. Any `UNKNOWN`, duplicate, missing-email, or invalid-syntax rows cost `$0.00`.

#### Are `UNKNOWN`, duplicate emails, and syntax errors charged?

No. Duplicate addresses in the same run, rows with malformed syntax or missing emails, and `UNKNOWN` verdicts are always free (`charged: false`).

#### Can I verify emails straight from a Google Maps or Apollo scraper?

Yes. Select the completed scraper dataset in **Input Dataset** (`sourceDatasetId`). Leave **Dataset Email Field** on `auto` (or enter your specific path) and keep **Preserve Input Dataset Columns** checked to receive one unified lead file ready for export.

#### Which verification statuses are safe for cold email outreach?

Enable **Output Deliverable Emails Only** (`onlyDeliverable: true`) or filter for `is_deliverable: true`, which keeps **`VALID`** and **`ROLE_ACCOUNT`** addresses while excluding `INVALID`, `DISPOSABLE`, `FULL_INBOX`, `CATCH_ALL`, and `UNKNOWN`.

#### When should I switch to the Own API Key MailVeri Actor?

If you verify high-volume lists (`500K`-`1M+` emails) regularly, switching to [MailVeri Email Verifier & Validator (`$0.30/1K`, Own API Key)](https://apify.com/mailveri/mailveri-email-verifier) becomes cheaper above `100K` credits and reaches roughly half the Pay-Per-Event price (`$0.30 / 1K` on the `$299 / 1M` non-expiring pack, or `$0.40 / 1K` on `$199 / 500K`) while adding high-volume asynchronous processing and checkpoint resume.

***

### Support

- **Pricing & Volume Packages:** <https://mailveri.com/pricing>
- **Claim 1,000 Free Credits (Direct API):** <https://app.mailveri.com/api-keys/>
- **Support:** `support@mailveri.com`

# Actor input Schema

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

Direct list of email addresses to verify (supports individual addresses or comma/semicolon/newline-separated rows). Leave empty when reading from an Input Dataset.

## `sourceDatasetId` (type: `string`):

Optional Apify Dataset ID from an upstream Google Maps, Apollo, or LinkedIn scraper run to verify in bulk.

## `emailField` (type: `string`):

Field path holding the email in Input Dataset items (e.g. 'email', 'contact.email', or 'auto' to detect email / workEmail / personalEmail / emails\[0]).

## `onlyDeliverable` (type: `boolean`):

When checked, only deliverable leads (VALID and ROLE_ACCOUNT) are saved to the output dataset. Every decisive verdict is still charged; this option only filters which rows are saved.

## `includeInputFields` (type: `boolean`):

Keep original scraper fields (company, name, phone, LinkedIn URL, etc.) alongside verification results.

## Actor input object example

```json
{
  "emails": [
    "support@mailveri.com"
  ],
  "emailField": "auto",
  "onlyDeliverable": false,
  "includeInputFields": true
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset containing verified email items (viewable in table/JSON and exportable as CSV, Excel, or JSON).

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

Aggregate status counts, duplicates saved, and billed events.

# 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": [
        "support@mailveri.com"
    ],
    "emailField": "auto"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mailveri/email-verifier-validator").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": ["support@mailveri.com"],
    "emailField": "auto",
}

# Run the Actor and wait for it to finish
run = client.actor("mailveri/email-verifier-validator").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": [
    "support@mailveri.com"
  ],
  "emailField": "auto"
}' |
apify call mailveri/email-verifier-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mailveri/email-verifier-validator"
        }
    }
}
```

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/tJJuFwNWaBSPDA8Qs/builds/EHKq2aXV0uEsj4Nug/openapi.json
