# Bulk Email Verifier & Risk Scorer & Validator + Quality Score (`pro100chok/email-verifier`) Actor

Validate and clean email lists in bulk. Returns deliverability status, 0–100 quality score, and risk level for every address. Detects disposable, role-based, catch-all, spam-trap, and typo emails. MX lookup, normalized address, did-you-mean suggestions. JSON & CSV ready for CRMs and ESPs.

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

## Pricing

$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 Verifier — Bulk Email Validation, Deliverability & Risk Score

> Validate, clean, and score email addresses in bulk. Catch bounces before you send. Detect disposable, role-based, catch-all, and spam-trap addresses. Output is ready for CRMs, ESPs, and spreadsheet imports.

### What this Actor does

Run an array of email addresses through the actor and get back a clean, enriched verification record for each. Typical use-cases:

- **Clean your mailing list** before an ESP campaign — drop the dead addresses so your bounce rate stays low and your sender reputation stays high.
- **Validate leads** from a form / chat / landing page — flag fakes, typos, disposable addresses, and spam traps before they hit your CRM.
- **Score prospects** for cold-email outreach — separate high-confidence deliverable mailboxes from catch-all / role / unknown ones.
- **Cross-check** bought or scraped lists — detect gibberish, plus-tag aliases, and free-mail vs. business addresses.

No SMTP setup on your side, no API keys, no captcha, no proxies — just paste the list and run.

---

### Input format

```json
{
  "emails": [
    "alex.morozov77@gmail.com",
    "jennifer.lee@icloud.com",
    "peter-anderson@hotmail.com"
  ],
  "concurrency": 3
}
````

| Field | Type | Required | Description |
|---|---|---|---|
| `emails` | `string[]` | ✅ | List of email addresses to verify. **Min 10, max 50 per run.** |
| `concurrency` | `integer` | — | Parallel verifications (1–20, default `3`). Higher = faster, but more likely to hit upstream rate limits. |

***

### Output format

One flat record per email, pushed to the default dataset. Example (JSON):

```json
{
  "address": "james_wilson87@hotmail.com",
  "status": "valid",
  "sub_status": "",
  "reason": "Mailbox exists and accepts mail.",
  "is_deliverable": true,
  "is_valid_format": true,
  "is_free_email": true,
  "is_business_email": false,
  "is_role_account": false,
  "is_disposable": false,
  "is_catch_all": false,
  "is_toxic": false,
  "is_spamtrap": false,
  "is_abuse": false,
  "is_global_suppression": false,
  "is_mailbox_full": false,
  "is_greylisted": false,
  "is_alias": false,
  "is_possible_typo": false,
  "has_plus_tag": false,
  "is_gibberish": false,
  "did_you_mean": null,
  "normalized_email": "james_wilson87@hotmail.com",
  "quality_score": 95,
  "deliverability_score": 95,
  "risk": "low",
  "account": "james_wilson87",
  "domain": "hotmail.com",
  "domain_age_days": 10983,
  "smtp_provider": "microsoft",
  "mx_found": true,
  "mx_record": "hotmail-com.olc.protection.outlook.com",
  "mx_records": ["hotmail-com.olc.protection.outlook.com"],
  "firstname": null,
  "lastname": null,
  "gender": null,
  "country": null,
  "region": null,
  "city": null,
  "zipcode": null,
  "processed_at": "2026-04-21 18:48:06.886",
  "verified_at": "2026-04-21 18:48:06.886"
}
```

#### Field reference

**Status**

| Field | Type | Description |
|---|---|---|
| `address` | string | The email that was verified |
| `status` | string | `valid` / `invalid` / `catch-all` / `unknown` / `spamtrap` / `abuse` / `do_not_mail` |
| `sub_status` | string | Granular reason code: `mailbox_not_found`, `disposable`, `role_based`, `possible_typo`, `greylisted`, etc. |
| `reason` | string | Plain-English explanation of the status |

**Derived verdicts** (computed on top of raw status)

| Field | Type | Description |
|---|---|---|
| `is_deliverable` | boolean | Mailbox accepts mail (`status == valid`) |
| `is_valid_format` | boolean | Passes RFC-style syntax check |
| `is_free_email` | boolean | Free provider (Gmail, Yahoo, Outlook, Hotmail, iCloud, mail.ru, …) |
| `is_business_email` | boolean | Inverse of `is_free_email` |
| `is_role_account` | boolean | Shared mailbox (`info@`, `support@`, `sales@`, `hr@`, …) |
| `is_disposable` | boolean | Temporary / throwaway address |
| `is_catch_all` | boolean | Domain accepts any address — existence can't be confirmed |
| `is_toxic` | boolean | Known complainer / trap |
| `is_spamtrap` | boolean | Hard spam trap — never send |
| `is_abuse` | boolean | Known abuse / complaint address |
| `is_global_suppression` | boolean | On a global suppression list |
| `is_mailbox_full` | boolean | Mailbox quota exceeded |
| `is_greylisted` | boolean | Temporary SMTP reject |
| `is_alias` | boolean | Alias that forwards elsewhere |
| `is_possible_typo` | boolean | Looks like a typo — see `did_you_mean` |
| `has_plus_tag` | boolean | Gmail-style `local+tag@domain` aliasing |
| `is_gibberish` | boolean | Random-looking local part (e.g. `asdqwer123`) |

**Scoring**

| Field | Type | Description |
|---|---|---|
| `quality_score` | integer | 0–100 deliverability score |
| `deliverability_score` | integer | Alias of `quality_score` |
| `risk` | string | `low` / `medium` / `high` / `unknown` |

**Metadata & enrichment**

| Field | Type | Description |
|---|---|---|
| `did_you_mean` | string | Suggested fix if the address looks like a typo |
| `normalized_email` | string | Canonical form (lowercased; for Gmail: dots stripped, `+tag` removed) |
| `account` | string | Local part (before `@`) |
| `domain` | string | Domain part (after `@`) |
| `domain_age_days` | integer | How old the domain is |
| `smtp_provider` | string | Detected mail provider (`google`, `microsoft`, `yahoo`, `apple`, …) |
| `mx_found` | boolean | Domain has MX records |
| `mx_record` | string | Primary MX host |
| `mx_records` | string\[] | MX hosts as an array (compatibility) |
| `firstname`, `lastname`, `gender`, `country`, `region`, `city`, `zipcode` | string | Append data when available |
| `processed_at`, `verified_at` | string | ISO-style timestamp of the check |

#### Getting the output

```
## JSON
GET https://api.apify.com/v2/acts/<actor-id>/runs/<run-id>/dataset/items?format=json

