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

🚀⚡ Discord Email Scraper Fast Advanced And Cheapest extracts verified email leads from Discord communities fast. 💰 Cost-effective & advanced filters for targeted outreach. Perfect for sales, marketing, and lead generation—start scraping in minutes!

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

## Pricing

from $1.99 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

**Discord Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from publicly available Discord-related sources using the keywords and email-domain filters you specify. If you’re using a **discord email scraper** to build outbound lists, a **discord email finder** for faster prospecting, or a **bulk discord email scraping tool** for research, this actor helps automate lead discovery at scale—without hours of manual searching.

Whether you’re a marketer, recruiter, or data enthusiast, this **discord members email extraction** workflow is designed to save you time by pulling relevant emails that match your targeting criteria and exporting them into a structured dataset.

---

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

| Feature | Benefit |
|---|---|
| ✅ **Keyword-based email extraction** | Find emails using the keywords you provide, instead of guessing |
| ✅ **Custom email-domain filtering** | Focus results on domains you care about (e.g. `@gmail.com`, `@yahoo.com`) |
| ✅ **Built-in resume progress** | Continues from a saved cursor so long runs are less likely to restart |
| ✅ **Max emails limit control** | Cap scraping to keep runs predictable and manage costs |
| ✅ **Reliability-focused execution** | Includes retries and fallbacks for resilience during scraping |
| ✅ **Structured dataset output** | Saves each lead with fields like `keyword`, `title`, `url`, and `email` |

---

### Key features

- 🔍 **Accurate email extraction**: Extracts email addresses found in fetched content and filters them by your selected domains  
- 🧩 **Flexible targeting inputs**: Use multiple `keywords` plus `customDomains` and optional `location` filtering to refine results  
- 🛡️ **Resilient scraping behavior**: Implements retry logic, handling empty/failed pages to improve completion rate  
- 💾 **Incremental saving**: Pushes each extracted lead into the dataset as it’s found  
- 🔁 **Resume where it left off**: Saves progress (including `cursor` and `seen_emails`) so runs can continue after interruptions  
- 🎯 **Cost-aware limits**: Uses `maxEmails` to stop when you’ve collected enough emails (doesn’t guarantee the target will be reached)  
- 📊 **Clean, analysis-friendly output**: Produces consistent fields for easy filtering and exporting into other tools  

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | Yes | A list of keywords (or queries) used to find relevant Discord-related pages and extract emails from them. |
| `location` | No | Optional location text to filter results and help narrow down the targets you’re interested in. |
| `customDomains` | No | A list of email domains (like `@gmail.com` or `@yahoo.com`) used to filter extracted emails so you only collect matching addresses. |
| `maxEmails` | No | The maximum number of emails to collect. The actor stops when this limit is reached. Higher values can take longer and still don’t guarantee reaching the target. |

***

### Output

The actor saves leads into the Apify dataset as JSON records (one pushed record per extracted email).

Example output record:

