# Email Finder Bulk — Lists of Domains or People to Emails (`bovi/email-finder-bulk`) Actor

Bulk email finder, two modes in one run: give a list of **company domains** to harvest published emails, OR a list of **people** (name + domain) to find their work email. Per-email confidence, source, role flag, and cross-list dedup. No API key.

- **URL**: https://apify.com/bovi/email-finder-bulk.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Lead generation, Business
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.75 / 1,000 email founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Email Finder Bulk — Lists of Domains or People to Emails

**Find emails for a whole list in one run — not 500 separate actor calls.**

Email Finder Bulk is a hybrid lead-generation tool that runs **two jobs in a single run**, so you never have to chain two actors or run one address at a time:

- **Mode B — you have a list of DOMAINS (no names).** Give it a list of company websites and it harvests the emails those sites publish — contact pages, `mailto:` links, page footers — and returns each one with a transparent **source** and a numeric **confidence**.
- **Mode A — you have a list of PEOPLE (name + company domain).** Give it `firstName`, `lastName`, and `domain` and it builds frequency-ranked email patterns, checks the domain's mail records, and (when the run network allows it) verifies the mailbox over SMTP — returning the best email plus ranked alternatives, each with its own confidence.

Use either mode on its own, or both together in the same run. Everything is merged into one clean, deduplicated table.

---

### Why this actor (what most bulk email tools get wrong)

Most email scrapers either return a single bare guess with no confidence, or they dump emails mixed with noise — tracking strings, image-filename artifacts, placeholder addresses — and leave you to clean it. Email Finder Bulk is built around three things those tools skip:

1. **A confidence score on every email.** You always know how much to trust a result, and where it came from (`mailto` link, contact page, page body, name pattern, or SMTP-verified).
2. **A junk filter.** Asset filenames (`logo@2x.png`), framework/tracking addresses, and placeholder domains (`example.com`, `yourdomain.com`) never reach your output.
3. **Cross-list deduplication.** Run a list of 300 domains and the same email found twice is collapsed into one row by default — a clean export, not a pile of repeats.

No API key. No login. You pay only for emails actually found.

---

### Input

You can fill in **`domains`**, **`people`**, or both.

#### Mode B — `domains`
A list of company domains or website URLs:

