# Email Verifier Pro | $0.85/1k - Bulk Email Validator (`blessiticus/email-verifier-pro`) Actor

Verify email addresses in bulk with real SMTP checks. Detect disposable, role-based, and catch-all emails. CSV upload, live progress, smart retries. Cheapest full-SMTP verifier on the Store at $0.85/1k emails.

- **URL**: https://apify.com/blessiticus/email-verifier-pro.md
- **Developed by:** [Mohammad Palekar](https://apify.com/blessiticus) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 6 total users, 2 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.85 / 1,000 results

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/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

## Email Verifier Pro | $0.85/1k — Bulk Email Validation & List Cleaning

Verify email addresses at scale with **real SMTP checks** — not just syntax validation. Email Verifier Pro connects directly to mail servers to confirm whether a mailbox actually exists, giving you the most accurate results possible.

**Stop wasting money on bounced emails.** Whether you're doing cold outreach, cleaning your CRM, or validating lead lists, this actor tells you exactly which emails are safe to send to and which ones will bounce.

### Why Email Verifier Pro?

| Feature | Email Verifier Pro | Other Actors |
|:---|:---:|:---:|
| **Price per 1,000 emails** | **$0.85** | $1.00 – $9.00 |
| Real SMTP verification | ✅ | Some ❌ |
| Disposable email detection | ✅ | Some ❌ |
| Catch-all domain detection | ✅ | Some ❌ |
| Role-based email detection | ✅ | Rare |
| Free provider detection | ✅ | Rare |
| CSV URL upload | ✅ | ❌ Most are JSON-only |
| Live progress tracking | ✅ | ❌ |
| Smart retry on failures | ✅ | ❌ |
| No external API key needed | ✅ | ❌ Many require 3rd-party accounts |

### Use Cases

- **Cold email outreach** — Verify your prospect list before sending to protect your sender reputation and avoid getting flagged as spam
- **Marketing campaigns** — Clean your email list to reduce bounce rates and improve deliverability metrics
- **CRM maintenance** — Remove invalid, disposable, and role-based emails from your database on a regular schedule
- **Lead generation** — Validate scraped email lists to ensure you're only reaching out to real people
- **E-commerce** — Verify customer email addresses at checkout to reduce failed order confirmations
- **Data enrichment pipelines** — Chain with other Apify actors: scrape emails → verify → export clean list

### How It Works

Email Verifier Pro performs **7 checks** on every email address:

#### Why Choose Email Verifier Pro?
- ⚡ **Lightning Fast:** Defaults to 10 simultaneous connections. Verify massive lists in minutes, not hours.
- 🎯 **Deep SMTP Validation:** We don't just check syntax. We talk directly to the target mail server.
- 💰 **Cheapest Full-SMTP Validation:** Just $0.85 per 1,000 emails. Others charge $2.00+ for the same accuracy.
- 🎁 **100 Email Free Trial:** Users on the free Apify plan can fetch up to 100 leads per run to test the accuracy before paying!
- 🛡️ **Role-Based & Disposable Detection:** Automatically flags `info@`, `admin@`, and temporary inboxes.
- 🔗 **Keeps Your Original Data:** Upload a CSV with names, companies, and custom IDs. We'll append the verification results without throwing away your original columns!
- 📈 **Live Progress Tracking:** See valid/invalid ratios in real-time as your list processes.)

1. **Syntax validation** — Is the email format correct? (`user@domain.com`)
2. **MX record lookup** — Does the domain have a mail server configured?
3. **SMTP handshake** — Can we connect to the mail server and confirm the mailbox exists?
4. **Disposable detection** — Is it a temporary/throwaway email? (Mailinator, Guerrilla Mail, etc.)
5. **Role-based detection** — Is it a generic address? (`info@`, `support@`, `admin@`)
6. **Catch-all detection** — Does the domain accept emails to any address? (makes verification unreliable)
7. **Free provider detection** — Is it Gmail, Yahoo, Outlook, or another free email service?

### Input

You can provide emails in **three ways** (use any one or combine them):

#### Option 1: Paste emails directly
Use the **Email Addresses** field to paste a list of emails, one per line.

#### Option 2: CSV file URL
Paste a URL to a CSV file in the **CSV File URL** field. We automatically detect the email column — or you can specify it manually. Supports:
- Direct download links
- Google Sheets (published as CSV)
- Dropbox shared links

#### Option 3: Apify Dataset ID
If you've already scraped emails with another actor, paste the **Dataset ID** in the corresponding field. We'll read the emails directly — no need to export and re-upload.

#### Advanced Settings

| Setting | Default | Description |
|:---|:---|:---|
| Concurrency | 10 | Emails verified simultaneously (1–30) |
| Max Retries | 2 | Retry count for temporary SMTP failures |
| Timeout | 30s | Max wait time per email |
| Max Emails | No limit | Cap the number of emails per run (up to 50,000) |

