# Domain Deliverability Checker SPF DKIM DMARC Blacklist Clay (`mambalabs/domain-deliverability-checker`) Actor

Audit a domain's email deliverability: SPF, DKIM, DMARC and policy, MX and mail provider, catch-all and blacklist checks, domain age, and a 0 to 100 health score. Flat JSON, Clay ready.

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

## Pricing

from $4.25 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Domain Deliverability Checker: SPF, DKIM, DMARC, MX, Blacklist

Audit a domain's email deliverability and DNS health in one call. Give it a domain and get back SPF, DKIM, and DMARC authentication with policy, MX records and mail provider, DNS blacklist status, catch-all detection, domain age, and a single 0 to 100 health score. Flat JSON, one row per domain, ready to drop into a Clay table. Pure DNS and SMTP: no browser, no proxy, no paid third-party APIs.

Built for outbound agencies, sales operations teams, and Clay users who need to check domain health before sending cold email. Where most Apify actors check only one slice (just DNS, or just blacklists, or just DMARC), this one returns the complete deliverability verdict in a single flat row.

### Features

- **Full email authentication audit.** SPF record and qualifier policy, DMARC record and policy (none, quarantine, reject), and DKIM presence across the common provider selectors.
- **Mail provider detection.** Identifies Google Workspace, Microsoft 365, Zoho, Proofpoint, Mimecast, Amazon SES, and more from the MX records.
- **DNS blacklist checks.** Tests the domain's mail server IP against a curated set of DNSBL zones and reports listed, clean, or unknown.
- **Catch-all detection.** SMTP RCPT probe to flag accept-all domains. Off by default because the Apify platform blocks outbound port 25; see Limitations.
- **Domain age.** Registration date via RDAP, the modern registry protocol that survives GDPR redaction, with a DNS SOA fallback.
- **Spam-trap risk heuristics.** Advisory flags for young domains, mail without authentication, and blacklisted infrastructure.
- **0 to 100 deliverability score.** A single transparent verdict with a low, medium, or high risk level.
- **Batch and cache.** Pass a `domains` array for bulk runs; results are cached for 24 hours to make repeat lookups free.

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `domain` | string | no | stripe.com | Bare domain without https:// or trailing slash. |
| `domains` | array | no | none | List of bare domains for batch processing. Takes precedence over `domain`. One output row per domain. |
| `batchSize` | integer | no | 5 | Domains audited concurrently per wave in batch mode. Maximum 10. |
| `skipCache` | boolean | no | false | Force a fresh audit and ignore any cached result. |
| `attempt_catch_all` | boolean | no | false | Run the SMTP catch-all probe. Off by default because the Apify platform blocks port 25; enable only on a runner that allows port 25 egress. |

Provide either `domain` or `domains`.

### Output

One flat row per domain. Every field is always present; absent values are null.

| Field | Type | Description | Example |
|-------|------|-------------|---------|
| `domain` | string | Normalized input domain | `stripe.com` |
| `spf_record` | string | Raw SPF TXT record, or null | `v=spf1 include:_spf.google.com ~all` |
| `spf_valid` | boolean | A valid v=spf1 record is present | `true` |
| `spf_policy` | string | Qualifier on all: fail, softfail, neutral, pass, or null | `softfail` |
| `dkim_selectors_found` | array | Common selectors that returned a key | `["google","s1","s2"]` |
| `dkim_present` | boolean | At least one common selector found | `true` |
| `dmarc_record` | string | Raw DMARC TXT record, or null | `v=DMARC1; p=reject;` |
| `dmarc_policy` | string | none, quarantine, reject, or null | `reject` |
| `dmarc_valid` | boolean | A valid v=DMARC1 record is present | `true` |
| `mx_records` | array | MX hosts with priority | `[{"host":"aspmx.l.google.com","priority":10}]` |
| `has_mx` | boolean | Domain has at least one MX | `true` |
| `mail_provider` | string | Detected provider, or null | `Google Workspace` |
| `catch_all` | boolean | SMTP accepts a random address, or null when unknown | `null` |
| `catch_all_status` | string | catch_all, not_catch_all, or unknown | `unknown` |
| `blacklisted` | boolean | Listed on any checked DNSBL | `false` |
| `blacklists_listed` | array | Zones that returned a listing | `[]` |
| `blacklists_checked` | array | Zones queried this run | `["bl.spamcop.net", ...]` |
| `blacklist_status` | string | listed, clean, or unknown | `clean` |
| `spam_trap_risk` | string | low, medium, or high heuristic | `low` |
| `spam_trap_flags` | array | Triggered heuristics | `[]` |
| `domain_age_days` | integer | Days since registration, or null | `11238` |
| `domain_age_source` | string | rdap, soa, or null | `rdap` |
| `has_website` | boolean | Domain has an A or AAAA record | `true` |
| `deliverability_score` | integer | 0 to 100 composite verdict | `95` |
| `risk_level` | string | low, medium, or high | `low` |
| `run_date` | string | ISO timestamp of the run | `2026-06-19T08:10:59Z` |

