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

Pull the complete maintained list of disposable, temporary, and throwaway email domains. Detect Mailinator, Guerrilla Mail, 10MinuteMail, YOPmail, and thousands more. Export to JSON, CSV, or Excel to validate signups, block fraud, clean CRM lists, and protect lead quality pipelines.

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

## Pricing

from $9.00 / 1,000 result items

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📧 Disposable Email Domains Scraper

> 🚀 **Export the disposable-email blocklist in seconds.** Pull **5,000+ throwaway email providers** for signup-form fraud prevention. Domains, MX-verified, strict superset, or SHA1-hashed variants. No API key, no registration, no manual list curation.

> 🕒 **Last updated:** 2026-05-23 · **📊 6 fields** per record · **🛡️ 5,000+ domains** · **🗂️ 4 list variants** · **🚫 Anti-fraud focus**

The **Disposable Email Domains Scraper** exports the community-maintained list of disposable, throwaway, and one-time-use email providers (Mailinator, 10MinuteMail, Guerrilla Mail, Temp-Mail, and 5,000+ more). Each record carries **6 fields**: domain, list variant, disposable flag, total list size, and timestamps. You can also pass a single domain and get back a one-row boolean answer ready for live signup-form validation.

Coverage spans **four canonical list variants**: the standard `domains` blocklist, the `mx`-verified subset (currently resolving MX), the broadest `strict` superset (includes parked and aliased domains), and a `sha1`-hashed variant for privacy-preserving lookups. This Actor turns each list into a CSV, Excel, JSON, or XML download you can wire straight into a fraud-prevention pipeline.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| SaaS onboarding teams, anti-fraud engineers, growth analysts, security teams, community-platform admins, marketing-ops | Signup-form validation, lead-quality scoring, free-trial abuse prevention, anti-spam enforcement, deliverability hygiene, CRM cleanup |

---

### 📋 What the Disposable Email Domains Scraper does

Three core workflows in a single run:

- 📥 **Full list export.** Dump any of the four list variants in one pass.
- 🔍 **Substring filter.** Return only domains containing a target string (`mailinator`, `temp`, `10min`, etc).
- ✅ **Single-domain check.** Pass one domain and get a boolean answer for live API gating.

Each record returns the domain, the source list, a boolean disposable flag, the total list size at run time, and timestamps.

> 💡 **Why it matters:** disposable-email signups drive most free-trial abuse, fake-account fraud, and bot-traffic distortion. A 5,000-domain blocklist refreshed weekly removes roughly 80-90% of the throwaway accounts that target SaaS signup flows.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to wire the list into a Make.com signup-validation flow._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>list</td><td>string</td><td>"domains"</td><td>One of domains, mx, strict, sha1.</td></tr>
<tr><td>domainFilter</td><td>string</td><td>""</td><td>Return only domains containing this substring (case-insensitive).</td></tr>
<tr><td>exactDomain</td><td>string</td><td>""</td><td>Check a single domain. Returns one row with a boolean result.</td></tr>
</tbody>
</table>

**Example: dump the strict superset of disposable domains.**

```json
{
    "maxItems": 5000,
    "list": "strict"
}
````

**Example: live signup-form check for one specific domain.**

```json
{
    "maxItems": 1,
    "list": "domains",
    "exactDomain": "mailinator.com"
}
```

> ⚠️ **Good to Know:** disposable-email vendors register new throwaway domains constantly. A weekly refresh is the most common cadence; high-fraud verticals (crypto, marketplaces, virtual-events) refresh daily.

***

### 📊 Output

Each record contains **6 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📧 `domain` | string | `"mailinator.com"` |
| 🗂️ `list` | string | `"domains"` |
| 🚫 `isDisposable` | boolean | `true` |
| 📊 `totalListSize` | number | `5247` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T00:00:00.000Z"` |
| ❌ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>📧 Bulk list export entry</strong></summary>

