# Bulk Email Verifier – Clean Email Lists & Reduce Bounce Rate (`solutionssmart/bulk-email-verifier`) Actor

Verify large email lists and remove invalid addresses before outreach. Reduce bounce rates and protect your sender reputation. Works with CSV, datasets, and automation workflows.

- **URL**: https://apify.com/solutionssmart/bulk-email-verifier.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 19 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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

## 📧 Bulk Email Verifier

Clean your email lists, reduce bounce risk, and protect your sender reputation.

Bulk Email Verifier is an Apify Actor for validating large lists of email addresses before you use them in cold outreach, CRM imports, or automation workflows. It checks each email with practical verification steps and returns structured results you can use immediately in your pipeline.

It is built for affordable bulk verification without paid third-party verification APIs.

### 🚀 Why use this actor?

If you run:

- cold email campaigns
- lead generation workflows
- CRM imports
- marketing automation
- scraped lead pipelines

bad email data creates avoidable problems:

- higher bounce rates
- weaker sender reputation
- wasted credits in outreach tools
- low-quality CRM records
- more manual cleanup work

Bulk Email Verifier helps you clean the list before sending, importing, or syncing it elsewhere.

### ✅ What this actor checks

Each email goes through several validation steps:

- Syntax validation: checks whether the email format is valid
- DNS / MX validation: checks whether the domain can receive email
- Disposable email detection: flags temporary or throwaway email providers
- Role account detection: flags generic inboxes like `info@`, `sales@`, or `admin@`
- Free provider signal: marks addresses from providers like Gmail or Yahoo as a separate signal

The actor labels each email as one of these statuses:

- `valid`
- `risky`
- `invalid`
- `unknown`

### 🎯 Typical use cases

#### 🔎 Lead generation

Verify email lists collected from:

- Google Maps scraping workflows
- LinkedIn lead collection workflows
- website contact extraction
- business directory scraping

#### ✉️ Cold outreach

Clean email lists before sending campaigns with tools such as:

- Instantly
- Lemlist
- Mailshake
- Smartlead
- other outreach platforms

#### 🗂️ CRM and list cleanup

Validate contacts before importing into:

- HubSpot
- Pipedrive
- Salesforce
- Airtable
- internal sales databases

#### ⚙️ Automation workflows

Use the actor inside:

- Apify pipelines
- n8n
- Make
- Zapier
- custom API workflows

### 📥 Input options

You can provide email lists in several beginner-friendly ways:

- Inline email array
- CSV file available at a public URL
- Raw CSV pasted directly into input
- Apify Dataset from another actor
- Apify Key-Value Store record

Provide either `emails` or `source`, not both.

### ⚡ Try it in 30 seconds

Use this small test input to verify a few emails quickly:

