# 📧 Email Verifier & Bulk Validator — MX, SMTP, Catch-All (`inexhaustible_glass/email-verifier`) Actor

Verify emails in bulk without sending mail: syntax, MX, SMTP mailbox probe, catch-all, disposable, role, free & SPF/DMARC/DKIM. Get deliverable/undeliverable/risky verdict + 0-100 score. Clean your lead list before you send. No API key.

- **URL**: https://apify.com/inexhaustible\_glass/email-verifier.md
- **Developed by:** [Hitman studio](https://apify.com/inexhaustible_glass) (community)
- **Categories:** Lead generation, SEO tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 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 & Bulk Validator — Check Email Deliverability (SMTP, MX, Catch-All)

**Clean any email list before you send.** Verify one address or a million — in bulk,
without sending a single email. For every address you get a clear verdict —
**`deliverable` / `undeliverable` / `risky` / `unknown`** — an **A–F grade**, a
**0–100 confidence score**, and the exact reason. Cut hard bounces, protect your
sender reputation, and stop wasting outreach on dead inboxes.

> ✅ **No API key. No signup. No proxy needed.** Free public checks (DNS + SMTP).

---

### ⚡ What it checks (per email)

| Check | What you learn |
|---|---|
| **Syntax** | Is the address validly formed (RFC-style)? |
| **Domain / MX** | Does the domain exist and actually accept mail? |
| **Microsoft 365 mailbox** | For company domains on Microsoft 365 / Azure AD, confirms whether the mailbox exists over **HTTPS** — **works on any cloud, no port 25 needed** |
| **SMTP mailbox** | For every other domain, connects to the real mail server and asks *“does this inbox exist?”* — **no email is sent** (RCPT probe) |
| **Catch-all** | Detects *accept-all* domains where every address “exists” (so you know a result is uncertain) |
| **Disposable** | Temp / throwaway providers — checked against a **live ~7,800-domain blocklist** refreshed each run |
| **Role-based** | `info@`, `sales@`, `support@` … (low-value for cold outreach) |
| **Free provider** | gmail / yahoo / outlook … |
| **SPF / DMARC / DKIM** | Email-authentication signals of the domain |
| **Mail provider** | Google Workspace, Microsoft 365, Zoho, Proofpoint … |
| **Typo fix** | `foo@gmial.com` → *did you mean* `foo@gmail.com` |
| **Normalized email** | Canonical form (Gmail dots & `+tags` removed) — great for de-duping |
| **Gravatar** *(optional)* | Is a real person’s avatar attached to this email? |

---

### 🥇 Why this beats other email verifiers

Most verifiers just return valid/invalid. This one gives your sales & data teams the
full picture — and it’s **bulk, block-proof, and needs no API key**:

| Feature | Typical verifier | **This actor** |
|---|:---:|:---:|
| Syntax + MX + SMTP mailbox check | ✅ | ✅ |
| Catch-all detection | ✅ | ✅ |
| Disposable + role + free flags | partial | ✅ |
| **SPF / DMARC / DKIM** deliverability signals | ❌ | ✅ |
| **Mail-provider detection** (Google/Microsoft/Zoho…) | ❌ | ✅ |
| **Typo suggestion** (`did_you_mean`) | ❌ | ✅ |
| **Normalized email** (Gmail dot/+tag) for de-dupe | ❌ | ✅ |
| **Gravatar** “real human” signal | ❌ | ✅ (optional) |
| **A–F grade + 0–100 score** | partial | ✅ |
| No API key / no monthly credit limit | ❌ | ✅ |
| Bulk + parallel | ✅ | ✅ |

---

### 🎯 Perfect for

- **Sales / SDR / outbound** — scrub a lead list so a cold campaign doesn’t bounce
- **Anyone using a lead / email-finder scraper** — verify the emails you just collected
- **Email marketing / newsletters** — cut hard bounces, keep your domain out of spam
- **Signup & lead forms** — validate an address the moment it’s entered
- **CRM hygiene** — de-dupe with the normalized form and drop dead addresses

> 💡 **Pairs with the author’s lead-gen actors** (Lead Enricher Pro, Google Maps Leads,
> Contact Details Scraper): **scrape emails → verify them here → send only to the good ones.**

---

### 🧾 Input

| Field | Description |
|---|---|
| `emails` | List of addresses to verify (or a comma/newline string) |
| `text` | Paste any text/CSV/thread — every email inside is extracted & verified |
| `smtpCheck` | Ask the mail server if the mailbox exists (default **on**). Turn off for a faster syntax+MX+DNS check |
| `gravatarCheck` | Also check for a public Gravatar avatar (default off) |
| `concurrency` | How many to verify in parallel, 1–20 (default 5) |
| `proxyHost` / `proxyPort` | **SOCKS5 proxy for the live SMTP check** — see below |
| `proxyType` / `proxyUsername` / `proxyPassword` | SOCKS5 (default) or SOCKS4, plus optional auth |

#### 🔌 Unlock the live SMTP mailbox check (port 25)
Real mailbox verification (“does this inbox exist?”) requires a connection to the
recipient’s mail server on **port 25** — and, to stop spam, **every cloud provider
(including Apify) blocks outbound port 25**. This is a hard rule of email, not a bug:
even the most popular open-source verifier ([reacherhq](https://github.com/reacherhq/check-if-email-exists))
works exactly the same way.

**Two ways to turn the SMTP check on:**
1. Set `proxyHost` / `proxyPort` to a **SOCKS5 proxy that allows port 25** (e.g. one
   running on a small VPS such as Kamatera or AvaHosting that leaves port 25 open).
2. Or run this Actor on any network/VPS where outbound port 25 is open.

**Without a proxy** the Actor still runs perfectly as a fast **MX + DNS + risk
validator** (syntax, MX, disposable, role, free, typo, provider, SPF/DMARC/DKIM,
normalization, grade & score) — it just reports the SMTP field honestly as `unknown`
instead of guessing.

#### Example input
```json
{
  "emails": ["ada@stripe.com", "info@apify.com", "test@mailinator.com", "foo@gmial.com"],
  "smtpCheck": true,
  "concurrency": 5
}
````

### 📤 Output (per email)

```json
{
  "email": "ada@stripe.com",
  "status": "deliverable",
  "is_valid": true,
  "grade": "A",
  "score": 95,
  "reason": "mailbox_exists",
  "is_valid_syntax": true,
  "normalized_email": "ada@stripe.com",
  "domain": "stripe.com",
  "provider": "Google Workspace",
  "has_mx": true,
  "mx_host": "aspmx.l.google.com",
  "smtp_status": "deliverable",
  "is_catch_all": false,
  "is_disposable": false,
  "is_role": false,
  "is_free": false,
  "has_spf": true,
  "has_dmarc": true,
  "has_dkim": true,
  "did_you_mean": null,
  "has_gravatar": null
}
```

Every run also saves a **`SUMMARY`** (totals by status) in the key-value store.

#### Statuses

- **`deliverable`** — the mailbox exists and accepts mail ✅ (safe to send)
- **`undeliverable`** — bad syntax, dead domain, or the mailbox doesn’t exist ❌ (do not send)
- **`risky`** — catch-all domain, disposable, or a role address ⚠️ (send with caution)
- **`unknown`** — the mail server wouldn’t confirm (greylisting / port 25 blocked); scored from MX + DNS

### ❓ FAQ

**Q: Does it send emails to verify them?** No. It uses an SMTP `RCPT` probe — it *asks*
the server whether the inbox exists and then disconnects. Nothing is ever delivered.

**Q: What is a “catch-all” domain?** A domain configured to accept mail for *every*
address, so the server can’t tell you if a specific inbox is real. We flag these as
`risky` so you don’t treat an unverifiable address as confirmed.

**Q: Why are some results `unknown`?** Some mail servers greylist or hide mailbox
existence, and some networks block outbound port 25. In those cases we fall back to a
confidence score from MX + SPF/DMARC signals instead of guessing.

**Q: Can I verify a whole CSV?** Yes — paste your list into `emails`, or drop the raw
text into `text` and every address is auto-extracted. Run it on a schedule for ongoing
list hygiene.

### 💵 Pricing

Pay per email verified — no subscription, no monthly credit cap. See the **Pricing** tab
on this Actor’s page for the current rate. Cleaning 1,000 emails costs a fraction of the
revenue you lose to bounces and a damaged sender reputation.

### 🔗 Related Actors (by the same author)

- **Lead Enricher Pro** — emails, phones, LinkedIn & tech stack from any website
- **Google Maps Leads** — business leads with emails & phones
- **Contact Details Scraper** — emails, phones & socials from any website
- **EU VAT Validator** — validate EU VAT numbers → official company name & address

### 🔖 Keywords

email verifier, email validator, bulk email verification, bulk email checker, email checker,
verify email address, check if email exists, email existence check, email deliverability,
email validation api, email verification api, smtp check, smtp email verification, mx lookup,
mx record check, catch-all detection, accept-all domain, disposable email detector, temporary
email checker, role email detection, free email detection, spf dkim dmarc check, email
authentication check, mail server checker, mailbox verification, microsoft 365 email verifier,
office 365 email check, azure ad email verification, gmail email checker, email typo correction,
email list cleaning, email list hygiene, clean email list, reduce bounce rate, lower bounce
rate, protect sender reputation, lead list cleaning, verify leads, email scrubbing, no api key
email verifier, socks5 proxy email verification, zerobounce alternative, neverbounce alternative,
hunter email verifier alternative, kickbox alternative, emailable alternative, truelist alternative.

### ⚖️ Notes

Uses public DNS records and standard SMTP conversations (no message is ever sent). Some
mail servers intentionally hide mailbox existence; results for those are reported honestly
as `risky` or `unknown` rather than guessed.

# Actor input Schema

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

List of email addresses to verify. You can also paste a comma/newline-separated string.

## `text` (type: `string`):

Paste any text (a CSV row, an email thread, a page) and every email address inside it will be extracted and verified.

## `smtpCheck` (type: `boolean`):

Connect to the mail server and ask whether the mailbox actually exists (RCPT probe — no email is sent). Turn off for a faster syntax + MX + DNS only check. Note: some networks block outbound port 25, in which case results fall back to 'unknown' with an MX/DNS score.

## `gravatarCheck` (type: `boolean`):

Also check whether the email has a public Gravatar avatar — a signal that a real person uses it. Slightly slower.

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

How many emails to verify in parallel (1-20). Lower this if a mail server rate-limits you.

## `proxyHost` (type: `string`):

Cloud providers (incl. Apify) block outbound port 25, so the SMTP mailbox check can't run without help. Point this at a SOCKS5 proxy / VPS that allows port 25 and the live mailbox check will work. Leave empty to run as a fast MX + DNS + risk validator.

## `proxyPort` (type: `integer`):

Proxy port (SOCKS5 default is 1080).

## `proxyType` (type: `string`):

SOCKS5 (recommended) or SOCKS4.

## `proxyUsername` (type: `string`):

Username for the SOCKS proxy, if it requires authentication.

## `proxyPassword` (type: `string`):

Password for the SOCKS proxy, if it requires authentication.

## Actor input object example

```json
{
  "emails": [
    "ada@stripe.com",
    "info@apify.com"
  ],
  "smtpCheck": true,
  "gravatarCheck": false,
  "concurrency": 5,
  "proxyType": "socks5"
}
```

# 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@openai.com",
        "john.doe@gmail.com",
        "test@mailinator.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("inexhaustible_glass/email-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@openai.com",
        "john.doe@gmail.com",
        "test@mailinator.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("inexhaustible_glass/email-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@openai.com",
    "john.doe@gmail.com",
    "test@mailinator.com"
  ]
}' |
apify call inexhaustible_glass/email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📧 Email Verifier & Bulk Validator — MX, SMTP, Catch-All",
        "description": "Verify emails in bulk without sending mail: syntax, MX, SMTP mailbox probe, catch-all, disposable, role, free & SPF/DMARC/DKIM. Get deliverable/undeliverable/risky verdict + 0-100 score. Clean your lead list before you send. No API key.",
        "version": "1.0",
        "x-build-id": "fGZ8g2x1L9b99bHdQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/inexhaustible_glass~email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-inexhaustible_glass-email-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/inexhaustible_glass~email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-inexhaustible_glass-email-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/inexhaustible_glass~email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-inexhaustible_glass-email-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": "Emails to verify",
                        "type": "array",
                        "description": "List of email addresses to verify. You can also paste a comma/newline-separated string.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "text": {
                        "title": "Or paste any text",
                        "type": "string",
                        "description": "Paste any text (a CSV row, an email thread, a page) and every email address inside it will be extracted and verified."
                    },
                    "smtpCheck": {
                        "title": "SMTP mailbox check",
                        "type": "boolean",
                        "description": "Connect to the mail server and ask whether the mailbox actually exists (RCPT probe — no email is sent). Turn off for a faster syntax + MX + DNS only check. Note: some networks block outbound port 25, in which case results fall back to 'unknown' with an MX/DNS score.",
                        "default": true
                    },
                    "gravatarCheck": {
                        "title": "Gravatar check",
                        "type": "boolean",
                        "description": "Also check whether the email has a public Gravatar avatar — a signal that a real person uses it. Slightly slower.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many emails to verify in parallel (1-20). Lower this if a mail server rate-limits you.",
                        "default": 5
                    },
                    "proxyHost": {
                        "title": "SOCKS proxy host (for full SMTP check)",
                        "type": "string",
                        "description": "Cloud providers (incl. Apify) block outbound port 25, so the SMTP mailbox check can't run without help. Point this at a SOCKS5 proxy / VPS that allows port 25 and the live mailbox check will work. Leave empty to run as a fast MX + DNS + risk validator."
                    },
                    "proxyPort": {
                        "title": "SOCKS proxy port",
                        "type": "integer",
                        "description": "Proxy port (SOCKS5 default is 1080)."
                    },
                    "proxyType": {
                        "title": "Proxy type",
                        "enum": [
                            "socks5",
                            "socks4"
                        ],
                        "type": "string",
                        "description": "SOCKS5 (recommended) or SOCKS4.",
                        "default": "socks5"
                    },
                    "proxyUsername": {
                        "title": "Proxy username (optional)",
                        "type": "string",
                        "description": "Username for the SOCKS proxy, if it requires authentication."
                    },
                    "proxyPassword": {
                        "title": "Proxy password (optional)",
                        "type": "string",
                        "description": "Password for the SOCKS proxy, if it requires authentication."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```