# Email Verifier — Keyless Pilot + BYOK (`myworkingmemory/email-verifier-bulk`) Actor

Verify email lists or Apify datasets. BYOK: $0.50/1K decisive results, supplier credits separate. Limited-time keyless pilot on all plans while allocation lasts: 10 rows/run, 20 checks/customer, 400 total. No startup fee; duplicates, unknowns, catch-alls and errors unbilled.

- **URL**: https://apify.com/myworkingmemory/email-verifier-bulk.md
- **Developed by:** [Myworkingmemory LLC](https://apify.com/myworkingmemory) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 byok verification 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?

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

## Email Verifier — Keyless Pilot + BYOK

Paste an array of email addresses or select an Apify dataset. Get one result per input row, in the same order, with a verdict, role and free-provider flags, typo suggestions, and a conservative `safe_to_send` flag.

**Bring your own MillionVerifier key (BYOK): $0.50 per 1,000 unique decisive results on every Apify plan, plus your separate supplier credits.** **For a limited time, while the shared pilot allocation lasts, customers on every Apify plan can try the keyless pilot** with included verification credits: ten input rows per run, twenty supplier checks per customer and 400 checks across the entire pilot. **No startup fee.** Duplicate copies, unknowns, catch-alls, diagnostics and failed checks are unbilled.

Use results in your CRM, lead workflow, Make, n8n, or an AI agent through Apify MCP. Download JSON, CSV or Excel from your run's dataset.

### Start with your list

Customers on every Apify plan can omit the supplier key for a limited time, while the shared pilot allocation lasts:

```json
{
  "emails": ["person@your-company.com", "sales@your-company.com"]
}
```

For BYOK on any plan, add your MillionVerifier key:

```json
{
  "emails": ["person@your-company.com", "sales@your-company.com"],
  "mv_api_key": "YOUR_MILLIONVERIFIER_KEY"
}
```

Alternatively:

```json
{
  "dataset_id": "YOUR_DATASET_ID",
  "email_field": "email",
  "mv_api_key": "YOUR_MILLIONVERIFIER_KEY"
}
```

Replace every example placeholder before running. Use a real MillionVerifier key for BYOK; public `API_KEY_FOR_…` demo keys cannot perform live verification. If chaining a dataset from another Actor, start verification only after that upstream run finishes and the dataset contains rows.

Supply exactly one source. Dataset rows must contain a single email string in the selected top-level column. The Actor requests read-only access to that dataset. BYOK supports up to 10,000 input rows per run; the keyless pilot permits at most ten, including duplicate and malformed rows.

**Every Apify plan, including Free:** omit the key for the limited-time keyless pilot while shared allocation remains, or supply your own key for BYOK. This is temporary access, not an ongoing included-credit service. A supplied key always selects BYOK, independently of pilot availability. An invalid or depleted customer key never falls back to owner credits. Free-plan runs do not generate developer payout; the shared trial credits fund this acquisition experiment.

Once your twenty checks or the global 400 checks are exhausted, a keyless run exits gracefully without verification fees and shows:

**Pilot allocation exhausted. Add your MillionVerifier API key (mv_api_key) to continue using your own credits. No verification fee was charged.**

Pilot limits count supplier checks, not just billable verdicts. Allocation is reserved before verification; interrupted or incomplete reservations can consume allowance without delivering a result. Failed or uncertain requests and supplier refunds do not replenish the allocation. Adding a valid key continues in BYOK mode using your credits. The limited pilot may be unavailable once its capacity has been used; it is not an unlimited included-credit service.

To use BYOK, create a [MillionVerifier account](https://app.millionverifier.com/), copy your API key into the secret input field, and start with a few addresses. Available MillionVerifier trial credits and Apify usage credits are separate balances. API keys entered through the input form are encrypted by Apify and never appear in result rows or application logs.

### What a result means

| Field | Meaning |
| --- | --- |
| `email` | Address checked; domain is normalized, local-part case preserved |
| `input_index`, `input_email` | Original row position and trimmed input |
| `result` | `ok`, `catch_all`, `unknown`, `invalid`, `disposable`, or `unverified` |
| `quality` | `good`, `risky`, or `bad` |
| `safe_to_send` | True only for a live `ok` result with an explicitly non-role address |
| `free`, `role` | Provider flags, or null when not available |
| `didyoumean` | Suggested correction, never applied automatically |
| `source`, `reason` | Where the verdict came from and why |
| `billable`, `is_test` | Whether the row incurs a result fee and whether it is simulated |
| `duplicate_of` | First occurrence's input index, or null; duplicate copies are unbilled |
| `billing_mode` | Whether the run uses your own key or the limited keyless pilot |

`safe_to_send` is a conservative list-filtering signal, not a guarantee of delivery or permission to contact someone. Catch-all, unknown, disposable, role and simulated results are never marked safe. Your sender reputation, suppression lists and sending practices still matter.

Repeated identical addresses are checked once per run. Only the first occurrence can incur a result fee; all duplicate rows remain in order so you can join results to the original input. Quoted or non-ASCII local parts and malformed values return an unbilled diagnostic instead of being falsely labeled nonexistent.

**Starting a new run with the same list performs fresh verification and incurs new charges for billable results.**

### Pricing

| Mode | Apify Free | Starter / Bronze | Scale / Silver | Business / Gold and higher |
| --- | ---: | ---: | ---: | ---: |
| BYOK result (`email-verified`) | $0.00050 | $0.00050 | $0.00050 | $0.00050 |
| Keyless pilot result (`email-verified-keyless`) | $0.00075 | $0.00075 | $0.00070 | $0.00060 |
| Startup | $0 | $0 | $0 | $0 |

BYOK costs **$0.50 per 1,000 billable results**, plus your MillionVerifier supplier credits. Ten billable keyless results cost **$0.0075 Free/Bronze**, **$0.0070 Silver**, or **$0.0060 Gold/higher**, with pilot supplier credits included. These are different offers: a BYOK headline fee excludes supplier credits. Platform usage during the run is included. Apify may charge its usual storage access costs after the run.

Only unique, delivered live `ok`, `invalid` or `disposable` verdicts incur result fees. Unknowns, catch-alls, duplicate copies, local syntax diagnostics, provider failures, unverified rows and sandbox results are unbilled. A partial run can still bill its successfully delivered decisive verdicts. A refused or entirely unsuccessful run has no verification or startup fee.

Set **Maximum cost per run** high enough for the unique supported addresses you submit. The Actor checks the worst-case result budget before supplier verification and checks supplier credit availability. Concurrent BYOK runs share your supplier balance; a later credit failure stops new checks and preserves completed work instead of switching suppliers.

**This pilot proves a transaction, not replenishment economics.** The 400-check allocation yields at most **$0.30 gross and $0.24 after Apify's commission, before platform costs**. It uses a limited trial-credit allocation and does not promise a permanent included-credit service at these prices. No supplier purchase or automatic top-up is enabled by the pilot.

### Reliability and privacy

The keyless pilot uses the realtime API with limited concurrency. For BYOK, up to 50 unique supported addresses use realtime; larger lists use bulk upload, bounded polling, download and supplier-file cleanup. Optional `verification_mode` can select BYOK bulk or realtime. The pilot remains realtime only.

A BYOK bulk job reaching the time limit is stopped; completed results are recovered where the supplier makes them available, while missing rows are marked unverified and unbilled. The input limit is not a promise that a bulk job will finish within one run. Single-request outages can produce unbilled MX diagnostics. **An MX record proves only that a domain has mail servers; it never proves a mailbox exists.** Completed checks are preserved if a later supplier request fails, and incomplete verification is reported explicitly.

There are no direct SMTP probes from the Actor and it sends no email messages. MillionVerifier performs mailbox verification. Single-request service failures are not automatically retried, avoiding uncertain duplicate supplier charges. Pilot permits are private, exclusively locked and consumed once; a retry or supplier refund never expands the pilot budget.

Addresses go to MillionVerifier, and results are stored in your Apify run's dataset and key-value store. DNS fallback queries domain names through the runtime's DNS resolver. The Actor does not include other input dataset columns. Bulk supplier files are deleted only after a completed or stopped job has a saved, validated report. If recovery or report storage fails, the file is retained for recovery; the run summary reports whether cleanup was confirmed and identifies any retained file. Abrupt platform termination can prevent cleanup; supplier retention rules then apply. Apify retention is controlled by your account settings.

Do not publish sensitive input or share your run's storage. Submit only data you are authorized to process. This Actor does not promise MillionVerifier's marketing refund guarantee applies to API verification.

Interrupted runs must be started as a new run; automatic restart is disabled to avoid duplicate results and billing. Successfully completed runs are not re-billed if resurrected. A saved bulk supplier report is retained in the private `PROVIDER_REPORT` record for recovery; `PROVIDER_FILE` records the supplier file identifier. The `OUTPUT` record contains counts and status; `RESULTS` contains a saved copy of generated rows if dataset publishing is interrupted. New-run verification is a separate billed operation, as disclosed above.

### Automate it

Run `myworkingmemory/email-verifier-bulk` through the Apify API, schedule it in Apify Console, or connect it to Apify MCP. Chain the `dataset_id` from your previous Actor, then filter `safe_to_send == true` before your next workflow step. The same result prices and pilot limits apply to Console, API and MCP runs.

### Connect through MCP

Add this server URL to a compatible MCP client such as Claude or Cursor, then authorize your Apify account. It preloads this Actor as a tool:

[Apify MCP — Email Verifier](https://mcp.apify.com/?tools=myworkingmemory/email-verifier-bulk)

```text
https://mcp.apify.com/?tools=myworkingmemory/email-verifier-bulk
```

Connecting does not start a run. Ask your agent to review the input and pricing before running; the same prices, input requirements and limits apply. See the [Apify MCP setup guide](https://docs.apify.com/mcp).

### More tools from Myworkingmemory

- [PDF & Word Metadata Cleaner](https://apify.com/myworkingmemory/document-metadata-cleaner) — Inspect metadata and create a separately verified cleaned copy.
- [Shopify Product Scraper](https://apify.com/myworkingmemory/shopify-store-extractor) — Extract Shopify product prices, inventory and variants.
- [Curated Finds](https://apify.com/myworkingmemory/software-library-search) — Discover curated GitHub tools and Hugging Face models.

Each Actor has its own inputs and pricing; follow its README before running. [Browse all our Actors](https://apify.com/myworkingmemory).

# Actor input Schema

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

One email per item. Original order and duplicate rows are preserved; duplicates do not incur another fee. Use this OR dataset_id. Keyless pilot: at most ten input rows; BYOK: up to 10,000.

## `dataset_id` (type: `string`):

Select an accessible Apify dataset with an email column. Use this OR emails. The keyless pilot accepts at most ten input rows; BYOK accepts up to 10,000.

## `email_field` (type: `string`):

Top-level dataset column containing a single email string.

## `mv_api_key` (type: `string`):

Use your real MillionVerifier API key, not API_KEY_FOR\_ demo keys or example placeholders. Optional on every Apify plan for a limited time, while the shared pilot allocation lasts. Supplying a key always selects BYOK and uses your own credits, independently of pilot availability. Invalid keys never fall back to owner credits. Stored encrypted by Apify. Pilot allocation exhausted. Add your MillionVerifier API key (mv_api_key) to continue using your own credits. No verification fee was charged.

## `mxFallback` (type: `boolean`):

On single-check service errors, return unbilled DNS diagnostics. DNS alone never produces safe_to_send=true.

## `verification_mode` (type: `string`):

BYOK: automatic uses realtime for up to 50 unique supported addresses, otherwise bounded bulk. Realtime is limited to 50 unique addresses. The keyless pilot uses realtime only and permits at most ten input rows.

## Actor input object example

```json
{
  "email_field": "email",
  "mxFallback": true,
  "verification_mode": "auto"
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("myworkingmemory/email-verifier-bulk").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("myworkingmemory/email-verifier-bulk").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 '{}' |
apify call myworkingmemory/email-verifier-bulk --silent --output-dataset

```

## MCP server setup

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

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/Gs5JXep3adEv7Lhpf/builds/IuteDcHyZdVBZ2QIr/openapi.json