# Disposable Email Domains Scraper (`muhammadafzal/disposable-email-domains-scraper`) Actor

Scrape a daily-updated disposable email domain list or check domains and addresses for signup abuse, CRM cleanup, and fraud screening.

- **URL**: https://apify.com/muhammadafzal/disposable-email-domains-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 domain 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

## Disposable Email Domains Scraper

> **Free-plan limit:** Apify free-plan runs can return at most **5 dataset records per run** from this Actor, even if you request more.

Scrape a daily-updated disposable email domain catalogue or check domains and email addresses for signup-abuse prevention, CRM cleanup, lead qualification, and fraud screening.

The Actor reads the public `disposable/disposable-email-domains` lists directly on every run. It returns normalized, deduplicated records and clearly distinguishes the normal blocklist, strict-only greylist entries, and domains that are not listed. No API key, browser, proxy, DNS lookup, mailbox access, or SMTP connection is required.

### What it extracts

| Field | Meaning |
| --- | --- |
| `query` | Original value supplied in `check` mode; `null` for catalogue exports |
| `domain` | Normalized lowercase ASCII domain |
| `isDisposable` | Whether the selected catalogue matched the domain or a parent domain |
| `classification` | `normal`, `strict-only`, or `not-listed` |
| `matchedDomain` | Exact catalogue entry that matched, including parent-domain matches |
| `isSubdomainMatch` | Whether a listed parent matched a queried subdomain |
| `sourceList` | `normal`, `strict`, or `none` |
| `sourceUrl` | Direct upstream file used for the result |
| `sourceUpdatedAt` | Latest repository push time when GitHub metadata is available |
| `scrapedAt` | UTC time when the record was created |

Results are stored in the default dataset and can be exported as JSON, JSONL, CSV, Excel, XML, RSS, or HTML. Every run also writes a `SUMMARY` key-value record with source counts, matched and delivered counts, warnings, and the estimated event cost.

### When to use it

Use this Actor to:

- block known temporary email services during registration;
- classify an existing list of email domains before importing leads;
- export a current disposable-domain blocklist into a database or security pipeline;
- compare conservative normal-list filtering with stricter anonymous-signup filtering;
- feed stable domain classifications to an AI agent, Make, Zapier, or your own API workflow.

Do not use it to prove that a mailbox exists, that an address can receive mail, or that a domain is malicious. A `not-listed` result means only that the selected community catalogue did not contain the domain at run time. Catch-all mailboxes, aliases, forwarding services, private relay addresses, newly launched temporary services, and stale community entries require separate policy decisions.

### Input

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `operation` | `scrape` or `check` | `scrape` | Export catalogue rows or classify supplied values |
| `listType` | `normal` or `strict` | `normal` | Strict adds domains from the anonymous-signup greylist |
| `queries` | string array | `[]` | Domains or email addresses for `check` mode; up to 10,000 |
| `includeNotListed` | boolean | `true` | In `check` mode, include domains absent from the selected list |
| `offset` | integer | `0` | Skip sorted catalogue rows in `scrape` mode |
| `maxResults` | integer | `100` | Maximum delivered rows, from 1 to 75,000 |

#### Scrape the first 500 normal-list domains

```json
{
  "operation": "scrape",
  "listType": "normal",
  "offset": 0,
  "maxResults": 500
}
```

#### Check domains and email addresses

```json
{
  "operation": "check",
  "listType": "strict",
  "queries": [
    "mailinator.com",
    "person@gmail.com",
    "user@sub.mailinator.com"
  ],
  "includeNotListed": true,
  "maxResults": 100
}
```

Duplicate inputs that normalize to the same domain are emitted once. Unicode domains are converted to ASCII/Punycode. When a subdomain is supplied, the Actor checks it and each parent domain against the selected list.

### Output example

```json
{
  "query": "user@sub.mailinator.com",
  "domain": "sub.mailinator.com",
  "isDisposable": true,
  "classification": "normal",
  "matchedDomain": "mailinator.com",
  "isSubdomainMatch": true,
  "sourceList": "normal",
  "sourceUrl": "https://raw.githubusercontent.com/disposable/disposable-email-domains/master/domains.txt",
  "sourceUpdatedAt": "2026-08-29T09:37:55.000Z",
  "scrapedAt": "2026-08-30T10:00:00.000Z"
}
```

### Pay-per-event pricing