```json
{
    "domain": "mailinator.com",
    "list": "domains",
    "isDisposable": true,
    "totalListSize": 5247,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>✅ Single-domain check result (positive)</strong></summary>

```json
{
    "domain": "10minutemail.com",
    "list": "strict",
    "isDisposable": true,
    "totalListSize": 18420,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>✅ Single-domain check result (negative)</strong></summary>

```json
{
    "domain": "gmail.com",
    "list": "domains",
    "isDisposable": false,
    "totalListSize": 5247,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🛡️ | **Comprehensive blocklist.** 5,000+ disposable-email providers in the default list, 18,000+ in the strict superset. |
| 🗂️ | **Four list variants.** Pick the right tradeoff between recall and precision for your use case. |
| ✅ | **Single-domain live check.** Real-time gating with one boolean response. |
| 🔁 | **Always fresh.** Pulls the latest community-maintained list on every run. |
| 🔐 | **SHA1-hashed variant.** Privacy-preserving lookups for compliance-sensitive workflows. |
| ⚡ | **Fast.** 5,000 domains in seconds, single-domain check in milliseconds. |
| 🚫 | **No authentication.** Works against the public blocklist source. No login or key needed. |

> 📊 Every dollar of free-trial abuse, fake-signup fraud, and bot traffic that the list intercepts is dollars not spent on incident response, support tickets, and skewed analytics.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Variants | Setup |
|---|---|---|---|---|---|
| **⭐ Disposable Email Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **5,000-18,000+** disposable domains | **Live per run** | domains, mx, strict, sha1 | ⚡ 2 min |
| Manual GitHub list pulls | Free | Single variant | Manual | One | 🐢 Build pipeline |
| Commercial fraud APIs | $99-999+/month | Full | Realtime | Many | ⏳ Hours |
| Self-curated regex | Free | Tiny | Manual | None | 🕒 Variable |

Pick this Actor when you want a fresh, multi-variant blocklist on demand without paying for a full fraud-detection suite.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Disposable Email Domains Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a list variant, optionally add a substring filter or single-domain check, set `maxItems`.
4. 🚀 **Run it.** Click **Start** and the Actor pulls the list.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛡️ SaaS Onboarding & Anti-Fraud

- Signup-form blocklist to stop free-trial farming
- Lead-quality scoring with disposable-email penalty
- Account-takeover prevention on password resets
- Trial-to-paid conversion analytics cleanup

</td>
<td width="50%" valign="top">

#### 📈 Growth & Marketing Ops

- Email-list hygiene before campaign sends
- Lead-source quality dashboards
- Webinar and event-registration deduplication
- Inflated MAU/DAU correction

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 💬 Community & UGC Platforms

- Comment-spam and review-spam prevention
- Forum signup gating
- Marketplace-seller verification
- Multi-account abuse detection

</td>
<td width="50%" valign="top">

#### 🏦 Fintech, Crypto & Marketplaces

- KYC pre-screening before identity checks
- Crypto signup gating in high-risk verticals
- Subscription-fraud prevention
- Refund-abuse pattern detection

</td>
</tr>
</table>

***

### 🔌 Automating Disposable Email Domains Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily or weekly refreshes keep your fraud-prevention rules current as new disposable providers come online.

***

### 🌟 Beyond business use cases

Anti-fraud signals have reach well beyond commercial SaaS. The same data supports research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Email-deliverability research datasets
- Signup-fraud measurement studies
- Networking and security course assignments
- Academic comparisons of blocklist coverage

</td>
<td width="50%">

#### 🎨 Personal and creative

- Privacy-tool development side projects
- Indie SaaS signup-form gating
- Personal CRM dedup and cleanup scripts
- Hobby forum admin tools

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Volunteer-signup integrity for civic campaigns
- Petition-platform deduplication
- Open-source community-platform hygiene
- Free clinic and food-bank intake-form validation

</td>
<td width="50%">

#### 🧪 Experimentation

- Train fraud-classification models with real-world labels
- Build agentic onboarding flows with live gating
- Prototype email-validation microservices
- A/B test signup gating impact on conversion

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Disposable%20Email%20Domains%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Disposable%20Email%20Domains%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Disposable%20Email%20Domains%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Disposable%20Email%20Domains%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a list variant (domains, mx, strict, or sha1), optionally add a substring filter or single-domain check, set `maxItems`, click Start, and the Actor returns one clean structured record per domain.

#### 📏 How accurate is the list?

The underlying source is community-maintained and updated continuously. The default `domains` list focuses on confirmed disposable providers (high precision). The `strict` variant includes parked and aliased domains (broader recall, lower precision). Pick the variant that matches your tolerance for false positives.

#### 🔁 How often is the list refreshed?

The source list is updated continuously. Every run of this Actor fetches live data. Daily or weekly cron schedules are the most common cadence for production fraud-prevention pipelines.

#### 🗂️ What is the difference between the four list variants?

- `domains`: the default high-precision disposable blocklist
- `mx`: subset with currently resolving MX records
- `strict`: broadest superset including parked and aliased domains
- `sha1`: hashed domain list for privacy-preserving lookups

#### ✅ Can I use this for live signup-form validation?

Yes. Use the `exactDomain` input to check a single domain per call. The Actor returns one row with a boolean result. For high-volume real-time checks, cache the full list locally and refresh daily.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to refresh the list on any cron interval. A daily refresh is the standard cadence for high-fraud verticals; weekly works for most SaaS signup flows.

#### ⚖️ Is this data legal to use?

The disposable-email blocklist is publicly available open data. Using it to gate signup forms is standard fraud-prevention practice and widely deployed across SaaS, fintech, and marketplace platforms.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan unlocks the full blocklist and daily scheduling.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, inspect the log, fix the input, and re-run. Partial datasets from failed runs are preserved.

#### 🔐 What is the SHA1 variant for?

For compliance-sensitive workflows where you cannot store raw email domain strings. Hash the user's email domain locally and compare against the SHA1 list for a privacy-preserving disposable check.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Disposable Email Domains Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get fraud-prevention alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe the blocklist into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push the refreshed list into your auth service or alert security teams when new domains appear.

***

### 🔗 Recommended Actors

- [**📧 Greenhouse Jobs Scraper**](https://apify.com/parseforge/greenhouse-jobs-scraper) - Company career-page job listings
- [**🛡️ FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - Broker and advisor regulatory records
- [**🏛️ Florida DFS Licensee Scraper**](https://apify.com/parseforge/florida-dfs-licensee-scraper) - State financial-services license records
- [**📊 ImportYeti Scraper**](https://apify.com/parseforge/importyeti-scraper) - U.S. import and shipment records
- [**🩺 ClinicalTrials.gov Scraper**](https://apify.com/parseforge/clinicaltrials-gov-scraper) - Registered clinical trials worldwide

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more fraud-prevention and reference scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by any disposable-email service or blocklist maintainer. All trademarks mentioned are the property of their respective owners. Only publicly available blocklist data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `list` (type: `string`):

Which list to export.

## `domainFilter` (type: `string`):

Only return domains containing this substring (case-insensitive).

## `exactDomain` (type: `string`):

Check whether one specific domain (e.g. mailinator.com) is on the blocklist. Returns one row with a boolean result.

## Actor input object example

```json
{
  "maxItems": 10,
  "list": "domains"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "list": "domains"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "maxItems": 10,
    "list": "domains",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/disposable-email-domains-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "list": "domains"
}' |
apify call parseforge/disposable-email-domains-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/disposable-email-domains-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Disposable Email Domains Scraper",
        "description": "Pull the complete maintained list of disposable, temporary, and throwaway email domains. Detect Mailinator, Guerrilla Mail, 10MinuteMail, YOPmail, and thousands more. Export to JSON, CSV, or Excel to validate signups, block fraud, clean CRM lists, and protect lead quality pipelines.",
        "version": "1.0",
        "x-build-id": "YnbT8wQ6zHRrmhikM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~disposable-email-domains-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-disposable-email-domains-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~disposable-email-domains-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-disposable-email-domains-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~disposable-email-domains-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-disposable-email-domains-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "list": {
                        "title": "List",
                        "enum": [
                            "domains",
                            "mx",
                            "strict",
                            "sha1"
                        ],
                        "type": "string",
                        "description": "Which list to export."
                    },
                    "domainFilter": {
                        "title": "Domain Substring Filter",
                        "type": "string",
                        "description": "Only return domains containing this substring (case-insensitive)."
                    },
                    "exactDomain": {
                        "title": "Check Single Domain",
                        "type": "string",
                        "description": "Check whether one specific domain (e.g. mailinator.com) is on the blocklist. Returns one row with a boolean result."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