**Score model:** has MX +20; valid SPF +20 (hard -all +5); DKIM present +15; valid DMARC +15 (quarantine +5, reject +10); blacklist clean +15 (unknown +7); catch-all not detected +5 (detected -10). Capped 0 to 100. Risk: 80 or more low, 50 to 79 medium, under 50 high.

### Pricing

| Tier | Discount | Per result | Per 1K results |
|------|----------|-----------|----------------|
| Free (no plan) | 0% | $0.005 | $5.00 |
| Starter (Bronze) | ~5% | $0.00475 | $4.75 |
| Scale (Silver) | ~10% | $0.0045 | $4.50 |
| Business (Gold) | ~15% | $0.00425 | $4.25 |

Free tier: 50 results per month included, resets monthly. Cached repeat lookups within 24 hours are free.

### Usage Examples

#### Apify Console / API

```bash
curl -X POST "https://api.apify.com/v2/acts/0tVgxI7A6o9jMlxmc/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domain":"stripe.com"}'
````

Batch:

```json
{ "domains": ["stripe.com", "github.com", "mailchimp.com"], "batchSize": 5 }
```

#### Clay Integration

1. Add an Enrichment column of type HTTP API, or use the Apify integration.
2. Call this actor with `domain` mapped to your domain column.
3. Map the returned fields to columns: `deliverability_score`, `risk_level`, `spf_valid`, `dmarc_policy`, `blacklist_status`, `mail_provider`.
4. Gate downstream sends on a formula like `deliverability_score >= 70` to skip risky domains before they enter a sequence.

The output is flat and one row per domain, so every field maps directly to a Clay column with no JSON unwrapping.

#### MCP Integration

```bash
npm install @mambalabsdev/mcp-domain-deliverability-checker
```

```json
{
  "mcpServers": {
    "domain-deliverability": {
      "command": "npx",
      "args": ["-y", "@mambalabsdev/mcp-domain-deliverability-checker"],
      "env": { "APIFY_TOKEN": "YOUR_TOKEN" }
    }
  }
}
```

Tool: `check_domain_deliverability` with `{ "domain": "stripe.com" }`.

### Error Handling

| Condition | Behavior | Output |
|-----------|----------|--------|
| Empty or invalid domain | Empty record pushed, run continues | all checks null or false, score 0 |
| No MX or NXDOMAIN | Row emitted, blacklist and SMTP skipped | `has_mx:false`, not treated as an error |
| Port 25 blocked or SMTP timeout | Catch-all reported as unknown | `catch_all:null, catch_all_status:"unknown"` |
| DNSBL zone blocks or errors | That zone dropped to unknown, others continue | `blacklist_status` may be `unknown` |
| RDAP unavailable | Falls back to SOA serial, then null | `domain_age_source:"soa"` or null |
| One domain throws in a batch | Caught per domain, empty record pushed | other rows unaffected |

### Limitations

- **Catch-all is off by default.** The Apify platform blocks outbound SMTP on port 25, so the catch-all probe returns unknown here. Enable `attempt_catch_all` only when running this actor on infrastructure that permits port 25 egress.
- **DNS blacklist coverage is best-effort.** Spamhaus and Barracuda block queries from cloud IPs and public resolvers without a paid data-query key, so some zones return unknown. A `clean` result means clean on the zones that answered, not an authoritative all-clear.
- **DKIM uses common-selector probing.** DKIM selectors cannot be enumerated from DNS, so the actor checks a fixed list of provider selectors. An empty result means not found on a common selector, not a guarantee that DKIM is absent.
- **Domain age depends on the registry.** RDAP returns the registration date for most TLDs; some registries omit or redact it, in which case the value is null or an approximate SOA-based fallback.
- **Data freshness.** Results are cached for 24 hours. Pass `skipCache: true` for a live audit.

***

**Part of the [Mamba Labs GTM Intelligence Suite](https://apify.com/mambalabs)**

| Actor | Actor ID |
|-------|----------|
| [GTM Hiring Signal Scraper](https://apify.com/mambalabs/gtm-hiring-signal-scraper) | D7O1SA2EqwHGsGr1P |
| [GTM Tech Stack Signal Enrichment](https://apify.com/mambalabs/gtm-tech-stack-signal-scraper) | qyd7nNyqFPelQViBx |
| [GTM Signals Aggregator](https://apify.com/mambalabs/gtm-signals-aggregator) | xKdRfnfFNkdMpFuNs |
| [Job Board Keyword Signal Scanner](https://apify.com/mambalabs/job-board-keyword-signal-scanner) | 4DvqpvhMR74NLcDDY |
| [Domain to LinkedIn URL Resolver](https://apify.com/mambalabs/domain-to-linkedin-url-resolver) | 3HtnSaqPHOg1Qg5gx |
| [ICP Fit Scorer](https://apify.com/mambalabs/icp-fit-scorer) | W161DT8W4kW55dMFh |

npm: [@mambalabsdev/ats-scrapers](https://www.npmjs.com/package/@mambalabsdev/ats-scrapers)

Built by [Mamba Labs](https://apify.com/mambalabs).

# Actor input Schema

## `domain` (type: `string`):

Bare domain without https:// or trailing slash. Example: stripe.com

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

Optional list of bare domains for batch processing. Takes precedence over the single domain field when provided. Each domain produces its own output row.

## `batchSize` (type: `integer`):

How many domains to audit concurrently per wave in batch mode. Default 5, maximum 10.

## `skipCache` (type: `boolean`):

By default a result is cached for 24 hours and reused on repeat lookups. Set true to force a fresh audit and ignore any cached result.

## `attempt_catch_all` (type: `boolean`):

Off by default. The Apify platform blocks outbound SMTP (port 25), so catch-all detection returns unknown here. Enable only when running this actor in an environment that allows port 25 egress (for example a self-hosted runner).

## Actor input object example

```json
{
  "domain": "stripe.com",
  "batchSize": 5,
  "skipCache": false,
  "attempt_catch_all": false
}
```

# Actor output Schema

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

No description

# 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 = {
    "domain": "stripe.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/domain-deliverability-checker").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 = { "domain": "stripe.com" }

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/domain-deliverability-checker").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 '{
  "domain": "stripe.com"
}' |
apify call mambalabs/domain-deliverability-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Domain Deliverability Checker SPF DKIM DMARC Blacklist Clay",
        "description": "Audit a domain's email deliverability: SPF, DKIM, DMARC and policy, MX and mail provider, catch-all and blacklist checks, domain age, and a 0 to 100 health score. Flat JSON, Clay ready.",
        "version": "0.0",
        "x-build-id": "tfGxTvGSA6IicE4et"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mambalabs~domain-deliverability-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mambalabs-domain-deliverability-checker",
                "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/mambalabs~domain-deliverability-checker/runs": {
            "post": {
                "operationId": "runs-sync-mambalabs-domain-deliverability-checker",
                "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/mambalabs~domain-deliverability-checker/run-sync": {
            "post": {
                "operationId": "run-sync-mambalabs-domain-deliverability-checker",
                "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": {
                    "domain": {
                        "title": "Domain",
                        "type": "string",
                        "description": "Bare domain without https:// or trailing slash. Example: stripe.com"
                    },
                    "domains": {
                        "title": "Domains (batch)",
                        "type": "array",
                        "description": "Optional list of bare domains for batch processing. Takes precedence over the single domain field when provided. Each domain produces its own output row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "batchSize": {
                        "title": "Batch Size",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many domains to audit concurrently per wave in batch mode. Default 5, maximum 10.",
                        "default": 5
                    },
                    "skipCache": {
                        "title": "Skip Cache",
                        "type": "boolean",
                        "description": "By default a result is cached for 24 hours and reused on repeat lookups. Set true to force a fresh audit and ignore any cached result.",
                        "default": false
                    },
                    "attempt_catch_all": {
                        "title": "Attempt Catch-All SMTP Probe",
                        "type": "boolean",
                        "description": "Off by default. The Apify platform blocks outbound SMTP (port 25), so catch-all detection returns unknown here. Enable only when running this actor in an environment that allows port 25 egress (for example a self-hosted runner).",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```