# Email MX Verifier (`maximedupre/email-mx-verifier`) Actor

Check email syntax, MX records, disposable domains, role addresses, free providers, typo suggestions, and delivery risk. Export clean rows for CRM, outreach, signup, and data workflows.

- **URL**: https://apify.com/maximedupre/email-mx-verifier.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 checked emails

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 verifier for clean email lists

Email MX Verifier checks email addresses before you upload them to a CRM, outreach tool, signup gate, or data pipeline. Paste a list of emails and get one row per checked address with syntax status, MX records, disposable-domain detection, role-address flags, free-provider detection, typo suggestions, confidence scores, and a clear send/review/suppress recommendation.

Use it as a bulk email verifier or email list cleaner when you already have the email addresses and need to know which ones are safe enough to keep. The Actor does not need user credentials, cookies, or third-party API keys. Standard mode uses public DNS checks and list-cleaning rules. Deep SMTP mode can optionally probe the target MX server without sending an email and reports ambiguous mailbox checks as `unknown` instead of failing the run.

For a small first run, keep the prefilled examples. They include a normal mailbox, a public developer contact, a disposable domain, a role address, a common typo, and an invalid string so you can see the full output shape quickly.

### ✅ What this bulk email verifier checks

- Email syntax and common formatting problems.
- Domain MX records and sorted MX host evidence.
- Known disposable or temporary email domains.
- Role-based addresses such as `admin@`, `support@`, `sales@`, and `noreply@`.
- Free email providers such as Gmail, Yahoo, Outlook, Proton Mail, Zoho, and Fastmail.
- Common domain typos such as `gmai.com` to `gmail.com`.
- Mail provider hints from MX hosts where they are recognizable.
- Optional SPF, DMARC, and common DKIM selector checks for domain health.
- Optional SMTP and catch-all probes in Deep SMTP mode.

The output is designed for filtering and exports. You can sort by `status`, `riskLevel`, `confidenceScore`, or `recommendedDisposition`, then send the dataset to CSV, Excel, Google Sheets, the Apify API, webhooks, schedules, or your own workflow.

### 📊 What data you get

Each dataset row represents one submitted email address after normalization and deduplication. Rows can include:

| Field | Description |
| --- | --- |
| `inputEmail` | Original email string you entered. |
| `normalizedEmail` | Lowercased email when syntax is valid. |
| `inputIndex` | Position of the email in your submitted list. |
| `status` | `valid`, `risky`, `invalid`, or `unknown`. |
| `isValid` | `true` when the standard checks consider the address usable. |
| `syntaxValid`, `syntaxErrors` | Syntax verdict and specific format issues. |
| `domain`, `hasMxRecords`, `mxRecords`, `mxProvider` | MX record check and source evidence. |
| `isDisposable`, `isRoleBased`, `roleType`, `isFreeProvider` | List-cleaning signals for filtering and segmentation. |
| `riskLevel`, `confidenceScore`, `recommendedDisposition` | Practical decision fields for send, review, retry, or suppress workflows. |
| `suggestedEmail` | Suggested correction for supported typo domains. |
| `domainHealth` | SPF, DMARC, and common DKIM selector checks when enabled. |
| `smtp`, `catchAll` | Deep SMTP evidence when selected. |
| `degradedReason`, `error`, `retryRecommended`, `checkedAt` | Audit and follow-up context. |

### 🚀 How to run it

1. Open the Actor input.
2. Add email addresses in **Email addresses**.
3. Keep **Verification depth** on **Standard** for a fast email MX check.
4. Use **Deep SMTP** only when mailbox-level evidence matters more than speed.
5. Start the Actor and open the dataset when the run finishes.

Standard mode is the best default for most list-cleaning work. Deep SMTP can be slower and some mail servers block or hide mailbox checks, especially large providers. When that happens, the row keeps the DNS evidence and marks the SMTP result as `unknown` with `retryRecommended`.

### 🧾 Input example