Current Apify event prices and platform-usage treatment are listed in the dedicated [Pricing section](#pricing) below.

Platform usage is included in event prices. A default 100-row scrape costs up to **$1.10005** in events. A 500-row export costs up to **$5.50005**. A check that delivers 10 deduplicated rows costs up to **$0.11005**. Filtering out unlisted domains reduces the delivered rows and result events. Apify's run-level maximum charge is respected by the platform.

### Reliability and limits

The Actor uses bounded direct HTTP requests to two public raw GitHub files, with 30-second request timeouts and up to three attempts for transient rate-limit or server failures. It validates source integrity before writing results and refuses to fabricate rows when the source is unavailable or unexpectedly malformed. The default input returns quickly and does not need an Apify Proxy.

The upstream project states that entries were disposable at some point but cannot guarantee every listed domain is still disposable. The lists are community maintained, so false positives and false negatives are possible. Treat the result as one abuse-prevention signal and maintain an allowlist for trusted customer domains when appropriate.

### API use

Start the Actor with the Apify API or an Apify client, wait for it to finish, then read the default dataset. The Actor output schema exposes direct links named `results` and `summary`, which makes the output discoverable to API clients and AI agents. Do not place your Apify token in a public URL or log.

### Data and legal notes

This Actor processes only the input values you provide and public domain-list data. Email local parts may appear in `query` output when you submit full addresses, so avoid sending personal data unless you have a lawful purpose and appropriate retention controls. The upstream catalogue is MIT licensed; consult its repository for attribution and contribution guidance. Use filtering in accordance with your contracts, privacy obligations, and anti-discrimination policies.

### Support

If a run fails, include the run ID, redacted input, expected outcome, and the `SUMMARY` record in your Apify issue. For incorrect classifications, verify the current upstream list first; additions and removals should be proposed to the source project with evidence.

### Pricing

This Actor uses **pay-per-event** pricing. These are the current Apify Store event prices:

| Event | Price (USD) | When it is charged |
|---|---:|---|
| `apify-default-dataset-item` | FREE: $0.011; BRONZE: $0.01; SILVER: $0.009; GOLD: $0.007; PLATINUM: $0.007; DIAMOND: $0.007 | Domain result — One normalized, schema-valid domain classification written to the default dataset. |
| `apify-actor-start` | $0.00005 | Actor Start — Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). — Charged once per run. |

Apify platform usage for this Actor run is included alongside the event prices above; no separate per-run platform-usage fee is passed to users.

This covers Apify platform usage for this Actor run. Other Apify products or usage outside this Actor run may still follow your account plan.

# Changelog

This Actor's version history is a separate document: https://apify.com/muhammadafzal/disposable-email-domains-scraper/changelog.md

# Actor input Schema

## `operation` (type: `string`):

Use scrape to export catalogue rows, or check to classify supplied domains/emails. Default is scrape; this does not perform SMTP validation.

## `listType` (type: `string`):

Use normal for known disposable services or strict to include anonymous-signup greylist domains. Default is normal.

## `queries` (type: `array`):

Use only with check. Enter domains or emails such as mailinator.com or user@mailinator.com; 1–10,000 values. Duplicates are removed.

## `includeNotListed` (type: `boolean`):

Use with check to emit a row for queries absent from the selected catalogue. Default true; false returns matches only.

## `offset` (type: `integer`):

Use with scrape to skip sorted catalogue rows before output. Default 0; range 0–74,999.

## `maxResults` (type: `integer`):

Use to cap dataset rows after filtering. Default 100; range 1–75,000. One dataset-item event is charged per delivered row.

## Actor input object example

```json
{
  "operation": "scrape",
  "listType": "normal",
  "queries": [
    "mailinator.com",
    "person@gmail.com"
  ],
  "includeNotListed": true,
  "offset": 0,
  "maxResults": 100
}
```

# Actor output Schema

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

Schema-validated domain records in the default dataset.

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

Outcome, source counts, delivered count, warnings, and cost estimate.

# 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 = {
    "operation": "scrape",
    "listType": "normal",
    "queries": [
        "mailinator.com",
        "person@gmail.com"
    ],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/disposable-email-domains-scraper").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 = {
    "operation": "scrape",
    "listType": "normal",
    "queries": [
        "mailinator.com",
        "person@gmail.com",
    ],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/disposable-email-domains-scraper").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 '{
  "operation": "scrape",
  "listType": "normal",
  "queries": [
    "mailinator.com",
    "person@gmail.com"
  ],
  "maxResults": 100
}' |
apify call muhammadafzal/disposable-email-domains-scraper --silent --output-dataset

```

## MCP server setup

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

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/MbBm0GcgvICz3fQV4/builds/68Fn1DagY1afLX9Di/openapi.json