```json
{
  "emails": [
    "contact@company.com",
    "info@startup.io",
    "hello@gmail.com"
  ],
  "mode": "mx",
  "dedupe": true,
  "checkDisposable": true,
  "checkRoleAccounts": true,
  "output": {
    "format": "dataset",
    "includeReasoning": true
  },
  "limits": {
    "maxEmails": 10,
    "concurrency": 5
  }
}
````

This example is also available in [examples/input-inline.json](examples/input-inline.json).

### 🧩 Example inputs

The actor uses `mode: "mx"` for MX validation, `checkRoleAccounts` for role inbox detection, and `source` for CSV or dataset inputs. The examples below match the current input schema, so they can be pasted directly into the actor.

#### Example 1: Quick Email Check

**Title**

Quick Email Validation

**Description**

Verify a small list of emails before sending a campaign.

**Input JSON**

```json
{
  "emails": [
    "contact@company.com",
    "info@startup.io",
    "hello@gmail.com"
  ],
  "mode": "mx",
  "checkDisposable": true,
  "checkRoleAccounts": true,
  "output": {
    "format": "dataset",
    "includeReasoning": true
  }
}
```

#### Verify emails from CSV

```json
{
  "source": {
    "type": "urlCsv",
    "url": "https://example.com/leads.csv"
  },
  "mode": "mx",
  "checkDisposable": true,
  "checkRoleAccounts": true,
  "output": {
    "format": "dataset,csv",
    "includeReasoning": true
  }
}
```

The Actor automatically uses the `email` column if it exists, or the first column otherwise.

#### Verify emails from another dataset

```json
{
  "source": {
    "type": "apifyDataset",
    "datasetId": "DATASET_ID"
  },
  "mode": "mx",
  "checkDisposable": true,
  "checkRoleAccounts": true,
  "output": {
    "format": "dataset,csv",
    "includeReasoning": true
  }
}
```

If the dataset contains an `email` field, the Actor uses it automatically. If not, it falls back to the first field in each item.

### 📤 Example output

Each verified email is stored as one item in the default dataset.

```json
{
  "email": "john@example.com",
  "status": "valid",
  "reasons": [],
  "signals": {
    "syntaxOk": true,
    "mxOk": true,
    "mxRecords": [
      {
        "exchange": "mail.example.com",
        "priority": 10
      }
    ],
    "isDisposable": false,
    "isRole": false,
    "isFreeProvider": false,
    "domain": "example.com"
  },
  "timing": {
    "normalize": 0,
    "syntax": 0,
    "mx": 42,
    "heuristics": 1
  },
  "reasoning": "Syntax and MX OK; no risky signals."
}
```

### 📊 Output fields

| Field | Description |
| --- | --- |
| `email` | Normalized email address |
| `status` | Final classification: `valid`, `risky`, `invalid`, or `unknown` |
| `reasons` | Reason codes such as `invalid_syntax`, `no_mx`, `disposable_domain`, `role_account`, or `smtp_rejected` |
| `signals` | Detailed machine-readable verification signals |
| `timing` | Per-step timing information in milliseconds |
| `reasoning` | Human-readable explanation when enabled |

Results can be consumed from the default dataset and exported as JSON, CSV, Excel, or API responses.

If you set `output.format` to `dataset,csv`, the Actor also saves `results.csv` to the default Key-Value Store. Every run also saves a `SUMMARY` record with aggregate counts and output settings.

### 🛠️ Recommended setup

For most use cases:

- use `mode: "mx"`
- keep `checkDisposable: true`
- keep `checkRoleAccounts: true`
- enable CSV output when you want a ready-to-import file

`smtp` mode is experimental. If you use it, also set `enableSmtp: true`.

### ▶️ How to use

1. Open the Actor in Apify.
2. Add emails directly or connect a source such as a CSV URL or dataset.
3. Choose the verification mode. `mx` is the recommended default.
4. Start the run.
5. Review the dataset results and export or forward the contacts you want to keep.

### Built for automation

Bulk Email Verifier is designed to work well inside data pipelines.

```text
Lead Scraper
     ->
Bulk Email Verifier
     ->
