# Bulk Email Validation API — Email Checker & Fraud Risk Scoring (`red.cars/email-risk-scorer`) Actor

Bulk email validation API: validate email lists and score each address 0-1 for fraud and spam risk — disposable/temp domains, dead or typo'd domains (no MX), role accounts, plus an AI judgment layer for ambiguous cases, with machine-readable reasons. $0.004 per scored email, no subscription.

- **URL**: https://apify.com/red.cars/email-risk-scorer.md
- **Developed by:** [AutomateLab](https://apify.com/red.cars) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does Email Risk Scorer do?

**Email Risk Scorer** is an **email validation API** on the Apify platform: give it one address or a bulk list (up to 500 per run) and it returns a **fraud and spam risk score (0–1)** for each one — in seconds, with a documented reason for every score. It catches **disposable and temporary email addresses** (against a continuously maintained blocklist), broken and misspelled domains (no MX record), **role accounts** (`info@`, `support@`, `contact@`), and uses an **AI judgment layer** to assess ambiguous addresses that rule-based checkers ignore. One tool, two jobs: a bulk email validation and email checker for list cleaning, and a fraud risk scorer for signup protection.

It is not an email sender and does not send messages to the addresses — it never touches the inbox, so it is safe to run on any list.

### Why use Email Risk Scorer?

- **Stop fake signups** — block disposable and typo'd domains at signup before they pollute your SaaS database or trigger free-trial abuse
- **Clean lists before campaigns** — remove high-risk addresses before you hit Send, protecting your sender reputation and avoiding bounce-driven blacklisting
- **Score lead quality** — flag role accounts and high-risk domains in lead-gen data before your sales team dials
- **Explainable results** — every score ships with machine-readable reasons (`disposable_email_domain`, `no_mx_record_or_dns_error`, `role_account`, `ai_judgment:0.85`), so you can automate on them, not just read them
- **Runs inside Apify** — API access, scheduling, webhooks, and integrations with Zapier, Make, and Google Sheets. No separate vendor account, no CSV uploads to a third party.

### Sample results

Every scored address comes back with a **risk score, a risk level, and machine-readable reasons** — straight from a real run's dataset:

| Email | risk\_score | risk | reasons |
|---|---|---|---|
| jane.doe@gmail.com | 0.22 | low | `ai_judgment:0.22` |
| info@stripe.com | 0.30 | low | `role_account`, `ai_judgment:0.23` |
| john.doe@gmial.com | 0.85 | high | `no_mx_record_or_dns_error`, `ai_judgment:0.85` |
| user@mailinator.com | 1.0 | high | `disposable_email_domain` |
| not-an-email@@ | 1.0 | invalid\_syntax | `failed RFC5322 syntax check` |

Treat **`high`** as block-or-review and **`medium`** as flag; **`low`** is usually safe to keep. The `reasons` array is what makes the score automatable — for example, auto-block only `disposable_email_domain` and manually review the rest.

### How to validate email addresses with Email Risk Scorer

1. Open the Actor in [Apify Console](https://console.apify.com) or call it via the [Apify API](https://docs.apify.com/api/v2)
2. Paste your email addresses into the `emails` input field (**1–500 per run**; split larger lists across runs)
3. Optionally enable `checkMx` for live DNS/MX verification and `useAiJudgment` for the AI layer on ambiguous cases
4. Run the Actor — results appear in the dataset, typically within seconds (the very first run may take a little longer while the container starts)
5. Download results as **JSON, CSV, Excel, or HTML**, or fetch them via the API/webhook

#### Bulk email validation for list cleaning

The `emails` field accepts **up to 500 addresses per run**, so a full list cleanup is a single bulk email validation run — paste the list, run once, and download the scored dataset. Split larger lists across runs; the one-time start fee applies once per run, which is why batching the whole list is the cheapest way to validate in bulk.

### How much does email validation cost?

Email Risk Scorer uses **pay-per-event pricing**: **$0.004 per scored email** plus a **$0.005 one-time actor start fee** per run. **You pay only for successfully scored emails — failed emails are never billed.** **Charged:** every email that comes back with a risk score and reasons. **Not charged:** addresses that fail processing entirely — they return an `error` record with `risk_score: null`, so a transient failure never inflates your bill. There is no subscription, no monthly credits that expire, and no minimum commitment — a 500-email list cleanup costs about **$2.01**, and per-email pricing typically undercuts credit-based verification services — and you keep everything inside your existing Apify workflows.

### Input

| Field | Type | Description |
|---|---|---|
| `emails` | array | Email addresses to score (required) |
| `checkMx` | boolean | Verify DNS/MX records for each domain (default: true) |
| `useAiJudgment` | boolean | Enable the AI judgment layer for ambiguous addresses (default: true — works out of the box, no extra setup needed) |

### Output

Each result contains the verdict, the score, and the reasons:

```json
{
    "email": "john.doe@gmial.com",
    "valid": true,
    "domain": "gmial.com",
    "mx": null,
    "risk_score": 0.85,
    "risk": "high",
    "reasons": ["no_mx_record_or_dns_error", "ai_judgment:0.85"]
}
```

Low-risk addresses look like this:

```json
{
    "email": "jane.doe@gmail.com",
    "valid": true,
    "domain": "gmail.com",
    "mx": "alt2.gmail-smtp-in.l.google.com",
    "risk_score": 0.22,
    "risk": "low",
    "reasons": ["ai_judgment:0.22"]
}
```

| Field | Type | Meaning |
|---|---|---|
| `valid` | boolean | Passes the RFC5322 syntax check — syntax only; deliverability is what `mx` and `reasons` tell you |
| `risk_score` | number (0–1) | Composite fraud/spam risk |
| `risk` | string | `low` (<0.4), `medium` (0.4–0.7), `high` (≥0.7), or `invalid_syntax` when the address fails the syntax check |
| `mx` | string or null | Resolved mail exchanger for the domain; `null` when none is found or the DNS lookup fails |
| `reasons` | array | Machine-readable evidence for the score |

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Tips for accurate email risk scores

- Keep `checkMx` enabled — it is what catches typo'd and dead domains
- Treat `high` as "block or review" and `medium` as "flag"; `role_account` alone is often acceptable for B2B contacts
- Batch your list in one run — the $0.005 start fee applies once per run, so fill the 500-address batch instead of running small chunks
- Automate on `reasons`, not just `risk`: for example, auto-block only `disposable_email_domain`

#### Is it legal to check email addresses for risk?

Email validation uses public DNS records and syntax analysis — no login to the mailbox, no messages sent, no personal mailbox data accessed. Validate addresses you collected legitimately, and follow GDPR/CAN-SPAM rules for how you use the results.

#### Does it detect disposable and temporary emails?

Yes — disposable and temporary domains are checked against a continuously maintained blocklist, so new throwaway domains are caught without you updating anything.

#### Does the AI judgment layer work out of the box?

Yes — `useAiJudgment` defaults to on and needs no configuration; ambiguous addresses get an AI-assessed score out of the box.

#### Does it need proxies or logins?

No. The Actor runs DNS lookups and local analysis only. Runs complete in seconds and cost nothing in compute units beyond the platform minimum.

#### Can I bulk validate a full email list?

Yes — the `emails` input is an array, so you can bulk validate up to 500 addresses per run. For longer lists, split them across runs; every address gets its own risk score and machine-readable reasons in the same dataset.

#### Are failed emails charged?

No — you pay only for successfully scored emails. If an address cannot be processed, it comes back as an error record with `risk_score: null` and **no charge event is emitted** for it. A domain with no MX record is a different case: that is a scored result (`no_mx_record_or_dns_error`) and is billed, because you received a verdict. The one-time $0.005 start fee applies per run regardless of outcome, which is why batching up to 500 addresses per run keeps it negligible.

#### Can I try it before paying?

Yes — every Apify account, including the free plan, comes with monthly platform usage credits that pay for pay-per-event charges, so you can run a small batch of email risk scoring before committing to anything (the free plan requires no credit card). A 50-address test run costs about **$0.21**, comfortably inside the free plan's monthly credits.

#### Do you store, send, or expose my email addresses?

No messages are ever sent and no mailbox is accessed — scoring uses syntax checks, public DNS/MX records, and disposable-domain matching. An address with no clear rule-based signal may additionally be assessed by an AI risk-judgment API; nothing is ever delivered to the address. Results live only in your run's dataset, downloadable as JSON, CSV, Excel, or HTML.

#### How is this different from prepaid-credit email verifiers?

You pay per scored email — no subscription, no credit bundles that expire, no minimum. And instead of a bare valid/invalid verdict you get a 0–1 fraud/spam risk score with machine-readable reasons (`disposable_email_domain`, `no_mx_record_or_dns_error`, `role_account`, `ai_judgment:*`), so signup protection and list cleaning run on evidence instead of guesses.

### FAQ, disclaimers, and support

- **It scored a valid-looking address as high risk.** Check the `reasons` array — the score is evidence-based, and the AI layer only activates for genuinely ambiguous cases
- **Feedback and feature requests:** open an issue on the Actor's **Issues** tab
- **Programmatic access:** see the **API** tab for endpoints and examples
- *Disclaimer: risk scores are decision-support signals, not guarantees. Do not use them as the sole basis for denying service.*

More purpose-built Actors from **red.cars** are on the way — follow the creator to see new tools as they publish.

# Actor input Schema

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

List of email addresses. Each scored email is one billable event. 1-500 per run.

## `useAiJudgment` (type: `boolean`):

Route ambiguous cases (no hard signal) through an AI risk judgment. Requires OPENROUTER\_API\_KEY secret on the actor.

## `checkMx` (type: `boolean`):

Verify the domain accepts mail (MX/DNS lookup).

## Actor input object example

```json
{
  "emails": [
    "satya.nadella@microsoft.com",
    "info@gmail.com",
    "user@mailinator.com",
    "john.doe@gmial.com",
    "contact@stripe.com"
  ],
  "useAiJudgment": true,
  "checkMx": true
}
```

# Actor output Schema

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

One record per address: email, valid, domain, mx, risk\_score (0-1), risk level, and machine-readable reasons. Downloadable as JSON, CSV, Excel, or HTML.

# 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": [
        "satya.nadella@microsoft.com",
        "info@gmail.com",
        "user@mailinator.com",
        "john.doe@gmial.com",
        "contact@stripe.com"
    ],
    "useAiJudgment": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("red.cars/email-risk-scorer").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": [
        "satya.nadella@microsoft.com",
        "info@gmail.com",
        "user@mailinator.com",
        "john.doe@gmial.com",
        "contact@stripe.com",
    ],
    "useAiJudgment": True,
}

# Run the Actor and wait for it to finish
run = client.actor("red.cars/email-risk-scorer").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": [
    "satya.nadella@microsoft.com",
    "info@gmail.com",
    "user@mailinator.com",
    "john.doe@gmial.com",
    "contact@stripe.com"
  ],
  "useAiJudgment": true
}' |
apify call red.cars/email-risk-scorer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,red.cars/email-risk-scorer"
        }
    }
}
```

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/yQIp5mxAOomeFXgXC/builds/f2igzQSTTuo7gwWjF/openapi.json