# Email MX & Deliverability Verifier (`fetch_cat/email-mx-deliverability-verifier`) Actor

Validate email lists with syntax, MX, disposable-domain, role-account, and deliverability risk checks before outreach.

- **URL**: https://apify.com/fetch\_cat/email-mx-deliverability-verifier.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 email checkeds

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

## Email MX & Deliverability Verifier

Validate email lists before outreach with syntax checks, public domain mail-server checks, disposable-domain flags, role-account detection, and a simple deliverability risk score.

Use this Apify Actor when you have a lead list, recruiting list, newsletter export, CRM upload, or enrichment dataset and want to quickly separate safer emails from risky ones before sending campaigns.

### What does Email MX & Deliverability Verifier do?

Email MX & Deliverability Verifier checks each email address you provide and returns a structured dataset with the most useful deliverability signals.

It can:

- ✅ Normalize and deduplicate email addresses
- ✅ Detect invalid email syntax
- ✅ Parse the mailbox domain
- ✅ Check whether the domain has MX mail records
- ✅ Check an A-record fallback when no MX record is present
- ✅ Flag common disposable or temporary email domains
- ✅ Flag role accounts such as `info@`, `support@`, and `admin@`
- ✅ Assign a practical risk level: `low`, `medium`, `high`, or `unknown`
- ✅ Return machine-readable reason codes for filtering and automation

### Who is it for?

This actor is useful for teams that work with email lists regularly.

- 📈 **Sales teams** can clean prospect lists before sending sequences.
- 🧲 **Lead generation agencies** can add validation signals to scraped or purchased leads.
- 👥 **Recruiters** can check candidate contact lists before outreach.
- 🛒 **E-commerce operators** can audit customer or partner exports.
- 🧪 **Data enrichment teams** can add email-quality columns to downstream workflows.
- 🧰 **No-code operators** can validate lists from Apify datasets, CSV exports, or pasted text.

### Why use it?

Bad email lists waste time, damage sender reputation, and create noisy CRM data.

This actor gives you fast, explainable checks that are easy to export and combine with other data. It does not claim that an inbox exists, but it helps identify addresses that are clearly malformed, risky, disposable, role-based, or attached to domains without visible mail routing.

### What checks are included?

The first version focuses on safe public signals.

- Syntax validation
- Domain extraction
- MX record check
- Optional A-record fallback check
- Disposable-domain check
- Role-account check
- Risk-level assignment
- Reason-code output

### What is not included?

This actor does not log into email providers and does not require private credentials.

It also does not perform mandatory SMTP mailbox probing in version 1. SMTP probing can be slow, blocked by mail servers, inaccurate due to catch-all domains, and potentially intrusive at scale. The actor instead focuses on stable public signals that are suitable for batch workflows.

### Data returned

| Field | Description |
| --- | --- |
| `email` | Original email string after trimming |
| `normalizedEmail` | Lowercase normalized email when syntax is valid |
| `validSyntax` | Whether the address has valid email syntax |
| `domain` | Parsed domain from the address |
| `mxFound` | Whether MX mail records were found |
| `mxRecords` | MX records with priority and exchange host |
| `aRecordFallbackFound` | Whether an A record exists when no MX was found |
| `isDisposable` | Whether the domain is a known temporary mailbox provider |
| `isRoleAccount` | Whether the mailbox is a role account |
| `riskLevel` | `low`, `medium`, `high`, or `unknown` |
| `reasonCodes` | Machine-readable reasons such as `MX_FOUND` or `INVALID_SYNTAX` |
| `checkedAt` | ISO timestamp for the check |

### How much does it cost to verify email deliverability?

The actor uses pay-per-event pricing.

You pay a $0.005 run-start fee plus a per-email fee for each checked email saved to the dataset. Current tiered per-email prices are approximately: FREE $0.0000667, BRONZE $0.0000580, SILVER $0.0000452, GOLD $0.0000348, PLATINUM $0.0000232, and DIAMOND $0.0000162.

For planning, this type of utility is designed for bulk checks such as hundreds or thousands of emails. Keep your first run small, confirm the output columns match your workflow, then scale to larger lists.

### Input options

You can provide email addresses in three ways.

1. `emails` — a direct array of email strings.
2. `csvText` — pasted text containing email addresses separated by commas, semicolons, spaces, tabs, or new lines.
3. `datasetId` — an Apify dataset ID plus the field name that contains emails.