```json
{
	"emails": [
		"user@gmail.com",
		"contact@github.com",
		"test@mailinator.com",
		"admin@microsoft.com",
		"user@gmai.com",
		"invalid-email"
	],
	"verificationDepth": "standard",
	"checkDomainHealth": true,
	"suggestTypos": true,
	"includeMxRecords": true
}
````

### 📤 Output example

```json
{
	"inputEmail": "user@gmail.com",
	"normalizedEmail": "user@gmail.com",
	"inputIndex": 1,
	"status": "risky",
	"isValid": false,
	"syntaxValid": true,
	"syntaxErrors": [],
	"domain": "gmail.com",
	"hasMxRecords": true,
	"isDisposable": false,
	"isRoleBased": false,
	"roleType": null,
	"isFreeProvider": true,
	"mxProvider": "Google Workspace",
	"riskLevel": "medium",
	"confidenceScore": 64,
	"recommendedDisposition": "send_with_caution",
	"suggestedEmail": null,
	"retryRecommended": false,
	"checkedAt": "2026-06-01T22:35:38.822Z"
}
```

### 💰 Pricing

This Actor uses pay-per-event pricing. You are charged once per email address checked and there is no Actor-start fee in the local pricing artifact.

Current planned prices:

| Apify plan | Price per 1,000 checked emails |
| --- | ---: |
| Free | `$0.80` |
| Bronze | `$0.70` |
| Silver | `$0.55` |
| Gold | `$0.40` |
| Platinum | `$0.25` |
| Diamond | `$0.20` |

The default prefilled run is small enough for a quick output check before you scale up to a larger list.

### ⚠️ Limits and caveats

- The Actor verifies emails you provide. It does not find new email addresses from names, domains, websites, or social profiles.
- MX records prove that a domain accepts email, not that a specific mailbox definitely exists.
- Deep SMTP never sends an email, but some mail servers time out, greylist, or hide mailbox existence. Those cases are marked as inconclusive.
- Disposable-domain and typo checks are rule-based and improve list hygiene, but they are not a legal or compliance decision by themselves.
- Invalid email strings are saved as useful list-cleaning rows so you can fix or suppress them downstream.

### ❓ FAQ

#### ✉️ Does this Actor send emails?

No. Standard mode only checks syntax, DNS, and list-cleaning signals. Deep SMTP can connect to a mail server and issue probe commands, but it does not deliver a message body.

#### 🔐 Do I need an API key or login?

No. Email MX Verifier does not need user credentials, cookies, or a paid external email-verification API.

#### 🧪 Should I use Standard or Deep SMTP?

Use Standard for most bulk list cleaning. Use Deep SMTP when mailbox-level evidence is important and you accept that some mail servers will return `unknown` or time out.

#### 📁 Can it upload a CSV directly?

Use the Apify Console list editor, API, integrations, or dataset tools to pass email arrays into the Actor. The public input contract is the `emails` list.

#### 🔎 Is this an email finder?

No. It checks email addresses you already have. It does not guess patterns, enrich contacts, scrape websites, or find professional emails.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~email-mx-verifier/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - Find public contact emails on websites before verifying them.
- [Gmail Username Checker ↗](https://apify.com/maximedupre/gmail-username-checker) - Check Gmail username availability for new address ideas.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Extract business addresses from company websites for lead data cleanup.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Build website link maps before contact or data extraction.
- [Font Detector ↗](https://apify.com/maximedupre/font-detector) - Audit website fonts, font sources, and typography evidence.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Enter one email address per line. Duplicates are checked once by default to keep exports and pricing clean.

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

Maximum number of submitted emails to check. Use a small limit for a quick first run. Set to 0 for no extra limit.

## `deduplicateEmails` (type: `boolean`):

Check each normalized email only once. Duplicate inputs are skipped so the dataset stays easy to filter.

## `verificationDepth` (type: `string`):

Standard runs fast syntax, MX, disposable, provider, role, and domain-health checks. Deep SMTP also attempts mailbox and catch-all probes without sending email.

## `checkDomainHealth` (type: `boolean`):

Check SPF, DMARC, and common DKIM selectors for each email domain.

## `suggestTypos` (type: `boolean`):

Suggest common domain corrections, such as gmai.com to gmail.com.

## `includeMxRecords` (type: `boolean`):

Include sorted MX host details on each checked email row.

## `smtpTimeoutSecs` (type: `integer`):

Maximum seconds to wait for SMTP replies when Deep SMTP is selected. Timeouts are saved as inconclusive results, not failed runs.

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

Maximum number of email addresses to check in parallel.

## Actor input object example

```json
{
  "emails": [
    "user@gmail.com",
    "contact@github.com",
    "test@mailinator.com",
    "admin@microsoft.com",
    "user@gmai.com",
    "invalid-email",
    "support@openai.com",
    "hello@stripe.com",
    "info@apify.com",
    "support@cloudflare.com",
    "sales@shopify.com",
    "team@vercel.com",
    "contact@npmjs.com",
    "hello@slack.com",
    "support@notion.so",
    "admin@wordpress.org",
    "contact@mozilla.org",
    "help@dropbox.com",
    "admin@example.com",
    "noreply@google.com",
    "security@github.com",
    "press@apple.com",
    "support@zoom.us",
    "info@wikipedia.org",
    "contact@spotify.com"
  ],
  "maxEmails": 0,
  "deduplicateEmails": true,
  "verificationDepth": "standard",
  "checkDomainHealth": true,
  "suggestTypos": true,
  "includeMxRecords": true,
  "smtpTimeoutSecs": 8,
  "concurrency": 32
}
```

# Actor output Schema

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

Open the dataset to view email MX verifier 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": [
        "user@gmail.com",
        "contact@github.com",
        "test@mailinator.com",
        "admin@microsoft.com",
        "user@gmai.com",
        "invalid-email",
        "support@openai.com",
        "hello@stripe.com",
        "info@apify.com",
        "support@cloudflare.com",
        "sales@shopify.com",
        "team@vercel.com",
        "contact@npmjs.com",
        "hello@slack.com",
        "support@notion.so",
        "admin@wordpress.org",
        "contact@mozilla.org",
        "help@dropbox.com",
        "admin@example.com",
        "noreply@google.com",
        "security@github.com",
        "press@apple.com",
        "support@zoom.us",
        "info@wikipedia.org",
        "contact@spotify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/email-mx-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": [
        "user@gmail.com",
        "contact@github.com",
        "test@mailinator.com",
        "admin@microsoft.com",
        "user@gmai.com",
        "invalid-email",
        "support@openai.com",
        "hello@stripe.com",
        "info@apify.com",
        "support@cloudflare.com",
        "sales@shopify.com",
        "team@vercel.com",
        "contact@npmjs.com",
        "hello@slack.com",
        "support@notion.so",
        "admin@wordpress.org",
        "contact@mozilla.org",
        "help@dropbox.com",
        "admin@example.com",
        "noreply@google.com",
        "security@github.com",
        "press@apple.com",
        "support@zoom.us",
        "info@wikipedia.org",
        "contact@spotify.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/email-mx-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": [
    "user@gmail.com",
    "contact@github.com",
    "test@mailinator.com",
    "admin@microsoft.com",
    "user@gmai.com",
    "invalid-email",
    "support@openai.com",
    "hello@stripe.com",
    "info@apify.com",
    "support@cloudflare.com",
    "sales@shopify.com",
    "team@vercel.com",
    "contact@npmjs.com",
    "hello@slack.com",
    "support@notion.so",
    "admin@wordpress.org",
    "contact@mozilla.org",
    "help@dropbox.com",
    "admin@example.com",
    "noreply@google.com",
    "security@github.com",
    "press@apple.com",
    "support@zoom.us",
    "info@wikipedia.org",
    "contact@spotify.com"
  ]
}' |
apify call maximedupre/email-mx-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email MX Verifier",
        "description": "Check email syntax, MX records, disposable domains, role addresses, free providers, typo suggestions, and delivery risk. Export clean rows for CRM, outreach, signup, and data workflows.",
        "version": "0.1",
        "x-build-id": "v2B3Z33rAbYr2fLE7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~email-mx-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-email-mx-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/maximedupre~email-mx-verifier/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-email-mx-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/maximedupre~email-mx-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-email-mx-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",
                "required": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "Email addresses",
                        "minItems": 1,
                        "maxItems": 100000,
                        "type": "array",
                        "description": "Enter one email address per line. Duplicates are checked once by default to keep exports and pricing clean.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxEmails": {
                        "title": "Email limit",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of submitted emails to check. Use a small limit for a quick first run. Set to 0 for no extra limit.",
                        "default": 0
                    },
                    "deduplicateEmails": {
                        "title": "Deduplicate emails",
                        "type": "boolean",
                        "description": "Check each normalized email only once. Duplicate inputs are skipped so the dataset stays easy to filter.",
                        "default": true
                    },
                    "verificationDepth": {
                        "title": "Verification depth",
                        "enum": [
                            "standard",
                            "deepSmtp"
                        ],
                        "type": "string",
                        "description": "Standard runs fast syntax, MX, disposable, provider, role, and domain-health checks. Deep SMTP also attempts mailbox and catch-all probes without sending email.",
                        "default": "standard"
                    },
                    "checkDomainHealth": {
                        "title": "Domain health",
                        "type": "boolean",
                        "description": "Check SPF, DMARC, and common DKIM selectors for each email domain.",
                        "default": true
                    },
                    "suggestTypos": {
                        "title": "Typo suggestions",
                        "type": "boolean",
                        "description": "Suggest common domain corrections, such as gmai.com to gmail.com.",
                        "default": true
                    },
                    "includeMxRecords": {
                        "title": "MX record details",
                        "type": "boolean",
                        "description": "Include sorted MX host details on each checked email row.",
                        "default": true
                    },
                    "smtpTimeoutSecs": {
                        "title": "SMTP timeout",
                        "minimum": 3,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum seconds to wait for SMTP replies when Deep SMTP is selected. Timeouts are saved as inconclusive results, not failed runs.",
                        "default": 8
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of email addresses to check in parallel.",
                        "default": 32
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