CRM / Outreach Tool
```

You can also send result batches to your own endpoint using the built-in webhook option.

### 💰 Pricing

The Actor uses Apify's consumption-based pricing, so cost depends on list size, concurrency, and DNS response times.

Because the Actor does not rely on paid verification APIs, it is generally a low-cost option for bulk pre-verification and list cleaning.

### 👥 Who should use this actor?

This Actor is a practical fit for:

- marketers
- growth teams
- lead generation agencies
- sales operations teams
- automation engineers
- Apify users building scraper-to-CRM workflows

### 🤝 Support

If you need help or want to suggest improvements:

- use the repository issue tracker
- use the Actor Issues tab on Apify
- send feature requests for new workflow integrations or output formats

Feedback is welcome, especially from teams using the Actor in real lead generation and outreach pipelines.

# Actor input Schema

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

One email address per row. Leave empty when Source is used.

## `source` (type: `object`):

Load emails from an Apify Dataset, Key-Value Store record, CSV URL, or raw CSV text. Leave empty when Emails (inline) is used.

## `mode` (type: `string`):

basic = syntax only, mx = syntax plus MX lookup, smtp = MX plus SMTP handshake.

## `enableSmtp` (type: `boolean`):

Must be enabled when Mode is SMTP. SMTP checks can be blocked by providers and may affect IP reputation.

## `checkDisposable` (type: `boolean`):

Mark addresses from known disposable email domains as risky.

## `checkRoleAccounts` (type: `boolean`):

Mark generic role addresses such as admin, info, or support as risky.

## `allowCatchAll` (type: `boolean`):

Reserved for future catch-all handling. Currently kept for forward compatibility.

## `dedupe` (type: `boolean`):

Remove duplicate email addresses before processing.

## `disposableDomainsExtra` (type: `array`):

Additional domain names to treat as disposable.

## `output` (type: `object`):

Choose whether to save only the dataset or also create a CSV export in the default Key-Value Store.

## `webhook` (type: `object`):

Optional destination for POST requests containing result batches.

## `limits` (type: `object`):

Concurrency and timeout settings for local runs and production runs.

## Actor input object example

```json
{
  "emails": [
    "contact@company.com",
    "info@startup.io",
    "hello@gmail.com"
  ],
  "mode": "mx",
  "enableSmtp": false,
  "checkDisposable": true,
  "checkRoleAccounts": true,
  "allowCatchAll": true,
  "dedupe": true,
  "disposableDomainsExtra": [],
  "output": {
    "format": "dataset",
    "includeReasoning": true
  },
  "webhook": {
    "batchSize": 100,
    "includeRunInfo": true
  },
  "limits": {
    "maxEmails": 50000,
    "concurrency": 20,
    "dnsTimeoutMs": 5000,
    "overallTimeoutMs": 1200000
  }
}
```

# Actor output Schema

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

Verified email results (one item per email).

## `csv` (type: `string`):

CSV file of results (stored in default Key-Value Store).

## `summary` (type: `string`):

JSON summary of result counts and output settings.

# 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": [
        "contact@company.com",
        "info@startup.io",
        "hello@gmail.com"
    ],
    "disposableDomainsExtra": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/bulk-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": [
        "contact@company.com",
        "info@startup.io",
        "hello@gmail.com",
    ],
    "disposableDomainsExtra": [],
}

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/bulk-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": [
    "contact@company.com",
    "info@startup.io",
    "hello@gmail.com"
  ],
  "disposableDomainsExtra": []
}' |
apify call solutionssmart/bulk-email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Email Verifier – Clean Email Lists & Reduce Bounce Rate",
        "description": "Verify large email lists and remove invalid addresses before outreach. Reduce bounce rates and protect your sender reputation. Works with CSV, datasets, and automation workflows.",
        "version": "0.1",
        "x-build-id": "79snHqxyrO2cNbJ3J"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~bulk-email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-bulk-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/solutionssmart~bulk-email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-bulk-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/solutionssmart~bulk-email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-bulk-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 (inline)",
                        "type": "array",
                        "description": "One email address per row. Leave empty when Source is used.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "source": {
                        "title": "🔗 Source",
                        "type": "object",
                        "description": "Load emails from an Apify Dataset, Key-Value Store record, CSV URL, or raw CSV text. Leave empty when Emails (inline) is used.",
                        "properties": {
                            "type": {
                                "title": "🧭 Source type",
                                "type": "string",
                                "description": "Where to load the email list from.",
                                "editor": "select",
                                "enum": [
                                    "apifyDataset",
                                    "apifyKeyValueStore",
                                    "urlCsv",
                                    "rawCsv"
                                ],
                                "enumTitles": [
                                    "🗂️ Apify Dataset",
                                    "🗝️ Apify Key-Value Store",
                                    "🌐 URL CSV",
                                    "📝 Raw CSV text"
                                ]
                            },
                            "datasetId": {
                                "title": "🗂️ Dataset ID",
                                "type": "string",
                                "description": "Required when Source type is Apify Dataset."
                            },
                            "kvKey": {
                                "title": "🗝️ Key-Value Store key",
                                "type": "string",
                                "description": "Required when Source type is Apify Key-Value Store."
                            },
                            "url": {
                                "title": "🌐 CSV URL",
                                "type": "string",
                                "description": "Required when Source type is CSV URL. Must be an http or https URL."
                            },
                            "csvText": {
                                "title": "📝 Raw CSV text",
                                "type": "string",
                                "description": "Required when Source type is Raw CSV text. The actor uses the email column when present, otherwise the first column."
                            }
                        },
                        "additionalProperties": false
                    },
                    "mode": {
                        "title": "🔍 Mode",
                        "enum": [
                            "basic",
                            "mx",
                            "smtp"
                        ],
                        "type": "string",
                        "description": "basic = syntax only, mx = syntax plus MX lookup, smtp = MX plus SMTP handshake.",
                        "default": "mx"
                    },
                    "enableSmtp": {
                        "title": "🧪 Enable SMTP check",
                        "type": "boolean",
                        "description": "Must be enabled when Mode is SMTP. SMTP checks can be blocked by providers and may affect IP reputation.",
                        "default": false
                    },
                    "checkDisposable": {
                        "title": "🗑️ Check disposable domains",
                        "type": "boolean",
                        "description": "Mark addresses from known disposable email domains as risky.",
                        "default": true
                    },
                    "checkRoleAccounts": {
                        "title": "👤 Check role accounts",
                        "type": "boolean",
                        "description": "Mark generic role addresses such as admin, info, or support as risky.",
                        "default": true
                    },
                    "allowCatchAll": {
                        "title": "📬 Allow catch-all domains",
                        "type": "boolean",
                        "description": "Reserved for future catch-all handling. Currently kept for forward compatibility.",
                        "default": true
                    },
                    "dedupe": {
                        "title": "🧹 Deduplicate emails",
                        "type": "boolean",
                        "description": "Remove duplicate email addresses before processing.",
                        "default": true
                    },
                    "disposableDomainsExtra": {
                        "title": "➕ Extra disposable domains",
                        "type": "array",
                        "description": "Additional domain names to treat as disposable.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "output": {
                        "title": "📦 Output options",
                        "type": "object",
                        "description": "Choose whether to save only the dataset or also create a CSV export in the default Key-Value Store.",
                        "properties": {
                            "format": {
                                "title": "🧾 Format",
                                "type": "string",
                                "description": "dataset = push to default dataset; add 'csv' to also save CSV to Key-Value Store.",
                                "enum": [
                                    "dataset",
                                    "dataset,csv"
                                ],
                                "enumTitles": [
                                    "📄 Dataset only",
                                    "📄 Dataset + CSV in Key-Value Store"
                                ]
                            },
                            "includeReasoning": {
                                "title": "💬 Include reasoning",
                                "type": "boolean",
                                "description": "Include a human-readable explanation in each result item.",
                                "default": true
                            }
                        },
                        "default": {
                            "format": "dataset",
                            "includeReasoning": true
                        },
                        "additionalProperties": false
                    },
                    "webhook": {
                        "title": "🔔 Webhook",
                        "type": "object",
                        "description": "Optional destination for POST requests containing result batches.",
                        "properties": {
                            "url": {
                                "title": "🌍 Webhook URL",
                                "type": "string",
                                "description": "http or https endpoint to receive JSON result batches."
                            },
                            "batchSize": {
                                "title": "📦 Batch size",
                                "type": "integer",
                                "description": "Number of results per webhook request.",
                                "minimum": 1,
                                "default": 100
                            },
                            "includeRunInfo": {
                                "title": "ℹ️ Include run info",
                                "type": "boolean",
                                "description": "Include run ID, actor ID, and batch index in the webhook payload.",
                                "default": true
                            }
                        },
                        "default": {
                            "batchSize": 100,
                            "includeRunInfo": true
                        },
                        "additionalProperties": false
                    },
                    "limits": {
                        "title": "⚙️ Limits",
                        "type": "object",
                        "description": "Concurrency and timeout settings for local runs and production runs.",
                        "properties": {
                            "maxEmails": {
                                "title": "🔢 Max emails",
                                "type": "integer",
                                "description": "Maximum number of emails to process in one run.",
                                "minimum": 1,
                                "default": 50000
                            },
                            "concurrency": {
                                "title": "🚦 Concurrency",
                                "type": "integer",
                                "description": "Number of email checks to process in parallel.",
                                "minimum": 1,
                                "default": 20
                            },
                            "dnsTimeoutMs": {
                                "title": "⏱️ DNS timeout (ms)",
                                "type": "integer",
                                "description": "Timeout for each DNS MX lookup in milliseconds.",
                                "minimum": 1,
                                "default": 5000
                            },
                            "overallTimeoutMs": {
                                "title": "⌛ Overall timeout (ms)",
                                "type": "integer",
                                "description": "Maximum run time in milliseconds.",
                                "minimum": 1,
                                "default": 1200000
                            }
                        },
                        "default": {
                            "maxEmails": 50000,
                            "concurrency": 20,
                            "dnsTimeoutMs": 5000,
                            "overallTimeoutMs": 1200000
                        },
                        "additionalProperties": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
