# Fast Email Validator (`dxbear/fast-email-validator`) Actor

Validate email leads in bulk with high speed and accuracy. Detect invalid, disposable, and risky addresses to keep your data clean and improve deliverability.

- **URL**: https://apify.com/dxbear/fast-email-validator.md
- **Developed by:** [Dxbear](https://apify.com/dxbear) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 email validates

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Fast Email Validator — Bulk Email Verification & Lead Validation

> ⚡ Validate email leads in bulk with high speed and accuracy. Detect invalid, disposable, catch-all, and risky addresses to keep your data clean and improve email deliverability.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-1a73e8)](https://apify.com/dxbear/fast-email-validator)
[![Email Validation](https://img.shields.io/badge/Task-Email%20Validation-brightgreen)](https://apify.com/dxbear/fast-email-validator)
[![Bulk Processing](https://img.shields.io/badge/Feature-Bulk%20Processing-orange)](https://apify.com/dxbear/fast-email-validator)

---

### 🚀 Overview

**Fast Email Validator** is a high-performance [Apify Actor](https://docs.apify.com/platform/actors) built for marketers, sales teams, and growth hackers who need to clean and verify email lists at scale. Designed for speed and accuracy, it helps you:

- ✅ **Reduce bounce rates** and protect your sender reputation
- ✅ **Filter out disposable**, temporary, and risky email addresses
- ✅ **Detect catch-all domains** and privacy-protected addresses
- ✅ **Enrich leads** with provider identification and MX record data

Ideal for **lead generation**, **email marketing campaigns**, **CRM data hygiene**, and **cold sales outreach automation**.

---

### ✨ Key Features

| Feature | Description |
|---|---|
| ⚡ **Bulk Validation at Scale** | Process thousands of emails in minutes — no more manual checks |
| 🎯 **Higher Deliverability** | Remove invalid addresses before sending to improve inbox placement |
| 💰 **Cost Efficiency** | Pay only for validated emails; stop wasting ad spend on bad leads |
| 🔍 **Rich Data Enrichment** | Get provider info, MX records, and risk flags to segment leads smarter |
| 🔄 **Seamless Automation** | Integrate via [Apify API](https://docs.apify.com/api/v2), [webhooks](https://docs.apify.com/platform/integrations/webhooks), or [Apify Integrations](https://docs.apify.com/platform/integrations) |
| 🤖 **AI & Agent Ready** | Connect to [Apify's MCP Server](https://docs.apify.com/platform/integrations/mcp) for AI agents, LLM pipelines, and autonomous workflows |

---

### 📥 Input Format

Provide a JSON object with an array of email addresses to validate. You can configure the input through the [Apify Console](https://console.apify.com/) or programmatically via the [Actor API](https://docs.apify.com/api/v2).

```json
{
  "emails": [
    "support@zuplo.com",
    "mobile@anthropic.com",
    "julian@anthropic.com"
  ]
}
````

***

### 📤 Output Format

Each validated email returns a detailed JSON object with deliverability signals, MX records, and risk flags.

#### Example Response

```json
[
  {
    "domain": "zuplo.com",
    "email": "support@zuplo.com",
    "role": true,
    "mx": true,
    "deliverable": true,
    "catchall": false,
    "provider": "Google Workspace",
    "disposable": false,
    "privacy": false,
    "mx_record": {
      "aspmx.l.google.com": 1,
      "alt1.aspmx.l.google.com": 5,
      "alt2.aspmx.l.google.com": 5,
      "alt3.aspmx.l.google.com": 10,
      "alt4.aspmx.l.google.com": 10
    }
  },
  {
    "domain": "anthropic.com",
    "email": "mobile@anthropic.com",
    "role": false,
    "mx": true,
    "deliverable": true,
    "catchall": true,
    "provider": "Google Workspace",
    "disposable": false,
    "privacy": false,
    "mx_record": {
      "aspmx.l.google.com": 1,
      "alt1.aspmx.l.google.com": 5,
      "alt2.aspmx.l.google.com": 5,
      "alt3.aspmx.l.google.com": 10,
      "alt4.aspmx.l.google.com": 10
    }
  }
]
```

#### 🔑 Output Fields Reference

| Field | Type | Description |
|---|---|---|
| `email` | `string` | The validated email address |
| `domain` | `string` | The domain portion of the email address |
| `deliverable` | `boolean` | `true` if the address is syntactically valid, has MX records, and accepts mail at the SMTP level |
| `mx` | `boolean` | `true` if the domain has valid MX (Mail Exchange) DNS records |
| `catchall` | `boolean` | `true` if the domain accepts mail for any address, making individual mailbox verification unreliable |
| `role` | `boolean` | `true` if the address is a role-based account (e.g. `support@`, `info@`, `admin@`) |
| `disposable` | `boolean` | `true` if the address belongs to a known disposable/temporary email service |
| `privacy` | `boolean` | `true` if the address uses a privacy-protection or masking service |
| `provider` | `string` | The detected email service provider (e.g. `Google Workspace`, `Microsoft 365`) |
| `mx_record` | `object` | A map of MX hostnames to their priority values as returned by DNS |

***

### 💰 Pricing

Validation is priced per email with automatic volume discounts. See [Apify Platform Pricing](https://apify.com/pricing) for plan details and [Usage & Billing](https://docs.apify.com/platform/usage-and-billing) for how Actor consumption is calculated.

| Tier | Price Per Email |
|---|---|
| No discount | $0.008 |
| 🥉 Bronze discount | $0.007 |
| 🥈 Silver discount | $0.006 |
| 🥇 Gold discount | $0.005 |

> 🎁 **Pro Tip:** Upgrade your [Apify subscription plan](https://apify.com/pricing) to unlock automatic volume discounts and priority processing.

***

### 🛠️ How to Use

#### 1. Via Apify Console

1. Go to [Fast Email Validator on Apify Store](https://apify.com/dxbear/fast-email-validator)
2. Click **Start** to open the Actor input
3. Paste your email list in JSON format into the input field
4. Click **Run** and monitor progress in real-time from the run log

> 📖 New to Apify? Read the [Getting Started Guide](https://docs.apify.com/platform/actors/running) to learn how to run your first Actor.

#### 2. Via Apify API

Use the [Apify API](https://docs.apify.com/api/v2) to trigger validation programmatically. This is ideal for integrating email verification into your existing pipelines, CRMs, or automation tools.

```bash
curl -X POST "https://api.apify.com/v2/acts/dxbear~fast-email-validator/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "emails": [
      "support@zuplo.com",
      "mobile@anthropic.com"
    ]
  }'
```

> 📖 For full API reference, see the [Apify API v2 Documentation](https://docs.apify.com/api/v2).

#### 3. Via Apify Client (JavaScript / Node.js)

If you're building custom scrapers or automation scripts, you can call the Actor directly using the [Apify JavaScript Client](https://docs.apify.com/api/client/js):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('dxbear/fast-email-validator').call({
  emails: ['support@zuplo.com', 'mobile@anthropic.com'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### 4. Schedule Recurring Validations

Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the Actor periodically — perfect for ongoing CRM hygiene and list maintenance.

***

### 🤖 AI Agent & MCP Server Integration

Fast Email Validator is fully compatible with [Apify's MCP Server](https://docs.apify.com/platform/integrations/mcp), enabling seamless integration with AI-powered workflows:

- 🧠 **AI Agents** — Let autonomous agents validate leads during research or outreach
- 🔄 **LLM Pipelines** — Pre-clean data before feeding into RAG systems or prompt chains
- ⚙️ **Agentic Workflows** — Build self-correcting lead qualification loops

**Example use case:**

> An AI sales agent scrapes LinkedIn → validates emails in real-time → only engages with deliverable, non-role addresses → logs qualified leads to your CRM.

🔗 **Learn more:** [Apify MCP Server Documentation](https://docs.apify.com/platform/integrations/mcp)

***

### 🎯 Ideal Use Cases

- **Cold Email Campaigns** — Clean your prospect list before sending to avoid spam traps and protect domain reputation
- **Lead Magnet Forms** — Validate emails at point-of-capture to improve database quality
- **CRM Data Hygiene** — Periodically audit and update contact records to reduce stale data
- **Ad Audience Building** — Ensure lookalike audiences are built on verified, deliverable emails
- **Partnership Outreach** — Verify contact emails before reaching out to potential partners
- **B2B Lead Generation** — Pair with [Apify Scrapers](https://apify.com/store) to build and validate lead lists end-to-end

***

### 📊 Performance Tips

- ✅ **Batch emails** in groups of 500–1,000 for optimal throughput
- ✅ **Filter early** — Remove obviously invalid formats before sending to the Actor to save on usage
- ✅ **Use webhooks** — Get instant notifications when validation completes via [Apify Webhooks](https://docs.apify.com/platform/integrations/webhooks)
- ✅ **Cache results** — Store validation outcomes in the [Apify Dataset](https://docs.apify.com/platform/storage/dataset) or your own database to avoid re-checking
- ✅ **Schedule runs** — Automate recurring validations with [Apify Schedules](https://docs.apify.com/platform/schedules)

***

### ❓ Frequently Asked Questions

**Q: How fast is the email validation?**
A: Typically 40–50 emails per minute depending on domain complexity, MX server response times, and network conditions.

**Q: Does this check if an inbox is full or inactive?**
A: We perform SMTP-level checks where possible, but cannot guarantee 100% deliverability due to server policies. A `deliverable: true` result means the address is syntactically valid, has MX records, and accepts mail at the protocol level.

**Q: Can I use this for GDPR-compliant workflows?**
A: Yes. We do not store your email data beyond the run duration. Always ensure you have a lawful basis for processing personal data under applicable regulations. See [Apify's Security & Compliance](https://docs.apify.com/platform/security) for more details.

**Q: What happens with catch-all domains?**
A: Catch-all domains accept mail for any address, making individual mailbox verification impossible. These are flagged with `catchall: true` so you can handle them according to your risk tolerance.

**Q: Is there a limit on how many emails I can validate?**
A: There is no hard limit. The Actor will process as many emails as you provide, constrained only by your [Apify plan's usage limits](https://docs.apify.com/platform/usage-and-billing).

***

### 🔗 Integrations & Resources

| Resource | Link |
|---|---|
| 📚 Apify Actor Documentation | [docs.apify.com/platform/actors](https://docs.apify.com/platform/actors) |
| 🔌 Apify API v2 Reference | [docs.apify.com/api/v2](https://docs.apify.com/api/v2) |
| 🤖 Apify MCP Server | [docs.apify.com/platform/integrations/mcp](https://docs.apify.com/platform/integrations/mcp) |
| 💻 Apify JS Client | [docs.apify.com/api/client/js](https://docs.apify.com/api/client/js) |
| 🗄️ Apify Dataset Storage | [docs.apify.com/platform/storage/dataset](https://docs.apify.com/platform/storage/dataset) |
| ⏱️ Apify Schedules | [docs.apify.com/platform/schedules](https://docs.apify.com/platform/schedules) |
| 🔗 Apify Webhooks | [docs.apify.com/platform/integrations/webhooks](https://docs.apify.com/platform/integrations/webhooks) |
| 💰 Apify Pricing | [apify.com/pricing](https://apify.com/pricing) |
| 🛡️ Security & Compliance | [docs.apify.com/platform/security](https://docs.apify.com/platform/security) |
| 💬 Apify Community (Discord) | [discord.gg/jyEM2PRvMU](https://discord.gg/jyEM2PRvMU) |

***

### 🤝 Support & Contributions

- 📚 **Docs:** [Apify Actor Documentation](https://docs.apify.com/platform/actors)
- 💬 **Community:** [Apify Discord Server](https://discord.gg/jyEM2PRvMU)
- 🐛 **Bug Reports:** Open an issue on the [Actor page](https://apify.com/dxbear/fast-email-validator)
- ✉️ **Contact:** Reach out via the Actor's Apify Store page
- ✨ **Feature Requests:** Open a discussion or issue with the `enhancement` label

***

> 🔐 **Data Privacy Notice:** Fast Email Validator processes emails transiently. No email content or metadata is retained after the Actor run completes. For full details, see [Apify's Privacy Policy](https://apify.com/privacy-policy) and [Security Documentation](https://docs.apify.com/platform/security).

***

**Ready to clean your leads and boost campaign performance?**

▶️ [**Run Fast Email Validator on Apify**](https://apify.com/dxbear/fast-email-validator)

*Built for marketers. Engineered for scale. Validated for results.* 🚀

# Actor input Schema

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

List of email addresses to validate. Each item should be a valid email string.

## Actor input object example

```json
{
  "emails": [
    "ahmed@scravity.com",
    "jakub@apify.com",
    "hello@anthropic.com"
  ]
}
```

# Actor output Schema

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

List of validated email records including deliverability, MX records, provider info and more.

# 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": [
        "ahmed@scravity.com",
        "jakub@apify.com",
        "hello@anthropic.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dxbear/fast-email-validator").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": [
        "ahmed@scravity.com",
        "jakub@apify.com",
        "hello@anthropic.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("dxbear/fast-email-validator").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 '{
  "emails": [
    "ahmed@scravity.com",
    "jakub@apify.com",
    "hello@anthropic.com"
  ]
}' |
apify call dxbear/fast-email-validator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fast Email Validator",
        "description": "Validate email leads in bulk with high speed and accuracy. Detect invalid, disposable, and risky addresses to keep your data clean and improve deliverability.",
        "version": "1.0",
        "x-build-id": "zzpdnFsIL9SY5hzd6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dxbear~fast-email-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dxbear-fast-email-validator",
                "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/dxbear~fast-email-validator/runs": {
            "post": {
                "operationId": "runs-sync-dxbear-fast-email-validator",
                "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/dxbear~fast-email-validator/run-sync": {
            "post": {
                "operationId": "run-sync-dxbear-fast-email-validator",
                "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": {
                    "emails": {
                        "title": "Email List",
                        "minItems": 1,
                        "maxItems": 10000,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of email addresses to validate. Each item should be a valid email string.",
                        "items": {
                            "type": "string",
                            "pattern": "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}$"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
