# Discord Email Scraper Fast Advanced And Cheapest (`scraperoka/discord-email-scraper-fast-advanced-and-cheapest`) Actor

📧 Extract emails fast with Discord Email Scraper—Advanced, accurate, and cost-effective. 🚀 Perfect for outreach, sales, and lead generation. ⚡ Scan targets efficiently and save time with reliable scraping results.

- **URL**: https://apify.com/scraperoka/discord-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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.

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

### Discord Email Scraper - Fast, Advanced and Cheapest 🎯

Manually collecting contact emails from Discord communities wastes hours you don’t have. **Discord Email Scraper - Fast, Advanced and Cheapest** helps by extracting email addresses from publicly available Discord pages using the keywords and email-domain filters you choose. It’s an ideal **discord email scraper** for marketers, recruiters, and growth teams who want a **fast discord email extract tool**—and you can pull results at scale in a single run.

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Discord.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "https://example.com/profile/123",
  "email": "alex@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network the lead was found on (shown as `Discord.com`) |
| `keyword` | string | Which keyword/term combination produced this specific lead |
| `title` | string | The page title text captured alongside the contact (useful for qualification) |
| `description` | string | The surrounding text used to locate the email (helps you validate context) |
| `url` | string | The page URL tied to the discovered email address |
| `email` | string | The extracted email address you can use for outreach |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

### Why Discord Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull data from public web sources — here’s what sets **Discord Email Scraper - Fast, Advanced and Cheapest** apart.

#### Fast, keyword-driven extraction

You control what to look for by providing your own `keywords`. This makes the **discord email extract tool** feel “built around your ICP” instead of returning random results.

#### Email-domain targeting for cleaner lists

With `customDomains`, you can focus on specific email extensions (for example `@gmail.com`, `@yahoo.com`). This is a practical way to improve the signal in your **discord email harvesting tool** output.

#### Built-in stopping rules to control cost

The actor collects up to `maxEmails` and stops once the limit is reached. That helps you run faster tests without accidentally scraping far beyond what you need.

#### Resumable progress for fewer wasted runs

If a run is interrupted, it resumes using saved progress (including already seen emails and a cursor). This keeps your **automated discord email scraper** workflow efficient across multiple attempts.

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords (queries) the actor uses to find relevant Discord email leads |
| `location` | ⬜ | A location filter you can set to narrow results (leave empty for no location filtering) |
| `customDomains` | ⬜ | Email domains to target during extraction (for example `@gmail.com`, `@yahoo.com`) |
| `maxEmails` | ⬜ | Maximum number of emails to collect before stopping (helps control scraping time and cost) |

### Core Capabilities

#### Targeted keyword search for lead discovery

The actor runs based on your provided `keywords`, building a focused **discord email scraper** workflow around the terms you care about.

#### Custom email-domain filtering

Use `customDomains` to constrain results to specific email extensions. This is especially useful if you’re using a **discord contact email finder** workflow with deliverability or ICP constraints.

#### Resilient execution with run-time control

It uses saved progress and manages extraction until your stopping conditions are met. This gives your **fast discord email scraper** runs better practical reliability for real production use.

#### Clear, integration-ready dataset output

Each lead is pushed incrementally into the dataset with a consistent set of fields: `network`, `keyword`, `title`, `description`, `url`, and `email`. That makes it easy to filter, enrich, and import into downstream tools.

#### Scales via multi-keyword and multi-domain combinations

Your results come from iterating over keyword and domain combinations. With the right keyword set and domains, the **advanced discord email scraper** can cover more ground in fewer runs.

### Who Gets the Most Out of This

Here’s how different teams put **Discord Email Scraper - Fast, Advanced and Cheapest** to work:

**Marketing teams** use it to build outreach lists quickly by starting with targeted role-style keywords like “manager” and “founder,” then filtering to the email domains they prefer. The result is a ready-to-merge dataset of emails with context (`url`, `title`, and `description`) for faster lead qualification.

**Recruiters** use this **discord email extract tool** to find potential candidates’ public contact emails based on the keywords that match their searches. They can cap `maxEmails` for controlled experiments and scale up once the lead quality looks good.

**Sales teams** apply `customDomains` to focus on domains that match their ideal customer profile, helping keep the list cleaner before CRM import. This supports “find discord emails quickly” workflows without manual browsing.

**Freelance researchers** rely on the consistent dataset fields to collect evidence-based contact data from public sources for analysis and reporting. The `keyword` value included per record makes it easier to segment results by search intent.

**Data engineers and automation specialists** can treat **automated discord email scraper** runs as a repeatable pipeline stage. Because results are written directly to the dataset with structured fields, they can integrate the actor run output into their existing ETL process using the Apify API.

