# Mass Discord Email Scraper (`scraper-mind/discord-email-scraper`) Actor

\[𝗖𝗼𝘀𝘁-𝗘𝗳𝗳𝗲𝗰𝘁𝗶𝘃𝗲] Discord Email Scraper extracts publicly available Discord emails and leads using targeted keywords and domains. Fast, accurate, and easy to use—perfect for outreach, lead gen, and research.

- **URL**: https://apify.com/scraper-mind/discord-email-scraper.md
- **Developed by:** [Scraper Mind](https://apify.com/scraper-mind) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 49 total users, 2 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 – Targeted, Scalable & Cost-Effective

The **Discord Email Scraper** is a powerful automation tool designed to extract **Discord emails**, contact details, and user information from public Discord sources using targeted **keywords**, custom domains, and filters. 🚀 It helps businesses, marketers, and researchers gather **Discord leads** quickly, saving hours of manual searching.

By scanning public posts, discussions, and profiles related to your chosen keyword, the scraper identifies **high-intent email leads**, especially when paired with domains like **@gmail.com** or **@outlook.com**.

From an SEO perspective, using a Discord email scraper helps you build segmented outreach lists, enrich CRM data, and power email marketing campaigns—all while keeping your lead-generation workflow efficient, automated, and scalable.

---

### 📩 What **Discord Email Scraper** can I extract?

Below is a visually clean table showing the types of **Discord leads** and metadata you can extract using the tool:

| Data Type Extracted    | Description                                                      |
| ---------------------- | ---------------------------------------------------------------- |
| **Email Address** 📧   | Extracts emails such as `gaming@example.com` from posts or bios. |
| **Keyword Matched** 🎯 | The keyword that triggered the result (e.g., *gaming*).          |
| **Title** 📝           | The title of the Discord post or discussion.                     |
| **Description** 📄     | A short text snippet from the page where the email appears.      |
| **URL** 🔗             | Direct link to the discovered Discord post.                      |
| **Network** 🌐         | The platform source (e.g., Discord.com).                         |

This scraper is ideal for collecting **Discord leads**, targeted contacts, and niche-specific email lists with precision and speed. It ensures every extracted item aligns with your search intent, making your lead pipeline more accurate and efficient.

---

#### ⭐ Key Features of **Discord Email Scraper**

* **🎯 Targeted Keyword Extraction**
  Find emails related to specific industries like *gaming*, *crypto*, *music*, *tech*, and more.

* **📧 Custom Domain Filtering**
  Pull only the emails you want (e.g., `@gmail.com`, `@protonmail.com`, etc.) for hyper-focused lead lists.

* **⚡ Fast & Cost-Effective Engine**
  Choose between a **cost-effective** engine for speed or a **legacy engine** for extra reliability.

* **🌍 Platform-Specific Scraping**
  Built exclusively for **Discord**, ensuring optimized accuracy and results.

* **⛔ Auto-Limit Controls**
  Use **maxEmails** to control cost and prevent unnecessary scraping.

* **📊 High-Quality Lead Output**
  Every result includes URLs, titles, descriptions, and emails—perfect for CRM imports or campaigns.

* **🔒 Proxy Support**
  Use rotating proxies for stability, anonymity, and scale.

---

### 🛠️ How to use **Discord Email Scraper** (Step-by-Step Guide)

Using the scraper is incredibly simple. Follow this beginner-friendly workflow:

1. **Log in to Apify**
   Create a free account or log in to your dashboard.

2. **Select the Actor**
   Search for **“Discord Email Scraper”** in the Apify Store.

3. **Enter Input Data**
   Paste your keywords, custom domains, email limits, and other parameters.

4. **Choose Optional Settings**

   * Select platform: **Discord**
   * Choose engine: **cost-effective** or **legacy**

5. **Run the Actor**
   Click *Start*. The scraper begins extracting targeted **Discord emails** instantly.

6. **Download Results**
   Export your leads as **JSON**, Excel, or CSV for immediate use in outreach tools or CRMs.

This workflow ensures a smooth experience from setup to downloading your final list of **Discord leads**. 💼

---

### 🎯 Use Cases

The **Discord Email Scraper** unlocks powerful applications across industries:

* **📣 Digital Marketing**
  Build laser-targeted email lists for gaming, tech, crypto, SaaS, and community-driven niches.

* **🤝 Lead Generation**
  Find highly relevant **Discord leads** for agency outreach, partnerships, and influencer recruitment.

* **📊 Market Research**
  Collect user discussions, patterns, and contact data to understand niche behaviors.

* **🧪 Academic & Trend Research**
  Extract keyword-based data for analyzing trends in gaming, digital culture, or community engagement.

* **📥 CRM & Sales Pipelines**
  Enrich your CRM with real, intent-based user emails pulled directly from public Discord sources.

If your goal is to reach audiences that live in Discord communities, this scraper is a game-changer.🔥

---

### 💎 Why choose us?

* **⚡ Ultra-Fast Performance** using async scraping and optimized requests.
* **💸 Cost-Effective Engine** for maximum results with minimal cost.
* **🎯 Precise Targeting** with keywords and domain-specific filtering.
* **🔒 Safe & Compliant** with built-in proxy support and configurable limits.
* **📈 SEO-Friendly Output** for teams who need clean, structured data for automation.
* **🤝 Trusted Support** — contact us anytime at **[scrapermindapi@gmail.com](mailto:scrapermindapi@gmail.com)**
* **🔁 Continually Improved** with updates based on user feedback and new scraping techniques (without exposing internal logic).

This scraper is designed for professionals who value speed, accuracy, and reliability.

---

### 📊 How many results can you scrape with **Discord Email Scraper**?

The number of results depends on:

* Your **keywords**
* Your **customDomains**
* **Email availability** on public Discord pages
* **maxEmails** you set
* The scraping engine selected

#### Scalability Highlights:

* You can extract anywhere from **10 to 10,000+ emails**, depending on your settings.
* The scraper stops automatically once it hits your **maxEmails** limit.
* Using broad keywords like *gaming*, *community*, *server*, or *help* significantly increases the volume of **Discord leads**.
* Using multiple domains (`@gmail.com`, `@yahoo.com`, `@outlook.com`) dramatically increases the number of results.
* Running multiple tasks with varied keyword clusters gives you exponential coverage.

Whether you need **a small batch of 50 hyper-targeted emails** or **a bulk set of 5,000 Discord leads**, the scraper scales effortlessly. 🚀

---

### ⚖️ Is it legal to scrape **Discord**?

Scraping Discord is **legal when done responsibly** using publicly accessible information.
Here’s what to know:

* ✔️ Scraping **public** data is generally permitted
* ✔️ You must follow **Discord’s Terms of Service**
* ✔️ Avoid scraping private servers, gated content, or login-required areas
* ✔️ Use the data ethically and respect user privacy
* ✔️ Ensure compliance with regulations like GDPR/CCPA if contacting users

The scraper retrieves only **publicly available** content and is designed to help automate data collection in a compliant, ethical way.

---

### 🧩 Input Parameters

#### 💻 JSON Input Example

```json
{
  "customDomains": ["@gmail.com"],
  "keywords": ["gaming"],
  "maxEmails": 10,
  "location": "",
  "platform": "Discord",
  "engine": "cost-effective"
}
````

#### 🧱 Input Parameter Table

| Parameter              | Type    | Description                  |
| ---------------------- | ------- | ---------------------------- |
| **keywords**           | Array   | Keywords to search for.      |
| **location**           | String  | Optional location filtering. |
| **platform**           | String  | Select platform (Discord).   |
| **customDomains**      | Array   | Filter emails by domain.     |
| **maxEmails**          | Integer | Maximum emails to collect.   |
| **engine**             | String  | Select scraping engine.      |
| **proxyConfiguration** | Object  | Optional proxy settings.     |

***

### 📤 Output Format

#### JSON Output Example

```json
[
  {
    "network": "Discord.com",
    "keyword": "gaming",
    "title": "Friends Account Hacked",
    "description": "Public post discussing gaming community.",
    "url": "https://support.discord.com/hc/...",
    "email": "example@gmail.com"
  }
]
```

#### Output Table

| Field           | Description                    |
| --------------- | ------------------------------ |
| **network**     | Source platform.               |
| **keyword**     | Matched keyword.               |
| **title**       | Page or post title.            |
| **description** | Snippet where email was found. |
| **url**         | Direct link to the content.    |
| **email**       | Extracted email address.       |

***

### ❓ FAQ

#### 1. Does the Discord Email Scraper work instantly?

Yes! Results start appearing within seconds depending on your keyword and engine.

#### 2. Can I scrape only Gmail emails?

Absolutely — just include **@gmail.com** in customDomains.

#### 3. Does it scrape Discord servers?

No, only **public-facing pages** are scraped for compliance.

#### 4. Can I run it daily?

Yes! It’s perfect for recurring lead-generation tasks.

#### 5. What’s the best keyword strategy?

Use **broad + niche** terms (e.g., *gaming*, *gaming help*, *gaming tips*).

#### 6. How many emails can I extract at once?

Up to **10,000**, depending on availability and your maxEmails setting.

#### 7. Do I need proxies?

Optional, but recommended for large-scale runs.

# Actor input Schema

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

A list of keywords to search for.

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

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `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.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "gaming"
  ],
  "location": "",
  "platform": "Discord",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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": [
        "gaming"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-mind/discord-email-scraper").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": ["gaming"],
    "location": "",
    "customDomains": ["@gmail.com"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass Discord Email Scraper",
        "description": "[𝗖𝗼𝘀𝘁-𝗘𝗳𝗳𝗲𝗰𝘁𝗶𝘃𝗲] Discord Email Scraper extracts publicly available Discord emails and leads using targeted keywords and domains. Fast, accurate, and easy to use—perfect for outreach, lead gen, and research.",
        "version": "0.0",
        "x-build-id": "mCpeTk3BSUhfGRWAE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-mind~discord-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-mind-discord-email-scraper",
                "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/scraper-mind~discord-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-mind-discord-email-scraper",
                "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/scraper-mind~discord-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-mind-discord-email-scraper",
                "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",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "gaming"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Discord"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Discord"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "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
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```