### Output

Each email produces a result row containing all of your original input columns (if you used a CSV or Dataset), plus our appended verification fields:

```json
{
    "email": "john@company.com",
    "status": "valid",
    "is_reachable": "safe",
    "is_disposable": false,
    "is_role_based": false,
    "is_catch_all": false,
    "is_free_provider": false,
    "syntax_valid": true,
    "mx_exists": true,
    "smtp_reachable": true,
    "mx_host": "alt1.aspmx.l.google.com",
    "smtp_response": "250 OK — Mailbox exists",
    "error_message": "",
    "verified_at": "2026-06-14T12:00:00Z"
}
````

#### Business Status (`status`)

| Status | Meaning | Action |
|:---|:---|:---|
| `valid` | ✅ Mailbox exists and accepts email | Safe to send |
| `invalid` | ❌ Mailbox doesn't exist or domain has no mail server | Remove from list |
| `risky` | ⚠️ Mailbox exists but may be a catch-all, disposable, or role-based | Review manually |
| `unknown` | ❓ Could not determine — server timeout or temporary error | Retry later |

#### Technical Details

We expose the raw technical signals so you can build your own custom logic:

- `is_reachable`: Raw Reacher API status (`safe`, `invalid`, `risky`, `unknown`)
- `smtp_reachable`: Boolean indicating if the SMTP server responded to our handshake
- `smtp_response`: The exact response message from the mail server (e.g., "550 User unknown")
- `mx_exists`: Boolean indicating if the domain has valid mail servers configured

Results are available as **JSON**, **CSV**, **Excel**, or **HTML** — download from the Dataset tab after the run completes.

### How to Reduce Email Bounce Rates

High bounce rates damage your sender reputation and can get your domain blacklisted. Here's how to use Email Verifier Pro to keep your lists clean:

1. **Before every campaign**: Run your list through Email Verifier Pro. Remove all `invalid` emails and review `risky` ones.
2. **Monthly CRM cleaning**: Schedule recurring runs to catch emails that have become invalid over time (employees leave, domains expire).
3. **At the point of collection**: Verify emails in real-time using the [Apify API](https://docs.apify.com/api/v2) to reject invalid addresses before they enter your database.

### Pricing

**$0.85 per 1,000 emails verified** — the most affordable full-SMTP verification on the Apify Store.

- No external API keys required
- No hidden fees or dual billing
- No monthly subscription — pay only for what you use
- You are charged per email verified (pay-per-event)

#### Cost Examples

| List Size | Cost |
|:---|:---|
| 1,000 emails | $0.85 |
| 10,000 emails | $8.50 |
| 50,000 emails | $42.50 |
| 100,000 emails | $85.00 |

### Frequently Asked Questions

#### How accurate is the verification?

We perform a **real SMTP handshake** with the recipient's mail server — the same process an actual email uses. This gives 95%+ accuracy for most providers. Catch-all domains are the exception: these accept all emails regardless, so we flag them as `risky` rather than giving a false `valid`.

#### How fast is the verification?

With the default concurrency of 10, you can verify approximately **1,000 emails every 2 to 3 minutes** depending on how quickly the recipient mail servers respond. Gmail and Outlook are typically fast; smaller providers may be slower.

#### Can I verify Gmail, Outlook, and Yahoo addresses?

Yes! We verify emails across all providers including Gmail, Outlook/Hotmail, Yahoo, custom domains, and more.

#### What happens if my run is interrupted?

Results are pushed to the dataset **in real-time** — if your run stops partway through, all emails verified up to that point are saved. Simply run the remaining emails in a new run.

#### Can I chain this with other Apify actors?

Absolutely! Scrape emails with any actor, then pass the Dataset ID directly to Email Verifier Pro. No export/import needed.

#### Is there a rate limit?

Yes — we cap at **50,000 emails per run** to maintain verification quality. For larger lists, split into multiple runs.

### Integrations

Email Verifier Pro can be connected with almost any cloud service or web app thanks to integrations on the Apify platform. You can easily integrate with:

- **Make.com** & **Zapier** (Automate list cleaning when new leads arrive)
- **n8n** (Build self-hosted verification workflows)
- **Clay** & **Apollo** (Enrich and verify outbound prospects)
- **Google Sheets** (Verify rows automatically)

### API Usage & Code Examples

You can run this Actor programmatically using the [Apify API](https://docs.apify.com/api/v2) and official clients.

#### JavaScript/Node.js

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

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

const run = await client.actor("YOUR_USERNAME/email-verifier-pro").call({
    emails: ["test@gmail.com", "contact@company.com"],
    concurrency: 10
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("YOUR_USERNAME/email-verifier-pro").call(run_input={
    "emails": ["test@gmail.com", "contact@company.com"],
    "concurrency": 10
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Apify CLI

```bash
echo '{
  "emails": [
    "test@gmail.com",
    "contact@company.com"
  ]
}' | apify call YOUR_USERNAME/email-verifier-pro --output-dataset
```

### Support

Found a bug or have a suggestion? Open an issue in the **Issues** tab — I respond within 24 hours.

# Actor input Schema

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

Paste email addresses to verify. One per line.

## `csvUrl` (type: `string`):

URL to a CSV file containing email addresses. Supports direct links, Google Sheets (published as CSV), and Dropbox links. The email column is auto-detected, or you can specify it below.

## `datasetId` (type: `string`):

ID of an existing Apify dataset containing emails. Useful for chaining with other actors (e.g., scrape emails → verify them).

## `emailColumn` (type: `string`):

Name of the column containing email addresses in your CSV or dataset. Leave empty for auto-detection (looks for columns named 'email', 'e-mail', 'Email Address', etc.).

## `concurrency` (type: `integer`):

Number of emails to verify simultaneously. Higher = faster but may trigger rate limits on some mail servers.

## `maxRetries` (type: `integer`):

How many times to retry a verification if the mail server times out or returns a temporary error. Set to 0 to disable retries.

## `timeout` (type: `integer`):

Maximum time to wait for each email verification. Increase this if you're verifying emails on slow or overloaded mail servers.

## `maxEmails` (type: `integer`):

Maximum number of emails to verify in this run. Leave empty for no limit.

## `freeTierNotice` (type: `string`):

Try up to 100 emails for free using the Apify Free Trial (configure in your Apify settings).

## Actor input object example

```json
{
  "emails": [
    "test@gmail.com",
    "nonexistent12345@gmail.com"
  ],
  "csvUrl": "https://docs.google.com/spreadsheets/d/.../export?format=csv",
  "datasetId": "abc123def456",
  "emailColumn": "",
  "concurrency": 10,
  "maxRetries": 2,
  "timeout": 30,
  "freeTierNotice": " "
}
```

# Actor output Schema

## `defaultDatasetUrl` (type: `string`):

URL to the dataset containing the verification results

# 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": [
        "test@gmail.com",
        "nonexistent12345@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("blessiticus/email-verifier-pro").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": [
        "test@gmail.com",
        "nonexistent12345@gmail.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("blessiticus/email-verifier-pro").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": [
    "test@gmail.com",
    "nonexistent12345@gmail.com"
  ]
}' |
apify call blessiticus/email-verifier-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Verifier Pro | $0.85/1k - Bulk Email Validator",
        "description": "Verify email addresses in bulk with real SMTP checks. Detect disposable, role-based, and catch-all emails. CSV upload, live progress, smart retries. Cheapest full-SMTP verifier on the Store at $0.85/1k emails.",
        "version": "1.0",
        "x-build-id": "bdQ2w7pO35OjUJt3X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/blessiticus~email-verifier-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-blessiticus-email-verifier-pro",
                "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/blessiticus~email-verifier-pro/runs": {
            "post": {
                "operationId": "runs-sync-blessiticus-email-verifier-pro",
                "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/blessiticus~email-verifier-pro/run-sync": {
            "post": {
                "operationId": "run-sync-blessiticus-email-verifier-pro",
                "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 Addresses",
                        "type": "array",
                        "description": "Paste email addresses to verify. One per line.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "test@gmail.com",
                            "nonexistent12345@gmail.com"
                        ]
                    },
                    "csvUrl": {
                        "title": "CSV File URL",
                        "type": "string",
                        "description": "URL to a CSV file containing email addresses. Supports direct links, Google Sheets (published as CSV), and Dropbox links. The email column is auto-detected, or you can specify it below."
                    },
                    "datasetId": {
                        "title": "Apify Dataset ID",
                        "type": "string",
                        "description": "ID of an existing Apify dataset containing emails. Useful for chaining with other actors (e.g., scrape emails → verify them)."
                    },
                    "emailColumn": {
                        "title": "Email Column Name",
                        "type": "string",
                        "description": "Name of the column containing email addresses in your CSV or dataset. Leave empty for auto-detection (looks for columns named 'email', 'e-mail', 'Email Address', etc.).",
                        "default": ""
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of emails to verify simultaneously. Higher = faster but may trigger rate limits on some mail servers.",
                        "default": 10
                    },
                    "maxRetries": {
                        "title": "Max Retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry a verification if the mail server times out or returns a temporary error. Set to 0 to disable retries.",
                        "default": 2
                    },
                    "timeout": {
                        "title": "Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time to wait for each email verification. Increase this if you're verifying emails on slow or overloaded mail servers.",
                        "default": 30
                    },
                    "maxEmails": {
                        "title": "Maximum Emails (Optional)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of emails to verify in this run. Leave empty for no limit."
                    },
                    "freeTierNotice": {
                        "title": "ℹ️ Notice",
                        "type": "string",
                        "description": "Try up to 100 emails for free using the Apify Free Trial (configure in your Apify settings).",
                        "default": " "
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```