## CSV — ready for Excel / Google Sheets / CRM import
GET https://api.apify.com/v2/acts/<actor-id>/runs/<run-id>/dataset/items?format=csv
```

***

### How it compares

| Feature | This Actor | Typical free validators |
|---|---|---|
| Status + sub-status | ✅ | ✅ |
| Deliverability / quality score (0–100) | ✅ | partial |
| Risk level (low / medium / high) | ✅ | ⛔ |
| Disposable / role / catch-all flags | ✅ | ✅ |
| Gibberish detection (random strings) | ✅ | ⛔ |
| `+tag` / Gmail alias detection | ✅ | ⛔ |
| Normalized email (canonical form) | ✅ | ⛔ |
| Typo detection with suggested fix | ✅ | partial |
| MX host + provider | ✅ | ✅ |
| Domain age | ✅ | ⛔ |
| Append data (first/last name, geo) | ✅ | ⛔ |
| No API keys from the user | ✅ | ⛔ |

***

### Pricing & limits

- **10–50 emails per run** — enforced in the input schema.
- Default memory: **256 MB** per run.
- Typical run: 50 emails in ~60–90 seconds at default concurrency.
- Failed / unverifiable addresses are **skipped** — they are not written to the dataset, so you are never billed for checks that didn't return a verdict.

***

### Best practices

1. **Keep concurrency at 3–5** for the cleanest results. Higher concurrency can trigger upstream rate limits.
2. **Batch large lists** — call the actor multiple times with 50 addresses each rather than fighting the per-run cap.
3. **Treat `catch-all` as "probably deliverable but unverified"** — don't drop those leads; flag and re-check later.
4. **Always drop `spamtrap`, `abuse`, and `is_disposable=true`** — sending to these hurts your sender reputation.
5. **Use `is_possible_typo` + `did_you_mean`** to auto-suggest corrections at the form level, before verification is even needed.

***

### FAQ

**Q: Can I run this on 10 000 addresses?**
Split into 200 runs of 50 each, or chain runs via Apify's scheduler / integrations. The per-run cap keeps a single run responsive and avoids partial-failure confusion.

**Q: What happens if an address is ambiguous (catch-all / unknown)?**
You still get a record with `status=catch-all` or `status=unknown`, a `risk=medium|high`, and a `reason` field explaining why. No silent drops.

**Q: Will it detect invalid Cyrillic / Unicode addresses?**
Syntax check is RFC-style ASCII; Unicode local parts aren't flagged automatically. For IDN domains the Punycode form works.

**Q: Do you store or share the emails I validate?**
Emails live only in the run's own Apify dataset, under your account. After the run's retention window, they're deleted. Nothing is sent to third parties beyond what's strictly necessary to perform the verification.

***

### Contact

Questions, feature requests, bulk volume arrangements, custom fields: **afrcanec@gmail.com**

***

**Tags:** email verifier, email validator, email validation, email verification, bulk email checker, bulk email validator, email deliverability, email list cleaner, email list cleaning, email quality score, email risk score, disposable email detector, disposable email checker, catch all detection, catch all email, role account detector, typo correction, mx record lookup, smtp check, email hygiene, lead validation, cold email, bounce rate, sender reputation, mailbox verification, email syntax check, gibberish email detector

# Actor input Schema

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

List of email addresses to verify via ZeroBounce. Minimum 10, maximum 50 per run.

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

How many emails to verify in parallel.

## Actor input object example

```json
{
  "emails": [
    "alex.morozov77@gmail.com",
    "j.thompson_1988@outlook.com",
    "maria.kovaleva@yahoo.com",
    "peter-anderson@hotmail.com",
    "nikolai.volkov@mail.ru",
    "book_worm42@protonmail.com",
    "jennifer.lee@icloud.com",
    "oliver.smith23@gmail.com",
    "elena_sokolova@yandex.ru",
    "michael.brown-jones@outlook.com"
  ],
  "concurrency": 3
}
```

# Actor output Schema

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

All verification records pushed to the default dataset.

# 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": [
        "alex.morozov77@gmail.com",
        "j.thompson_1988@outlook.com",
        "maria.kovaleva@yahoo.com",
        "peter-anderson@hotmail.com",
        "nikolai.volkov@mail.ru",
        "book_worm42@protonmail.com",
        "jennifer.lee@icloud.com",
        "oliver.smith23@gmail.com",
        "elena_sokolova@yandex.ru",
        "michael.brown-jones@outlook.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pro100chok/email-verifier").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "emails": [
        "alex.morozov77@gmail.com",
        "j.thompson_1988@outlook.com",
        "maria.kovaleva@yahoo.com",
        "peter-anderson@hotmail.com",
        "nikolai.volkov@mail.ru",
        "book_worm42@protonmail.com",
        "jennifer.lee@icloud.com",
        "oliver.smith23@gmail.com",
        "elena_sokolova@yandex.ru",
        "michael.brown-jones@outlook.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("pro100chok/email-verifier").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "emails": [
    "alex.morozov77@gmail.com",
    "j.thompson_1988@outlook.com",
    "maria.kovaleva@yahoo.com",
    "peter-anderson@hotmail.com",
    "nikolai.volkov@mail.ru",
    "book_worm42@protonmail.com",
    "jennifer.lee@icloud.com",
    "oliver.smith23@gmail.com",
    "elena_sokolova@yandex.ru",
    "michael.brown-jones@outlook.com"
  ]
}' |
apify call pro100chok/email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Email Verifier & Risk Scorer & Validator + Quality Score",
        "description": "Validate and clean email lists in bulk. Returns deliverability status, 0–100 quality score, and risk level for every address. Detects disposable, role-based, catch-all, spam-trap, and typo emails. MX lookup, normalized address, did-you-mean suggestions. JSON & CSV ready for CRMs and ESPs.",
        "version": "1.0",
        "x-build-id": "09c42nedLMwXzGsjp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pro100chok~email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pro100chok-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/pro100chok~email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-pro100chok-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/pro100chok~email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-pro100chok-email-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "Emails to verify",
                        "minItems": 10,
                        "maxItems": 50,
                        "type": "array",
                        "description": "List of email addresses to verify via ZeroBounce. Minimum 10, maximum 50 per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many emails to verify in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```