You can combine these options in one run. Duplicates are normalized and checked once.

### Example input

```json
{
  "emails": [
    "support@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "checkMx": true,
  "checkARecordFallback": true,
  "includeDisposableCheck": true,
  "maxConcurrency": 20,
  "dnsProvider": "google"
}
````

### How to run it

1. Open the actor on Apify.
2. Paste a few email addresses into the input.
3. Keep the default checks enabled.
4. Start the run.
5. Open the dataset when the run finishes.
6. Filter by `riskLevel`, `validSyntax`, `mxFound`, or `reasonCodes`.
7. Export the results to CSV, JSON, Excel, or API.

### Output example

```json
{
  "email": "support@example.com",
  "normalizedEmail": "support@example.com",
  "validSyntax": true,
  "domain": "example.com",
  "mxFound": true,
  "mxRecords": [
    { "priority": 0, "exchange": "." }
  ],
  "aRecordFallbackFound": false,
  "isDisposable": false,
  "isRoleAccount": true,
  "riskLevel": "medium",
  "reasonCodes": ["ROLE_ACCOUNT", "MX_FOUND"],
  "checkedAt": "2026-07-03T00:00:00.000Z"
}
```

### Understanding risk levels

`low` means the address syntax is valid, the domain has mail routing, and no major risk flags were detected.

`medium` means the address may still be usable, but it has a caution flag such as a role mailbox or weak fallback domain evidence.

`high` means the address is clearly invalid, disposable, or attached to a domain without useful mail-routing signals.

`unknown` means a DNS check failed, so the actor could not confidently classify deliverability.

### Tips for better results

- Start with 10–20 emails to confirm your workflow.
- Use `datasetId` when validating output from another Apify actor.
- Keep `checkMx` enabled for most production runs.
- Keep `includeDisposableCheck` enabled for lead-gen lists.
- Treat `riskLevel` as a filtering signal, not a legal or compliance decision.
- Review `reasonCodes` when building automated rules.

### Integrations

You can use the results in common automation workflows.

- Export to Google Sheets or Excel for manual review.
- Feed low-risk emails into CRM import workflows.
- Send high-risk rows to a cleanup queue.
- Combine with lead scrapers to validate contacts before sales outreach.
- Use Apify webhooks to trigger the next step after a run succeeds.
- Read the dataset from the Apify API in your backend.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/email-mx-deliverability-verifier').call({
  emails: ['support@example.com', 'bad-email'],
  checkMx: true,
  checkARecordFallback: true,
  includeDisposableCheck: true
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/email-mx-deliverability-verifier').call(run_input={
    'emails': ['support@example.com', 'bad-email'],
    'checkMx': True,
    'checkARecordFallback': True,
    'includeDisposableCheck': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~email-mx-deliverability-verifier/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"emails":["support@example.com","bad-email"],"checkMx":true}'
```

### MCP usage

Use the Apify MCP server to run this actor from AI tools that support Model Context Protocol.

MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/email-mx-deliverability-verifier
```

Claude Code setup example:

```bash
claude mcp add apify-email-verifier https://mcp.apify.com/?tools=fetch_cat/email-mx-deliverability-verifier
```

MCP JSON configuration example:

```json
{
  "mcpServers": {
    "apify-email-verifier": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/email-mx-deliverability-verifier"
    }
  }
}
```

Example prompts:

- "Verify these 50 emails and return only high-risk rows."
- "Check this Apify dataset of leads and summarize how many have MX records."
- "Run the email verifier and prepare a CSV of low-risk contacts."

### Working with Apify datasets

If another actor produced a dataset with an `email` column, copy its dataset ID into `datasetId`.

If the field has a different name, set `datasetEmailField` to that column name. For example, use `workEmail`, `contactEmail`, or `emailAddress` depending on your dataset.

### Limits and reliability

The actor checks public signals and is suitable for batch workflows.

Very large runs depend on the number of email addresses and current DNS response times. If you see `unknown` risk levels, retry those rows later or lower concurrency.

### Legality and responsible use

Only validate email addresses you are allowed to process. Follow applicable privacy, anti-spam, and data-protection laws, including rules for consent, retention, and outreach.

This actor provides technical validation signals. You remain responsible for how you use the data.

### FAQ

#### Does this guarantee an inbox exists?

No. The actor checks syntax and public domain-level signals. It does not guarantee that a specific mailbox accepts mail.

#### Why is a role account marked medium risk?

Role accounts such as `info@` and `support@` can be valid, but they often represent teams, aliases, or generic inboxes rather than an individual lead.

#### Why did a valid-looking email return high risk?

The domain may have no MX record and no A-record fallback, or it may be a disposable-domain provider.

#### Why did some rows return unknown?

A DNS lookup failed or timed out. Retry those rows later or reduce concurrency.

### Related Apify actors

You can combine this actor with other Apify lead-generation, search, and enrichment actors from the same Apify account to build a complete prospecting workflow.

### Changelog

- Initial version: syntax, MX, A-record fallback, disposable-domain, role-account, risk-level, and reason-code output.

# Actor input Schema

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

Paste email addresses to validate. Duplicates are normalized and checked once per run.

## `csvText` (type: `string`):

Optional pasted CSV, newline, comma, semicolon, or whitespace separated email list.

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

Optional Apify dataset ID to read email addresses from.

## `datasetEmailField` (type: `string`):

Field name containing email addresses when datasetId is used.

## `checkMx` (type: `boolean`):

Look up public DNS MX records for each valid email domain.

## `checkARecordFallback` (type: `boolean`):

If no MX record exists, check whether the domain has an A record as a weak fallback signal.

## `includeDisposableCheck` (type: `boolean`):

Flag common temporary or disposable mailbox providers.

## `dnsProvider` (type: `string`):

DNS-over-HTTPS provider. Google is currently supported.

## `maxConcurrency` (type: `integer`):

Number of email addresses to verify in parallel. Keep low for small test runs.

## Actor input object example

```json
{
  "emails": [
    "support@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "datasetEmailField": "email",
  "checkMx": true,
  "checkARecordFallback": true,
  "includeDisposableCheck": true,
  "dnsProvider": "google",
  "maxConcurrency": 20
}
```

# 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 = {
    "emails": [
        "support@example.com",
        "sales@gmail.com",
        "bad-email",
        "test@mailinator.com"
    ],
    "datasetEmailField": "email"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/email-mx-deliverability-verifier").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": [
        "support@example.com",
        "sales@gmail.com",
        "bad-email",
        "test@mailinator.com",
    ],
    "datasetEmailField": "email",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/email-mx-deliverability-verifier").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": [
    "support@example.com",
    "sales@gmail.com",
    "bad-email",
    "test@mailinator.com"
  ],
  "datasetEmailField": "email"
}' |
apify call fetch_cat/email-mx-deliverability-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email MX & Deliverability Verifier",
        "description": "Validate email lists with syntax, MX, disposable-domain, role-account, and deliverability risk checks before outreach.",
        "version": "0.1",
        "x-build-id": "Dw9KTmeoWdIo39Fow"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~email-mx-deliverability-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-email-mx-deliverability-verifier",
                "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/fetch_cat~email-mx-deliverability-verifier/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-email-mx-deliverability-verifier",
                "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/fetch_cat~email-mx-deliverability-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-email-mx-deliverability-verifier",
                "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 validate. Duplicates are normalized and checked once per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "csvText": {
                        "title": "CSV or pasted text",
                        "type": "string",
                        "description": "Optional pasted CSV, newline, comma, semicolon, or whitespace separated email list."
                    },
                    "datasetId": {
                        "title": "Input dataset ID",
                        "type": "string",
                        "description": "Optional Apify dataset ID to read email addresses from."
                    },
                    "datasetEmailField": {
                        "title": "Dataset email field",
                        "type": "string",
                        "description": "Field name containing email addresses when datasetId is used.",
                        "default": "email"
                    },
                    "checkMx": {
                        "title": "Check MX records",
                        "type": "boolean",
                        "description": "Look up public DNS MX records for each valid email domain.",
                        "default": true
                    },
                    "checkARecordFallback": {
                        "title": "Check A-record fallback",
                        "type": "boolean",
                        "description": "If no MX record exists, check whether the domain has an A record as a weak fallback signal.",
                        "default": true
                    },
                    "includeDisposableCheck": {
                        "title": "Flag disposable email domains",
                        "type": "boolean",
                        "description": "Flag common temporary or disposable mailbox providers.",
                        "default": true
                    },
                    "dnsProvider": {
                        "title": "DNS provider",
                        "enum": [
                            "google"
                        ],
                        "type": "string",
                        "description": "DNS-over-HTTPS provider. Google is currently supported.",
                        "default": "google"
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of email addresses to verify in parallel. Keep low for small test runs.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```