# Email Domain Security & Deliverability Auditor (`feeng/email-domain-security-deliverability-auditor`) Actor

🛡️ Audit MX, SPF, DMARC, DKIM, MTA-STS, TLS-RPT, BIMI, CAA, DNSSEC, and web TLS without sending email. Get evidence-backed security and deliverability scores, prioritized fixes, and a client-ready report.

- **URL**: https://apify.com/feeng/email-domain-security-deliverability-auditor.md
- **Developed by:** [Daniel S.](https://apify.com/feeng) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 audited email domains

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Domain Security & Deliverability Auditor

🛡️ **Bulk-audit email authentication, anti-spoofing, DNS security, and web TLS without sending a single email.**

Turn domains, URLs, or email addresses into an evidence-backed security and deliverability scorecard. This standalone Apify Actor checks **MX, SPF, DKIM, DMARC, MTA-STS, TLS-RPT, BIMI, CAA, DNSSEC deployment hints, and website TLS certificates** using public DNS and HTTPS/TLS only. No paid API, proxy, email login, SMTP probe, or third-party Actor is required.

Built for:

- 📣 cold email, sales operations, and outbound agencies
- ✉️ email marketing and deliverability teams
- 🧑‍💻 IT, DevOps, security, and compliance teams
- 🏢 MSPs and agencies auditing customer domain portfolios
- 🔁 recurring domain monitoring through Apify Schedules and webhooks

### Why use this email domain auditor?

Most email health checks return a few green or red icons. This Actor produces operational evidence that can be exported, automated, and handed to the person who must fix the problem:

- **Two separate 0-100 scores** for security and deliverability
- **Recursive SPF lookup analysis**, including the 10-lookup limit, include errors, redirect errors, and recursion loops
- **Selector-aware DKIM discovery** through TXT and CNAME records
- **DMARC policy strength**, enforcement percentage, alignment, and reporting destinations
- **MTA-STS marker plus live HTTPS policy validation**
- **CAA, DNSSEC deployment hints, and website TLS certificate evidence**
- **Prioritized findings** with severity, evidence, and a plain-English recommendation
- **Professional HTML report** plus portfolio summary JSON
- **Three focused dataset views** for management, email authentication, and transport security

### 🔍 Checks

| Check | What is inspected | Typical problem detected |
|---|---|---|
| MX | Priority, host, Null MX, provider hint | Domain cannot receive email |
| SPF | Syntax, `all` policy, includes, redirect, recursive DNS lookup count | `+all`, multiple records, more than 10 lookups |
| DMARC | `p`, `sp`, `pct`, `rua`, `ruf`, `adkim`, `aspf` | Missing policy, `p=none`, partial enforcement |
| DKIM | Supplied selectors through TXT and CNAME | No key discovered, revoked selector |
| MTA-STS | `_mta-sts` TXT and HTTPS policy file | Marker exists but policy is invalid or unreachable |
| TLS-RPT | `_smtp._tls` reporting record | No visibility into SMTP TLS failures |
| BIMI | Default BIMI record and HTTPS logo location | Missing or malformed brand record |
| CAA | Authorized certificate issuers | No CA issuance restriction |
| DNSSEC hint | Public DS and DNSKEY evidence | Missing or incomplete deployment |
| Web TLS | Trust, hostname, protocol, expiry, issuer, cipher | Expired, untrusted, or legacy TLS |

> **Safety:** the Actor reads public infrastructure configuration only. It never sends email, never verifies whether a mailbox exists, and never performs an SMTP handshake.

### 🚀 Quick start

Paste domains, URLs, and email addresses into the Apify Input form:

```json
{
  "domains": [
    "example.com",
    "security@github.com",
    "https://www.cloudflare.com"
  ],
  "checks": [
    "mx",
    "spf",
    "dmarc",
    "dkim",
    "mtaSts",
    "tlsRpt",
    "bimi",
    "caa",
    "dnssec",
    "webTls"
  ],
  "dkimSelectors": [
    "google",
    "default",
    "selector1",
    "selector2",
    "s1",
    "s2",
    "k1",
    "k2",
    "mail",
    "smtp",
    "mandrill",
    "amazonses"
  ],
  "timeoutSecs": 10,
  "concurrency": 10
}
````

Email addresses and URLs are normalized to a domain, leading `www.` is removed from URLs, internationalized domains are converted to ASCII, and duplicates are merged. Invalid values are skipped and listed in `SUMMARY`.

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `domains` | string array | `["example.com"]` | 1-1,000 domains, URLs, or email addresses |
| `checks` | string array | all checks | Controls to run; disabled controls do not reduce scores |
| `dkimSelectors` | string array | 12 common selectors | Add exact selectors used by your email providers |
| `timeoutSecs` | integer | `10` | Per DNS, HTTPS, or TLS operation, 2-30 seconds |
| `concurrency` | integer | `10` | Domains processed in parallel, 1-30 |

#### Which DKIM selectors should I use?

DKIM public keys live at `<selector>._domainkey.<domain>`. DNS has no operation that lists all selectors, so any DKIM checker must know which selectors to test. The defaults cover common generic, Google, Microsoft, Mailchimp, Amazon SES, and transactional-email patterns. Add the exact selectors from your email provider when known.

### 📦 Output

The default dataset contains **one structured row per unique normalized domain**. CSV, JSON, Excel, XML, and API exports are available through standard Apify datasets.

```json
{
  "domain": "example.com",
  "status": "completed",
  "overallScore": 68,
  "securityScore": 62,
  "deliverabilityScore": 74,
  "riskLevel": "high",
  "mxFound": true,
  "mxProviders": ["Google Workspace"],
  "spfStatus": "warning",
  "spfLookupCount": 8,
  "spfLookupLimitExceeded": false,
  "dmarcPolicy": "none",
  "dkimFound": true,
  "dkimSelectorsFound": ["google"],
  "mtaStsMode": null,
  "webTlsStatus": "pass",
  "topRecommendation": "Review aggregate reports, align legitimate senders, then progress to p=quarantine and p=reject.",
  "findings": [
    {
      "check": "dmarc",
      "severity": "high",
      "code": "DMARC_MONITOR_ONLY",
      "title": "DMARC does not enforce protection",
      "message": "p=none collects reports but does not ask receivers to block or quarantine spoofed mail.",
      "evidence": {
        "policy": "none"
      },
      "recommendation": "Review aggregate reports, align legitimate senders, then progress to p=quarantine and p=reject."
    }
  ]
}
```

See [`examples/output.json`](./examples/output.json) for the complete shape.

#### Dataset views

- **Risk overview**: scores, severities, issue count, and top fix
- **Email authentication**: MX, provider, SPF lookup count, DMARC, and DKIM
- **Transport and DNS security**: MTA-STS, TLS-RPT, BIMI, CAA, DNSSEC, and web TLS

#### Key-value store reports

| Key | Content type | Purpose |
|---|---|---|
| `SUMMARY` | `application/json` | Portfolio counts, score averages, coverage, common findings, and priority actions |
| `REPORT` | `text/html` | Standalone responsive report suitable for client review or printing |

### 📊 How scoring works

Security and deliverability use separate weighted models:

- **Deliverability:** MX, SPF, DKIM, DMARC, MTA-STS, TLS-RPT, and BIMI
- **Security:** SPF, DKIM, DMARC, MTA-STS, TLS-RPT, BIMI, CAA, DNSSEC hint, and web TLS

Each score is normalized across **enabled checks with successful evidence**. A disabled check never reduces the score. If a network operation fails, the related weight is excluded and the coverage percentage falls. Always interpret score and coverage together.

Grades:

| Score | Grade |
|---:|:---|
| 95-100 | A+ |
| 90-94 | A |
| 80-89 | B |
| 70-79 | C |
| 60-69 | D |
| 0-59 | F |

Severity takes precedence in `riskLevel`: a critical finding remains critical even if optional controls raise the numeric average.

### 💼 Practical workflows

#### Audit cold-email sending domains

Run MX, SPF, DKIM, DMARC, MTA-STS, and TLS-RPT before launching a campaign. Filter the dataset for:

- `spfLookupLimitExceeded = true`
- `dmarcPolicy = none` or empty
- `dkimFound = false`
- `riskLevel = critical` or `high`

#### Create an agency lead magnet

Audit prospect domains, export the Risk overview as CSV, and share the generated HTML report during discovery. Findings include evidence and specific remediation rather than generic sales claims.

#### Monitor a customer portfolio

Create a saved task, schedule it weekly, and connect a webhook to Make, n8n, Zapier, Slack, or your ticketing system. Compare current rows with the prior run in your own datastore to detect posture changes.

#### Support security inventory reviews

Use the API or Apify MCP integration to enrich asset inventory with CAA, DNSSEC hints, web certificate expiry, and email anti-spoofing posture.

### API usage

Replace `YOUR_USERNAME` and `APIFY_TOKEN`:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_USERNAME~email-domain-security-deliverability-auditor/runs?token=APIFY_TOKEN" \
  -H "content-type: application/json" \
  -d '{
    "domains": ["example.com", "github.com"],
    "checks": ["mx", "spf", "dmarc", "dkim"],
    "concurrency": 10
  }'
```

The Actor also works through the Apify JavaScript/Python clients, webhooks, schedules, Make, Zapier, n8n, and Apify MCP.

### Local development

Requirements: Node.js 22 or newer.

```bash
npm install
npm test
npx apify-cli validate-schema
npm start
```

Local `npm start` reads input through the standard Apify local storage. Unit tests use dependency-injected DNS, HTTP, and TLS mocks and do not require network access.

### Privacy and security

- No email is sent.
- No mailbox, SMTP recipient, or password is tested.
- No paid API or third-party Actor is called.
- Inputs and outputs use the run's private Apify storages unless the user explicitly shares them.
- Web TLS and MTA-STS connections block private, loopback, link-local, documentation, multicast, and reserved IP targets.
- HTTP responses are limited and redirects are not followed.
- Every individual check handles timeout and DNS errors without crashing other domains.

### Honest limitations

1. **DKIM is selector-based.** A `not discovered` result is not proof that no outbound message is signed.
2. **DNSSEC is a hint.** Public DS and DNSKEY evidence is useful for inventory, but this Actor is not a full validating resolver.
3. **No inbox-placement test.** DNS posture is only one part of deliverability; sender reputation, message content, engagement, and list quality are not measured.
4. **No SMTP probe.** The Actor does not test mailbox existence, catch-all behavior, or bounce status.
5. **Public-view differences are possible.** Split-horizon DNS and private enterprise policies may differ from records visible to the Actor.

### Monetization

The recommended predictable launch price is **$0.006 per audited domain ($6 per 1,000)** plus a **$0.00005 run start**. One dataset row equals one completed domain audit, so the synthetic Apify default dataset item event maps cleanly to user value. The HTML report and summary are included.

See [`PRICING.md`](./PRICING.md) for margins, discount tiers, and the exact Apify Console configuration.

### License

MIT. See [`LICENSE`](./LICENSE).

# Actor input Schema

## `domains` (type: `array`):

Add one value per row. Examples: example.com, https://www.example.com, or user@example.com. URLs and email addresses are normalized to their domain. Duplicates are removed.

## `checks` (type: `array`):

Select the controls you need. Scores are normalized across enabled checks, so disabled checks do not reduce a score.

## `dkimSelectors` (type: `array`):

DKIM selectors cannot be listed through DNS. Add provider-specific selectors when known. Common Google, Microsoft, Mailchimp, SendGrid, Amazon SES and generic selectors are included.

## `timeoutSecs` (type: `integer`):

Maximum time for an individual DNS, HTTPS, or TLS operation. Slow or unreachable checks become structured errors instead of failing the run.

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

Number of domains audited in parallel. Reduce this when testing unusually slow DNS infrastructure.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "user@github.com",
    "https://www.cloudflare.com"
  ],
  "checks": [
    "mx",
    "spf",
    "dmarc",
    "dkim",
    "mtaSts",
    "tlsRpt",
    "bimi",
    "caa",
    "dnssec",
    "webTls"
  ],
  "dkimSelectors": [
    "google",
    "default",
    "selector1",
    "selector2",
    "s1",
    "s2",
    "k1",
    "k2",
    "mail",
    "smtp",
    "mandrill",
    "amazonses"
  ],
  "timeoutSecs": 10,
  "concurrency": 10
}
```

# Actor output Schema

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

One complete structured result per normalized domain.

## `overview` (type: `string`):

Compact scorecard view for triage and CSV export.

## `authentication` (type: `string`):

MX, SPF, DKIM and DMARC-focused view.

## `transportSecurity` (type: `string`):

MTA-STS, TLS-RPT, BIMI, CAA, DNSSEC and website TLS view.

## `csvExport` (type: `string`):

Download the overview fields as CSV.

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

Portfolio-level counts, averages, coverage and prioritized recommendations.

## `htmlReport` (type: `string`):

A standalone, presentation-ready report stored in the default key-value store.

# 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 = {
    "domains": [
        "example.com",
        "user@github.com",
        "https://www.cloudflare.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("feeng/email-domain-security-deliverability-auditor").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 = { "domains": [
        "example.com",
        "user@github.com",
        "https://www.cloudflare.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("feeng/email-domain-security-deliverability-auditor").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 '{
  "domains": [
    "example.com",
    "user@github.com",
    "https://www.cloudflare.com"
  ]
}' |
apify call feeng/email-domain-security-deliverability-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Domain Security & Deliverability Auditor",
        "description": "🛡️ Audit MX, SPF, DMARC, DKIM, MTA-STS, TLS-RPT, BIMI, CAA, DNSSEC, and web TLS without sending email. Get evidence-backed security and deliverability scores, prioritized fixes, and a client-ready report.",
        "version": "0.1",
        "x-build-id": "Sz90ZW0aBXLl96J0n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/feeng~email-domain-security-deliverability-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-feeng-email-domain-security-deliverability-auditor",
                "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/feeng~email-domain-security-deliverability-auditor/runs": {
            "post": {
                "operationId": "runs-sync-feeng-email-domain-security-deliverability-auditor",
                "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/feeng~email-domain-security-deliverability-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-feeng-email-domain-security-deliverability-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "🌐 Domains, URLs, or email addresses",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add one value per row. Examples: example.com, https://www.example.com, or user@example.com. URLs and email addresses are normalized to their domain. Duplicates are removed.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 2048
                        },
                        "default": [
                            "example.com"
                        ]
                    },
                    "checks": {
                        "title": "🔍 Checks to run",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select the controls you need. Scores are normalized across enabled checks, so disabled checks do not reduce a score.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "mx",
                                "spf",
                                "dmarc",
                                "dkim",
                                "mtaSts",
                                "tlsRpt",
                                "bimi",
                                "caa",
                                "dnssec",
                                "webTls"
                            ],
                            "enumTitles": [
                                "📬 MX receiving records",
                                "🧾 SPF policy and recursive lookup count",
                                "🛡️ DMARC enforcement policy",
                                "🔏 DKIM selector discovery",
                                "🔒 MTA-STS policy",
                                "📊 SMTP TLS reporting (TLS-RPT)",
                                "🏷️ BIMI brand record",
                                "🔐 Certificate Authority Authorization (CAA)",
                                "⛓️ DNSSEC deployment hint",
                                "🌐 Website TLS certificate"
                            ]
                        },
                        "default": [
                            "mx",
                            "spf",
                            "dmarc",
                            "dkim",
                            "mtaSts",
                            "tlsRpt",
                            "bimi",
                            "caa",
                            "dnssec",
                            "webTls"
                        ]
                    },
                    "dkimSelectors": {
                        "title": "🔑 DKIM selectors to probe",
                        "minItems": 1,
                        "maxItems": 50,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "DKIM selectors cannot be listed through DNS. Add provider-specific selectors when known. Common Google, Microsoft, Mailchimp, SendGrid, Amazon SES and generic selectors are included.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 63,
                            "pattern": "^[A-Za-z0-9_-]+$"
                        },
                        "default": [
                            "google",
                            "default",
                            "selector1",
                            "selector2",
                            "s1",
                            "s2",
                            "k1",
                            "k2",
                            "mail",
                            "smtp",
                            "mandrill",
                            "amazonses"
                        ]
                    },
                    "timeoutSecs": {
                        "title": "⏱️ Per-request timeout",
                        "minimum": 2,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum time for an individual DNS, HTTPS, or TLS operation. Slow or unreachable checks become structured errors instead of failing the run.",
                        "default": 10
                    },
                    "concurrency": {
                        "title": "⚡ Concurrent domains",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of domains audited in parallel. Reduce this when testing unusually slow DNS infrastructure.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