```json
{
  "network": "Discord.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | The network label for the source (`"Discord.com"`). |
| `keyword` | string | The keyword used for this extraction batch. |
| `title` | string | The extracted page title text (falls back to `"No title"` when missing). |
| `description` | string | The extracted textual description used for email extraction (`"No data"` when missing). |
| `url` | string | The extracted URL for the result item (`"No URL"` when missing). |
| `email` | string | A unique email address extracted and matching your selected domains. |

> Results are pushed incrementally to the dataset while the run is in progress, which makes exporting to JSON/CSV straightforward after completion.

***

### How to use Discord Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**
   Go to [console.apify.com](https://console.apify.com) and sign in.

2. **Find the actor**
   Search for **Discord Email Scraper - Fast, Advanced and Cheapest** in the Actors section.

3. **Go to the INPUT section**
   Use the built-in input form (or paste your `input.json` contents).

4. **Set your email targeting**
   Enter one or more values in `keywords`, and add the domains you want in `customDomains` (for example `@gmail.com` or `@yahoo.com`).

5. **Optional: add location filtering**
   Fill in `location` if you want to narrow results by region or city.

6. **Optional: cap results**
   Set `maxEmails` to control how many unique emails you want to collect per run. If you don’t set it, the default is used.

7. **Run the actor**
   Click **Run** and monitor the logs. The actor will push results to the dataset as it finds emails, and it will reuse saved progress when resuming.

8. **Export your dataset**
   After completion, open the dataset and export your results (JSON/CSV) for use in your outreach workflows.

No coding required — get accurate results in minutes with this **discord email harvesting tool**.

***

### Advanced features & SEO optimization

- 🧠 **Engineered for “discord email scraper” workflows**: Built specifically around keyword + email-domain filtering, making it a practical **discord email extraction software** for lead lists
- ⏱️ **Run-length control with `maxEmails`**: Helps you stay within predictable bounds for a **fast discord email scraper** experience
- 🔄 **Resume support for long batches**: Uses saved state so you don’t lose progress during extended scraping sessions
- 🧾 **Structured lead fields for analysis**: Consistent dataset rows make it easier to filter by `keyword`, inspect `url`, and review extracted `title`/`description`
- 🛡️ **Resilience improvements**: Includes retry logic and fallback behavior when results are empty or blocked, improving reliability for **advanced discord email scraper** use cases

***

### Best use cases

- 📈 **Outbound lead generation**: Build a contact list faster by extracting emails that match your targeted domains from Discord-related pages
- 🎯 **Marketing segmentation**: Use `keywords` + `customDomains` to generate focused **discord leads email scraper** results by role and email provider
- 🧠 **Market research**: Rapidly gather email contacts for competitive or niche discovery projects using **discord user email list** style outputs
- 🏢 **B2B outreach research**: Focus on company-relevant domains to build a cleaner **discord contact email scraper** dataset for outreach
- 🧾 **CRM enrichment pipelines**: Feed extracted emails into your CRM workflow for automated deduping and enrichment (structured dataset fields support this)
- 🔎 **Data analysis & validation**: Analyze which keywords produce more `email` matches and review associated `url`, `title`, and `description`
- ⚙️ **Automation-friendly scraping**: Use this **automated discord email scraper** actor to run recurring lead refresh jobs at scale

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings (required)
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array of strings (optional)
  - ✅ `maxEmails` as an integer (optional, default behavior applies)

- **Proxy Support**
  - ✅ Includes proxy support for reliable scraping behavior (with retry and fallback resilience)

- **Retry Mechanism**
  - ✅ Includes retry and fallback logic for pages that fail or yield empty results

- **Dataset Structure**
  - ✅ Dataset title: **Discord Emails Dataset**
  - ✅ Default view: **Scraped Leads**
  - ✅ Each row includes: `keyword`, `title`, `description`, `url`, `email`

- **Limitations**
  - ❌ Results are not guaranteed to reach your `maxEmails` target
  - ❌ Free runs enforce a maximum of **100 emails** (unless running as a paid user)
  - ❌ Only emails matching your `customDomains` pattern are extracted into `email`

***

### FAQ

#### Does Discord Email Scraper - Fast, Advanced and Cheapest extract emails only from Discord profiles?

✅ It extracts email addresses from publicly available Discord-related sources based on your provided `keywords` and `customDomains`. The dataset output is labeled with `network: "Discord.com"`.

#### What input fields are required?

✅ Only `keywords` is required. You can optionally add `location`, `customDomains`, and `maxEmails` to refine targeting.

#### Can I control how many emails I collect?

✅ Yes. Use `maxEmails` to set the maximum number of emails to collect. The actor stops once the limit is reached, though it doesn’t guarantee that the exact number will be reached.

#### Why might I get fewer results than expected?

✅ The actor stops when it can no longer find new matching emails, and results depend on what’s available in publicly accessible sources that match your keywords and selected email domains.

#### Is there a limit on free plans?

✅ Yes. If you’re not on a paid plan, free user runs apply a maximum of **100 emails**.

#### What does the dataset contain after the run?

✅ The dataset stores structured lead rows with fields including `keyword`, `title`, `description`, `url`, and `email`, labeled with `network: "Discord.com"`.

#### Can I resume a long run if it stops?

✅ Yes. The actor saves progress (including `cursor` and `seen_emails`) so it can resume without starting from scratch.

#### Is this useful for building a discord server email scraping lead list?

✅ It can be a strong fit for creating a **discord server email scraping** workflow—especially when you use role/intent keywords and domain filters to produce consistent contact leads for outreach.

***

### Support & feature requests

Want improvements to your **Discord Email Scraper - Fast, Advanced and Cheapest** workflow? Share feedback or request enhancements.

- 💡 **Feature Requests**: Examples include better export options (CSV formatting), expanding matching behavior, or adding new filters tailored to common **discord email finder** use cases.
- 📧 **Contact**: For support and feature requests, email <dataforleads@gmail.com>.

Your feedback helps shape future upgrades to this **discord email harvesting tool**.

***

### Closing CTA / Final thoughts

*If you need the most comprehensive **Discord Email Scraper - Fast, Advanced and Cheapest** for scalable email extraction, this actor delivers structured leads fast—powered by your keywords and domain filters.*

# 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("scrapers-hub/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("scrapers-hub/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 scrapers-hub/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=scrapers-hub/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": "🚀⚡ Discord Email Scraper Fast Advanced And Cheapest extracts verified email leads from Discord communities fast. 💰 Cost-effective & advanced filters for targeted outreach. Perfect for sales, marketing, and lead generation—start scraping in minutes!",
        "version": "1.0",
        "x-build-id": "ZgLOQ6dqKRAAim5Tc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~discord-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-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/scrapers-hub~discord-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-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/scrapers-hub~discord-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