### Step-by-Step: How to Use It

No coding needed. Here’s how to run Discord Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — go to the actor page on [console.apify.com](https://console.apify.com).
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — if you use proxy support for reliable scraping, enable it in the Run Options / proxy configuration of your choice.
4. **Hit Run and watch the live log** — the actor runs and pushes results incrementally as it finds emails.
5. **View results in the dataset tab** — check the “Scraped Leads” dataset view (table with `keyword`, `title`, `description`, `url`, `email`).
6. **Export as JSON, CSV, or Excel** — download directly from the dataset export options.

The whole process takes under 5 minutes to set up.

### Integrations & Export Options

Once your data is collected, **Discord Email Scraper - Fast, Advanced and Cheapest** plugs directly into your existing workflow.

Export formats are available from the Apify dataset tab as **JSON, CSV, or Excel**, making it simple to import into CRMs, spreadsheets, and internal systems. If you use automation, you can connect results to tools via Apify’s API, Zapier/Make-style automation flows, or webhooks to trigger downstream steps when a run completes.

For deeper automation options and programmatic usage, see Apify’s API documentation at https://apify.com/docs/api.

### Pricing & Free Trial

Discord Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can run small tests with free credits, then scale up as your workflow becomes more reliable and repeatable.

Beyond the free tier, pricing is typically based on Apify platform compute (pay-as-you-go). Start for free at [apify.com](https://apify.com) and scale when you’re ready.

### Reliability & Performance

| What We Handle | How |
|---|---|
| Extraction stopping rules | Uses `maxEmails` to stop once your requested volume is reached |
| Run resilience | Saves progress and resumes with previously seen emails and cursor state |
| Duplicate control | Tracks `seen_emails` to avoid pushing duplicates |
| Incremental dataset writing | Pushes records as they’re found, so work isn’t lost if a run stops early |
| Practical efficiency | Includes logic to stop when additional pages aren’t yielding new emails |

**Limitations:** The actor extracts email addresses from publicly available sources. If Discord pages don’t contain emails matching your provided filters, you may get fewer results than expected. For enterprise-scale runs, contact us to discuss custom configurations.

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier for this actor so you can run smaller tests before scaling up.

#### Do I need to log in to Discord to use this?

No. This actor is designed to extract emails from publicly available sources without requiring logins.

#### How accurate is the data?

It’s only as accurate as the emails that appear in publicly available content that matches your keyword and domain filters. The actor extracts emails based on what it finds in the available text.

#### How many results can I get per run?

You control the maximum number of emails to collect with the `maxEmails` input. If you request more than the free tier allows, a free-user cap can be applied.

#### How often is the data updated / how fresh is it?

Freshness depends on when the underlying publicly available pages show updates. Each run captures the data at the time it performs the extraction.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor works with **publicly available data**, but you’re responsible for compliance with GDPR, CCPA, platform terms, and any applicable regulations for how you store and use the results.

#### Can I export results to Google Sheets or Excel?

Yes. You can export the dataset directly from Apify as JSON, CSV, or Excel, which you can then import into Google Sheets or other tools.

#### Can I run this on a schedule automatically?

Yes. You can schedule Apify actor runs using Apify scheduling features available in the platform.

#### Can I access this via API?

Yes. You can trigger runs and fetch results programmatically using the Apify API.

#### What happens if the actor hits an error?

If errors occur while pushing a record, the actor logs the issue and continues. Progress is saved so the run can resume without losing already collected work.

### Need Help or Have a Request?

Got a question about **Discord Email Scraper - Fast, Advanced and Cheapest** or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and feedback on improving keyword and filtering results. Feature ideas welcome—such as webhook notifications on completion or additional filtering options.

### Disclaimer & Responsible Use

*Discord Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to build email lead lists from public sources — start your free run today.*

This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform ToS, and any applicable local regulations when using or storing the data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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 = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/discord-email-scraper-fast-advanced-and-cheapest").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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/discord-email-scraper-fast-advanced-and-cheapest").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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/discord-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/discord-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Discord Email Scraper Fast Advanced And Cheapest",
        "description": "📧 Extract emails fast with Discord Email Scraper—Advanced, accurate, and cost-effective. 🚀 Perfect for outreach, sales, and lead generation. ⚡ Scan targets efficiently and save time with reliable scraping results.",
        "version": "1.0",
        "x-build-id": "OE2aKxOnhsjgd8Hbu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~discord-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-discord-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~discord-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-discord-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~discord-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-discord-email-scraper-fast-advanced-and-cheapest",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
