# Disposable Email & Domain Checker — 5 Merged Lists ($0.30/1k) (`leadharbor/disposable-email-checker`) Actor

Disposable email checker: flags temp and free-provider emails or domains against 5 merged lists, refreshed weekly. $0.30 per 1,000.

- **URL**: https://apify.com/leadharbor/disposable-email-checker.md
- **Developed by:** [Mohammed Samaan](https://apify.com/leadharbor) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 email or domain checks

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

## Disposable Email & Domain Checker

Paste emails or domains. Each one comes back with:

- `disposable` — `true` if the domain is on a public throwaway-email list
- `freeProvider` — `true` for Gmail-style free mailboxes (Gmail, Yahoo, Outlook and similar)
- `matchedLists` — which of the five merged lists flagged it

It is a pure list lookup: no DNS calls, no browser, no proxy, no login. A run of 1,000 items finishes in seconds.

**Price: $0.30 per 1,000 checks** (pay per event, $0.0003 each) plus $0.001 per run start. Inputs that cannot be read as an email or domain are returned with an error and are not charged.

### What it checks against

Five public lists, merged. Each was checked for a licence that allows commercial use:

| List | Licence |
|---|---|
| disposable-email-domains/disposable-email-domains | CC0-1.0 |
| disposable/disposable-email-domains | MIT |
| FGRibreau/mailchecker | MIT |
| wesbos/burner-email-providers | MIT |
| Kikobeats/free-email-domains (free providers) | MIT |

The lists are refreshed from their public sources when the cached copy is more than 7 days old. If a refresh fails, the run uses the last good copy (or the copy bundled with the Actor) and still completes. Every row has `listsUpdatedAt` so you can see how fresh the data was. To force a refresh, tick **Refresh lists now**.

Subdomains are matched against their parent domain, so `a.b.guerrillamail.com` is flagged because `guerrillamail.com` is.

### Input

| Field | What it does |
|---|---|
| `inputs` | Emails, domains or URLs, one per line. Up to 100,000 per run. |
| `refreshLists` | Optional. Download the public lists again before checking. |

### Example output

Input: `throwaway@mailinator.com`, `jane@gmail.com`

```json
[
  {
    "input": "throwaway@mailinator.com",
    "type": "email",
    "domain": "mailinator.com",
    "valid": true,
    "disposable": true,
    "freeProvider": false,
    "matchedLists": ["disposable-email-domains", "disposable", "mailchecker", "burner-email-providers"],
    "matchedDomain": "mailinator.com",
    "listsUpdatedAt": "2026-10-05T10:09:51.295Z",
    "error": null
  },
  {
    "input": "jane@gmail.com",
    "type": "email",
    "domain": "gmail.com",
    "valid": true,
    "disposable": false,
    "freeProvider": true,
    "matchedLists": [],
    "matchedDomain": null,
    "listsUpdatedAt": "2026-10-05T10:09:51.295Z",
    "error": null
  }
]
```

`freeProvider` is `false` for disposable domains: those are reported as `disposable`, not as free providers.

### What it does not do

- It does not check whether a mailbox exists or whether a domain can receive mail. For that, use the [Bulk Email Verifier](https://apify.com/leadharbor/bulk-email-verifier).
- A domain missing from the lists is not proof that it is safe. New throwaway domains appear every day and the lists lag behind them.
- The lists are community-maintained. A domain on one list can occasionally be a false positive; `matchedLists` shows how many lists agree.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/leadharbor~disposable-email-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"inputs":["throwaway@mailinator.com","jane@gmail.com"]}'
```

Python, with the [apify-client](https://pypi.org/project/apify-client/) package:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("leadharbor/disposable-email-checker").call(
    run_input={"inputs": ["throwaway@mailinator.com", "jane@gmail.com"]}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["input"], row["disposable"], row["freeProvider"], row["matchedLists"])
```

### Difference from Bulk Email Verifier

| | Disposable Email & Domain Checker | [Bulk Email Verifier](https://apify.com/leadharbor/bulk-email-verifier) |
|---|---|---|
| Input | Emails **or bare domains or URLs** (`inputs`) | Email addresses (`emails`) |
| Disposable answer | `disposable` plus `matchedLists`, the per-list matches from the five merged lists | One verdict per address |
| Also checks | Free-provider flag only | MX lookup, SPF and DMARC presence, 0-100 score |
| Price | **$0.30 per 1,000** | $0.50 per 1,000 |

Use this Actor when you only need to know if a domain is throwaway and want it cheap. Use the verifier when you also need MX, SPF, DMARC and a score.

### FAQ

**Do I need to give full email addresses?**
No. Emails, bare domains (`mailinator.com`) and URLs all work. Only the domain part is checked.

**Does it contact the domain or the mailbox?**
No. It is a lookup against the merged lists. There are no DNS calls, so it does not tell you whether the domain can receive mail.

**What does `matchedLists` mean?**
The names of the lists that flagged the domain. More lists agreeing means a firmer match; a single list can be a false positive.

**Why is `freeProvider` false for a disposable domain?**
Disposable domains are reported as `disposable`, not as free providers.

**Does a `disposable: false` result mean the domain is safe?**
No. New throwaway domains appear daily and the lists lag behind them.

**How fresh are the lists?**
Refreshed from their public sources when the cached copy is over 7 days old. Each row has `listsUpdatedAt`. Tick **Refresh lists now** to force it.

**What happens to bad input?**
The row comes back with `valid: false` and an `error`, and is not charged.

**How many items per run?**
Up to 100,000.

### Find us on RapidAPI

- [Disposable Email Checker on RapidAPI](https://rapidapi.com/samaanmohammed/api/disposable-email-checker16): a REST API for single-email disposable checks, with a free plan.

### Related actors

- [Bulk Email Verifier](https://apify.com/leadharbor/bulk-email-verifier): MX, SPF, DMARC and a 0-100 score per email.
- [Domain Trust Check](https://apify.com/leadharbor/domain-trust-check): domain age, SSL, SPF/DKIM/DMARC and a 0-100 trust score.
- [Website Contact Extractor](https://apify.com/leadharbor/website-contact-extractor): pull emails and phones from business websites, then screen them here.
- [Google Maps Scraper, MX-Checked Business Email Leads](https://apify.com/leadharbor/google-maps-verified-email-scraper): business leads with emails from Google Maps.
- [Website Technology Detector](https://apify.com/leadharbor/website-tech-stack-detector) — Detects the CMS, frameworks, analytics and 100+ other technologies a website uses from its homepage. $9 per 1,000 sites.

# Actor input Schema

## `inputs` (type: `array`):

One email address or domain per line, e.g. jane@example.com or example.com. A full URL also works; only the domain is used. Subdomains are matched against their parent domain.

## `refreshLists` (type: `boolean`):

Download the public lists again before checking. Normally not needed: lists are refreshed automatically when they are more than 7 days old.

## Actor input object example

```json
{
  "inputs": [
    "throwaway@mailinator.com",
    "jane@gmail.com",
    "ceo@stripe.com",
    "guerrillamail.info"
  ],
  "refreshLists": false
}
```

# Actor output Schema

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

One row per input: disposable, freeProvider and the lists that matched.

## `resultsUi` (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 = {
    "inputs": [
        "throwaway@mailinator.com",
        "jane@gmail.com",
        "ceo@stripe.com",
        "guerrillamail.info"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadharbor/disposable-email-checker").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 = { "inputs": [
        "throwaway@mailinator.com",
        "jane@gmail.com",
        "ceo@stripe.com",
        "guerrillamail.info",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("leadharbor/disposable-email-checker").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 '{
  "inputs": [
    "throwaway@mailinator.com",
    "jane@gmail.com",
    "ceo@stripe.com",
    "guerrillamail.info"
  ]
}' |
apify call leadharbor/disposable-email-checker --silent --output-dataset

```

## MCP server setup

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

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/wcOtZQdRt1SUjKGY8/builds/8UzmF7eApdpW5EGrf/openapi.json