# Email Risk Validator, Contact Finder & Lead Cleaner (`wearable_monkey/email-risk-validator-lead-cleaner`) Actor

Validate email lists, extract website emails/phones/socials, generate B2B email candidates, score delivery risk, and export clean CRM-ready leads for outreach and SaaS workflows.

- **URL**: https://apify.com/wearable\_monkey/email-risk-validator-lead-cleaner.md
- **Developed by:** [闻涛 曾](https://apify.com/wearable_monkey) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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 Risk Validator, Contact Finder & Lead Cleaner

Clean email lists, extract public website contacts, and generate B2B email candidates before outreach, CRM import, signup review, or fraud prevention. This Actor combines bulk email verification, website email/phone/social extraction, B2B pattern-based email generation, MX checks, typo suggestions, and CRM-ready exports.

### Fast trial paths

Start with one of these workflows to see useful output in the first run:

- Clean a messy email list: paste `emailsText`, keep `dedupe` on, and export `clean-emails.json` plus `risky-emails.json`.
- Extract contacts from company websites: paste `urls` or `urlsText`, keep `extractContacts` on, and review public emails, phones, social links, and contact-page evidence.
- Generate B2B candidates: paste `peopleText` with names and company domains, then review generated candidates by `deliverability_grade`, `confidence`, and `risk.recommendation`.

For repeat use, schedule the Actor after every new lead-source export from Google Maps, directories, LinkedIn tools, Apollo, HubSpot, Salesforce, Airtable, or Google Sheets.

### Market-driven upgrade

A same-category scan of Apify email/contact products showed the most attractive buyer-facing features:

- Bulk email verification with syntax, MX, disposable, role, and free-provider signals
- B2B email finder workflows using first name, last name, and company domain
- Website contact finder workflows that extract public emails, phones, and social links
- Confidence scores, delivery grades, clean/risky split, and CRM export files
- Simple pricing and practical outputs for lead generation, agencies, and growth teams

This Actor now bundles those core capabilities into one lead-quality workflow.

### What it does

- Validates direct email lists from structured input or pasted text
- Detects invalid syntax, disposable domains, free providers, role accounts, risky TLDs, and suspicious local parts
- Checks MX records when enabled and returns sorted MX records
- Suggests fixes for common typo domains such as `gamil.com`, `gmial.com`, and `example.con`
- Extracts public contact data from websites, including emails, phone numbers, and social links
- Discovers likely contact pages such as contact, about, team, support, impressum, and privacy pages
- Generates B2B email candidates from people + company domains using patterns like `first.last`, `flast`, and `last.first`
- Outputs risk score, recommendation, A-F deliverability grade, confidence, clean/risky split, and CRM export files

### Best use cases

- Clean B2B lead lists before cold email
- Turn company websites into outreach-ready contact signals
- Generate likely business email candidates for founders, sales teams, recruiters, and agencies
- Audit newsletter subscribers before campaigns
- Filter disposable signups in SaaS onboarding workflows
- Prepare CRM contacts before HubSpot, Salesforce, Airtable, or Google Sheets imports
- Enrich Google Maps, directory, or spreadsheet exports with public contacts

### Input

You can provide one or more of these inputs:

- `emails` - structured list of email addresses
- `emailsText` - raw email block separated by new lines, commas, spaces, or semicolons
- `urls` - company or lead websites to scan for public contacts
- `urlsText` - raw website block pasted from a spreadsheet or CRM export
- `peopleText` - one person per line for candidate generation, using `First, Last, company.com` or `Full Name, company.com`
- `candidatePatterns` - optional patterns such as `first.last`, `firstlast`, `flast`, `firstl`, `last.first`, `lastf`

Optional settings:

- `extractContacts` - enable/disable website contact extraction
- `maxPagesPerUrl` - number of pages to scan per website
- `requestTimeoutSecs` - timeout for website page requests
- `strictness` - use `low`, `normal`, or `high` risk scoring
- `checkMx` - check whether domains have MX records
- `dedupe` - remove duplicate email addresses before validation
- `proxyConfiguration` - optional Apify Proxy or custom proxy settings for website contact extraction

### Output

Dataset records include three record types:

- `email_validation` - direct input or extracted email validation result
- `generated_candidate` - generated B2B email candidate and validation result
- `contact_extraction` - website-level extraction summary

Important fields include:

- `email`, `domain`, `local_part`, `tld`
- `valid_syntax`, `disposable`, `role_based`, `free_provider`, `business_email`, `personal_email`
- `risky_tld`, `suspicious_local`, `mx_status`, `mx_records`, `suggestion`
- `risk.score`, `risk.label`, `risk.reasons`, `risk.recommendation`
- `deliverability_grade`, `confidence`, `clean`
- `source_url`, `pages_scanned`, `extracted_emails`, `phone_numbers`, `social_links`
- `person`, `pattern`, `generated_from` for generated candidates

The key-value store also contains:

- `SUMMARY` - totals and risk breakdown
- `clean-emails.json` - emails recommended for use
- `risky-emails.json` - emails recommended for review or blocking
- `generated-candidates.json` - generated B2B candidates with validation signals
- `extracted-contacts.json` - website contact extraction summaries
- `domain-summary.json` - per-domain clean/risky counts
- `crm-export.json` - compact CRM-ready clean lead export

### Example input

```json
{
  "emails": [
    "test@gmail.com",
    "admin@mailinator.com",
    "sales@example.con",
    "info@openai.com"
  ],
  "emailsText": "support@example.com\nhello@tempmail.com",
  "urls": [
    "https://www.apify.com",
    "https://www.openai.com"
  ],
  "peopleText": "Sam, Altman, openai.com\nMelanie Perkins, canva.com",
  "candidatePatterns": [
    "first.last",
    "firstlast",
    "flast",
    "firstl",
    "last.first"
  ],
  "strictness": "normal",
  "checkMx": false,
  "dedupe": true,
  "extractContacts": true,
  "maxPagesPerUrl": 3,
  "requestTimeoutSecs": 15,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Example output

```json
{
  "record_type": "generated_candidate",
  "source": "email_finder",
  "email": "sam.altman@openai.com",
  "valid_syntax": true,
  "domain": "openai.com",
  "business_email": true,
  "mx_status": "found",
  "suggestion": null,
  "risk": {
    "score": 12,
    "label": "low",
    "reasons": ["generated_candidate_unconfirmed"],
    "recommendation": "verify"
  },
  "deliverability_grade": "B",
  "confidence": "medium",
  "generated_candidate": true,
  "pattern": "first.last",
  "clean": true
}
```

### Proxy option

Website contact extraction can run directly or through the Apify input field `proxyConfiguration`. Direct mode is cheapest for cooperative websites. Enable Apify Proxy or custom proxies when a website blocks datacenter requests, rate-limits repeated scans, or behaves differently by country. The Actor only receives the proxy URL at runtime and does not store proxy passwords in outputs.

### Pricing transparency

This Actor is configured for pay-per-event pricing. The primary paid event is each result written to the default dataset. One run can output validation rows, generated candidate rows, and website contact summary rows.

Current public pricing shown by Apify:

- Actor start: `$0.0005`
- Dataset result: `$0.001` per dataset result

Cost examples:

- 1,000 validation results: about `$1`
- 10,000 validation results: about `$10`
- 100 websites with 3 pages each plus extracted emails: depends on extracted result count

### Accuracy notes

- MX checks depend on DNS availability and can be slower than syntax-only validation.
- Website extraction only uses publicly available page content from submitted URLs.
- Generated B2B candidates are pattern guesses; use `risk`, `deliverability_grade`, `confidence`, and MX status before outreach.
- Disposable-domain detection uses a curated internal list and should be treated as a strong signal, not a legal/compliance guarantee.
- Free-provider detection is useful for B2B workflows but should not be treated as a reason to reject consumer users.

### Recommended workflow

1. Paste lead emails, websites, or people + domains.
2. Keep `dedupe` enabled to avoid paying for duplicate validations.
3. Use `normal` strictness for outreach lists.
4. Use `high` strictness for fraud-prone signup workflows.
5. Export `clean-emails.json` or `crm-export.json` to your CRM or outreach tool.
6. Review `generated-candidates.json` before contacting generated emails.
7. Review `risky-emails.json` before deleting contacts permanently.

# Actor input Schema

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

Paste email addresses to validate. Up to 10,000 emails per run.

## `emailsText` (type: `string`):

Optional newline, comma, semicolon, or space-separated email list. Useful for raw CRM exports and lead lists.

## `urls` (type: `array`):

Optional company or lead websites. The Actor scans the homepage plus likely contact/about/team/support/privacy pages for public emails, phones, and social links.

## `urlsText` (type: `string`):

Optional newline, comma, semicolon, or space-separated website list for quick paste from CRMs, Google Maps exports, or spreadsheets.

## `extractContacts` (type: `boolean`):

Extract public emails, phone numbers, and social links from submitted websites, then validate discovered emails.

## `maxPagesPerUrl` (type: `integer`):

Maximum pages to fetch per website. Higher values can find more contacts but run slower.

## `requestTimeoutSecs` (type: `integer`):

Timeout in seconds for each website page request.

## `proxyConfiguration` (type: `object`):

Optional proxy settings for website contact extraction. Use Apify Proxy or custom proxies when target websites rate-limit datacenter traffic.

## `peopleText` (type: `string`):

Optional people list for B2B email candidate generation. Use one line per person: First, Last, company.com or Full Name, company.com.

## `candidatePatterns` (type: `array`):

Patterns used to generate business email candidates. Supported tokens: first, last, f, l, fi, li. Examples: first.last, flast, firstl, last.first.

## `strictness` (type: `string`):

Higher strictness marks free providers and risky patterns more aggressively.

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

Check domain MX records for deliverability. Slower but more accurate for real lead lists and generated candidates.

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

Remove duplicate email addresses before validation to reduce cost and keep cleaner output.

## Actor input object example

```json
{
  "emails": [
    "test@gmail.com",
    "admin@mailinator.com",
    "sales@example.con"
  ],
  "emailsText": "ceo@openai.com\nadmin@mailinator.com\nsales@example.con",
  "urls": [
    "https://www.apify.com",
    "https://www.openai.com"
  ],
  "urlsText": "https://www.apify.com\nhttps://www.openai.com",
  "extractContacts": true,
  "maxPagesPerUrl": 3,
  "requestTimeoutSecs": 15,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "peopleText": "Sam, Altman, openai.com\nMelanie Perkins, canva.com",
  "candidatePatterns": [
    "first.last",
    "firstlast",
    "flast",
    "firstl",
    "last.first"
  ],
  "strictness": "normal",
  "checkMx": true,
  "dedupe": true
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "emails": [
        "test@gmail.com",
        "admin@mailinator.com",
        "sales@example.con"
    ],
    "emailsText": `ceo@openai.com
admin@mailinator.com
sales@example.con`,
    "urls": [
        "https://www.apify.com",
        "https://www.openai.com"
    ],
    "urlsText": `https://www.apify.com
https://www.openai.com`,
    "peopleText": `Sam, Altman, openai.com
Melanie Perkins, canva.com`,
    "candidatePatterns": [
        "first.last",
        "firstlast",
        "flast",
        "firstl",
        "last.first"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wearable_monkey/email-risk-validator-lead-cleaner").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "emails": [
        "test@gmail.com",
        "admin@mailinator.com",
        "sales@example.con",
    ],
    "emailsText": """ceo@openai.com
admin@mailinator.com
sales@example.con""",
    "urls": [
        "https://www.apify.com",
        "https://www.openai.com",
    ],
    "urlsText": """https://www.apify.com
https://www.openai.com""",
    "peopleText": """Sam, Altman, openai.com
Melanie Perkins, canva.com""",
    "candidatePatterns": [
        "first.last",
        "firstlast",
        "flast",
        "firstl",
        "last.first",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("wearable_monkey/email-risk-validator-lead-cleaner").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "emails": [
    "test@gmail.com",
    "admin@mailinator.com",
    "sales@example.con"
  ],
  "emailsText": "ceo@openai.com\\nadmin@mailinator.com\\nsales@example.con",
  "urls": [
    "https://www.apify.com",
    "https://www.openai.com"
  ],
  "urlsText": "https://www.apify.com\\nhttps://www.openai.com",
  "peopleText": "Sam, Altman, openai.com\\nMelanie Perkins, canva.com",
  "candidatePatterns": [
    "first.last",
    "firstlast",
    "flast",
    "firstl",
    "last.first"
  ]
}' |
apify call wearable_monkey/email-risk-validator-lead-cleaner --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Risk Validator, Contact Finder & Lead Cleaner",
        "description": "Validate email lists, extract website emails/phones/socials, generate B2B email candidates, score delivery risk, and export clean CRM-ready leads for outreach and SaaS workflows.",
        "version": "1.0",
        "x-build-id": "YQe0gteaew4KeXEU4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wearable_monkey~email-risk-validator-lead-cleaner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wearable_monkey-email-risk-validator-lead-cleaner",
                "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/wearable_monkey~email-risk-validator-lead-cleaner/runs": {
            "post": {
                "operationId": "runs-sync-wearable_monkey-email-risk-validator-lead-cleaner",
                "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/wearable_monkey~email-risk-validator-lead-cleaner/run-sync": {
            "post": {
                "operationId": "run-sync-wearable_monkey-email-risk-validator-lead-cleaner",
                "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",
                        "maxItems": 10000,
                        "type": "array",
                        "description": "Paste email addresses to validate. Up to 10,000 emails per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "emailsText": {
                        "title": "Emails text block",
                        "type": "string",
                        "description": "Optional newline, comma, semicolon, or space-separated email list. Useful for raw CRM exports and lead lists."
                    },
                    "urls": {
                        "title": "Websites to scan",
                        "maxItems": 200,
                        "type": "array",
                        "description": "Optional company or lead websites. The Actor scans the homepage plus likely contact/about/team/support/privacy pages for public emails, phones, and social links.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urlsText": {
                        "title": "Websites text block",
                        "type": "string",
                        "description": "Optional newline, comma, semicolon, or space-separated website list for quick paste from CRMs, Google Maps exports, or spreadsheets."
                    },
                    "extractContacts": {
                        "title": "Extract website contacts",
                        "type": "boolean",
                        "description": "Extract public emails, phone numbers, and social links from submitted websites, then validate discovered emails.",
                        "default": true
                    },
                    "maxPagesPerUrl": {
                        "title": "Max pages per website",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum pages to fetch per website. Higher values can find more contacts but run slower.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Website request timeout",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout in seconds for each website page request.",
                        "default": 15
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings for website contact extraction. Use Apify Proxy or custom proxies when target websites rate-limit datacenter traffic.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "peopleText": {
                        "title": "People for B2B email candidates",
                        "type": "string",
                        "description": "Optional people list for B2B email candidate generation. Use one line per person: First, Last, company.com or Full Name, company.com."
                    },
                    "candidatePatterns": {
                        "title": "Email candidate patterns",
                        "type": "array",
                        "description": "Patterns used to generate business email candidates. Supported tokens: first, last, f, l, fi, li. Examples: first.last, flast, firstl, last.first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "strictness": {
                        "title": "Strictness",
                        "enum": [
                            "low",
                            "normal",
                            "high"
                        ],
                        "type": "string",
                        "description": "Higher strictness marks free providers and risky patterns more aggressively.",
                        "default": "normal"
                    },
                    "checkMx": {
                        "title": "Check MX records",
                        "type": "boolean",
                        "description": "Check domain MX records for deliverability. Slower but more accurate for real lead lists and generated candidates.",
                        "default": true
                    },
                    "dedupe": {
                        "title": "Remove duplicates",
                        "type": "boolean",
                        "description": "Remove duplicate email addresses before validation to reduce cost and keep cleaner output.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