```json
{
  "domains": ["stripe.com", "notion.so", "https://www.diverxo.com"],
  "maxPerDomain": 3
}
````

#### Mode A — `people`

A list of people, each with a name and company domain:

```json
{
  "people": [
    { "firstName": "Patrick", "lastName": "Collison", "domain": "stripe.com" },
    { "firstName": "Tobias", "lastName": "Lutke", "domain": "shopify.com" }
  ],
  "verifySmtp": true
}
```

#### Options

| Field | What it does | Default |
| --- | --- | --- |
| `domains` | Mode B — websites to harvest emails from | — |
| `people` | Mode A — people to find work emails for | — |
| `deduplicateEmails` | Collapse the same email into one row; when off, repeats are marked `duplicate_flag=true` | `true` |
| `maxPerDomain` | Cap emails returned per harvested domain (cost + noise control) | `3` |
| `verifySmtp` | Mode A — attempt live SMTP verification; falls back to MX + pattern ranking if port 25 is blocked | `true` |
| `maxAlternatives` | Mode A — ranked alternative candidates per person | `5` |
| `maxItems` | Total output cap across both modes (0 = unlimited) | `0` |
| `proxyConfiguration` | Proxy used to reach websites; **residential is the default and recommended** for reliable access | residential |

***

### Output

One flat row per email, merged across both modes:

```json
{
  "domain": "acme.com",
  "email": "jane.doe@acme.com",
  "first_name": "Jane",
  "last_name": "Doe",
  "email_source": "smtp_verified",
  "confidence": 0.95,
  "duplicate_flag": false,
  "status": "verified",
  "is_role_account": false,
  "is_disposable": false,
  "mx_found": true,
  "verification_method": "smtp",
  "on_domain": true,
  "alternative_emails": [],
  "parse_confidence": 1.0,
  "input_mode": "people",
  "scraped_at": "2026-06-15T12:00:00Z"
}
```

#### Field guide

- **`email_source`** — where the email came from: `mailto` / `contact_page` / `website_body` (Mode B), or `name_pattern` / `smtp_verified` (Mode A).
- **`confidence`** — 0–1 score. SMTP-verified mailboxes and `mailto` links score highest; body-text matches score lower.
- **`duplicate_flag`** — `true` only when deduplication is off and the email already appeared earlier in the run.
- **`is_role_account`** — `true` for shared addresses like `info@`, `sales@`, `support@`.
- **`on_domain`** — `true` when the email's domain matches the site it was found on.
- **`status`** — `verified`, `accept_all`, `unverified_guess`, `no_mx` (Mode A), or `harvested` (Mode B).

***

### Pricing example

This actor is **pay-per-result**: you are charged once per email found, and never for failed lookups, low-confidence guesses, or collapsed duplicates.

> Example: a run over **100 domains** that finds **60 emails** charges for **60 results**. Domains that yield nothing cost you nothing in result fees.

***

### Use cases

- **Outreach lists.** Turn a list of company domains into a contact list ready for your sending tool.
- **CRM enrichment.** Feed a list of accounts (people or domains) and fill the email column with scored, deduplicated results.
- **Lead research.** Combine both modes — find decision-makers by name where you know them, and harvest general contacts where you don't.
- **Agency prospecting.** Process a target list once, with confidence on every row so you can prioritize the strongest contacts.

***

### FAQ

**Do I need names?** No. Mode B works from domains alone. Mode A is for when you do know the person's name.

**Why do some emails have higher confidence?** A mailbox confirmed over SMTP, or an address published in a `mailto:` link, is more trustworthy than one matched in page text — and the score reflects that.

**Does SMTP verification always run?** Mode A tries it, but many cloud networks block outbound port 25. When that happens the finder automatically falls back to MX + frequency-ranked patterns and labels the method accordingly — you still get a ranked best guess.

**Will I get duplicates?** Not by default. Deduplication collapses repeats into one row. Turn it off if you want to see every occurrence with a `duplicate_flag`.

**Is a proxy required?** For Mode B, a residential proxy is used by default for reliable access to target websites. You can adjust it in `proxyConfiguration`.

***

### Legal & responsible use

This actor collects **publicly available** contact information that companies and individuals choose to publish on their own websites and through public mail records. Use the results in compliance with applicable laws (including GDPR, CAN-SPAM, and local marketing regulations) and the terms of the sites you target. You are responsible for how you contact the people and businesses you find — always honor opt-outs and obtain consent where required.

# Actor input Schema

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

List of company domains or website URLs to harvest published emails from (contact pages, mailto links, page footers). No names needed. Example: \["stripe.com", "notion.so"].

## `people` (type: `array`):

List of people to find work emails for. Each item: firstName (required), lastName (or surname), optional fullName, and domain (required). Example: {"firstName": "Patrick", "lastName": "Collison", "domain": "stripe.com"}.

## `deduplicateEmails` (type: `boolean`):

Collapse the same email found via two inputs into a single row. When off, every occurrence is kept and repeats are marked with duplicate\_flag=true. Default: true.

## `maxPerDomain` (type: `integer`):

Cap how many emails to return per harvested domain — controls cost and noise. Default: 3.

## `verifySmtp` (type: `boolean`):

For the people mode: attempt live SMTP RCPT verification so confirmed mailboxes are marked 'verified'. If your run network blocks outbound port 25, it falls back to MX + pattern ranking. Default: true.

## `maxAlternatives` (type: `integer`):

How many ranked alternative-email candidates to return per person (each with its own confidence). Default: 5.

## `smtpTimeoutSecs` (type: `integer`):

Timeout for each SMTP connection attempt. Increase on slow mail servers. Default: 8.

## `maxItems` (type: `integer`):

Maximum total records to output across both modes. 0 = no limit. Useful for cost control. Default: 0.

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

Proxy used to reach websites in Mode B. Residential is the default and recommended — sites are never touched from a bare datacenter IP.

## Actor input object example

```json
{
  "domains": [
    "diverxo.com",
    "asadoretxebarri.com"
  ],
  "people": [
    {
      "firstName": "Patrick",
      "lastName": "Collison",
      "domain": "stripe.com"
    }
  ],
  "deduplicateEmails": true,
  "maxPerDomain": 3,
  "verifySmtp": true,
  "maxAlternatives": 5,
  "smtpTimeoutSecs": 8,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of email rows (domain, email, first\_name, last\_name, email\_source, confidence, duplicate\_flag, status, is\_role\_account, on\_domain, parse\_confidence).

# 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": [
        "diverxo.com",
        "asadoretxebarri.com"
    ],
    "people": [
        {
            "firstName": "Patrick",
            "lastName": "Collison",
            "domain": "stripe.com"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/email-finder-bulk").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": [
        "diverxo.com",
        "asadoretxebarri.com",
    ],
    "people": [{
            "firstName": "Patrick",
            "lastName": "Collison",
            "domain": "stripe.com",
        }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/email-finder-bulk").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": [
    "diverxo.com",
    "asadoretxebarri.com"
  ],
  "people": [
    {
      "firstName": "Patrick",
      "lastName": "Collison",
      "domain": "stripe.com"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/email-finder-bulk --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Finder Bulk — Lists of Domains or People to Emails",
        "description": "Bulk email finder, two modes in one run: give a list of **company domains** to harvest published emails, OR a list of **people** (name + domain) to find their work email. Per-email confidence, source, role flag, and cross-list dedup. No API key.",
        "version": "0.1",
        "x-build-id": "ab6rYPtEYcdrZ2Q4n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~email-finder-bulk/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-email-finder-bulk",
                "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/bovi~email-finder-bulk/runs": {
            "post": {
                "operationId": "runs-sync-bovi-email-finder-bulk",
                "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/bovi~email-finder-bulk/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-email-finder-bulk",
                "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": {
                    "domains": {
                        "title": "Mode B — Domains (harvest published emails)",
                        "type": "array",
                        "description": "List of company domains or website URLs to harvest published emails from (contact pages, mailto links, page footers). No names needed. Example: [\"stripe.com\", \"notion.so\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "people": {
                        "title": "Mode A — People (name + company domain)",
                        "type": "array",
                        "description": "List of people to find work emails for. Each item: firstName (required), lastName (or surname), optional fullName, and domain (required). Example: {\"firstName\": \"Patrick\", \"lastName\": \"Collison\", \"domain\": \"stripe.com\"}."
                    },
                    "deduplicateEmails": {
                        "title": "Deduplicate emails across the list",
                        "type": "boolean",
                        "description": "Collapse the same email found via two inputs into a single row. When off, every occurrence is kept and repeats are marked with duplicate_flag=true. Default: true.",
                        "default": true
                    },
                    "maxPerDomain": {
                        "title": "Max emails per domain (Mode B)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Cap how many emails to return per harvested domain — controls cost and noise. Default: 3.",
                        "default": 3
                    },
                    "verifySmtp": {
                        "title": "Verify via SMTP (Mode A)",
                        "type": "boolean",
                        "description": "For the people mode: attempt live SMTP RCPT verification so confirmed mailboxes are marked 'verified'. If your run network blocks outbound port 25, it falls back to MX + pattern ranking. Default: true.",
                        "default": true
                    },
                    "maxAlternatives": {
                        "title": "Max alternative emails (Mode A)",
                        "minimum": 0,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many ranked alternative-email candidates to return per person (each with its own confidence). Default: 5.",
                        "default": 5
                    },
                    "smtpTimeoutSecs": {
                        "title": "SMTP timeout (seconds)",
                        "minimum": 2,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Timeout for each SMTP connection attempt. Increase on slow mail servers. Default: 8.",
                        "default": 8
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total records to output across both modes. 0 = no limit. Useful for cost control. Default: 0.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach websites in Mode B. Residential is the default and recommended — sites are never touched from a bare datacenter IP.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```