# VK Email Scraper (`scrapapi/vk-email-scraper`) Actor

- **URL**: https://apify.com/scrapapi/vk-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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 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

### **VK** Email Scraper 📱

**VK** Email Scraper allows users to **extract** a wide range of **data** from **VK** profiles and pages. This includes email addresses, user names, profile URLs, and other publicly available **contact** details.

The tool is designed to provide structured and organized **data** for easy use. With **VK** email **extract**ion tools, you can gather information from individual profiles or groups.

It also supports **extract**ing **data** from **VK** pages, events, and communities. The **extract**ed **data** can be used for marketing, research, or networking purposes.

**VK** email scraping services ensure compliance with ethical standards and **data** privacy regulations. This makes it a reliable choice for professionals and businesses alike.

VK Email Scraper is a powerful tool designed to extract email addresses from VK profiles and pages efficiently. It helps businesses and individuals gather contact information for networking and marketing purposes.

Using VK email extraction tools can save countless hours compared to manual data collection. This software ensures accuracy and speed while adhering to ethical scraping practices.

VK contact scrapers are ideal for professionals looking to expand their reach by connecting with VK users. The tool is built to handle large-scale data extraction with ease and reliability.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract public email addresses from VK profiles and pages. |
| User Names | Retrieve the names of VK users for personalized outreach. |
| Profile URLs | Get links to VK user profiles for further exploration. |
| Group Information | Extract data from VK groups and communities. |
| Event Details | Gather information from VK events for targeted campaigns. |
| Location Data | Collect location details if publicly available on VK profiles. |
| Contact Numbers | Retrieve phone numbers shared publicly on VK profiles. |
| Profile Descriptions | Extract bio and description details from VK profiles. |

### Key Features of **VK** Email Scraper

Here are the **standout features** that make the **VK** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Efficiently extract emails from **VK** profiles and pages
- ⭐ Supports bulk data scraping for large-scale projects
- ⭐ Provides structured and organized data outputs
- ⭐ **Customizable** filters to target specific user groups or locations
- ⭐ **Fast** and reliable scraping process with minimal errors
- ⭐ Built-in compliance with ethical scraping practices
- ⭐ User-friendly interface for easy operation
- ⭐ Supports exporting data in multiple formats like CSV and JSON
- ⭐ **Advanced** algorithms to bypass common scraping limitations
- ⭐ **Regular** updates to ensure compatibility with **VK** platform changes
- ⭐ **Secure** and encrypted data handling for user safety
- ⭐ 247 customer support for troubleshooting and assistance

### How to use **VK** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **VK** emails today:

1. ✅ **Sign up** for the **VK** Email Scraper service and **log in** to your account
2. ✅ Navigate to the dashboard and select the scraping mode (profile group or event)
3. ✅ Enter the **VK** profile URLs or keywords you want to scrape data from
4. ✅ Set your filters such as location group size or activity level
5. ✅ **Start** the scraping process and monitor progress in real-time
6. ✅ Once completed review the extracted data in the results section
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the data responsibly and in compliance with legal guidelines

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for **VK**-based marketing campaigns
🎯 Reach out to potential customers using verified contact details

Networking and Outreach
🎯 Connect with professionals and influencers on **VK**
🎯 Expand your network by reaching out to **VK** group members

Market Research
🎯 **Analyze** **VK** user data for trends and insights
🎯 **Study** community engagement and preferences on **VK**

Event Promotion
🎯 Gather contact details from **VK** event attendees
🎯 Promote your events to relevant **VK** communities

### Why choose us? 💎

**VK** Email Scraper is a trusted solution for extracting emails and other data from **VK**. Our tool is designed with **advanced** algorithms to ensure accuracy and efficiency.

It supports bulk scraping, making it ideal for large-scale projects. We prioritize user experience with a simple and intuitive interface.

Our **VK** email harvesting software is **regular**ly updated to stay compatible with **VK** platform changes. We ensure compliance with ethical standards and data privacy regulations.

Our customer support team is available 24/7 to assist with any issues. Whether you are a marketer, researcher, or business owner, **VK** Email Scraper is tailored to meet your needs.

Choose us for **reliable** and secure **VK** data scraping tools.

### **VK** Email Scraper Scalability 📈

**VK** Email Scraper is built to handle projects of any size, from small-scale extractions to enterprise-level operations. The tool is optimized for high-speed performance, ensuring quick and **efficient** data collection.

Its **advanced** algorithms allow for **seamless** operation even with large datasets. You can scrape **VK** emails fast without compromising on accuracy or data quality.

Our **VK** email finder supports bulk scraping, making it ideal for **extensive** campaigns. It also offers **customizable** filters to narrow down results based on specific criteria.

With scalable infrastructure, **VK** Email Scraper adapts to your growing data scraping needs. This makes it a reliable choice for businesses of all sizes.

### **VK** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **VK** is **legal** as long as you follow **ethical** and **compliant** practices. The **VK** Email Scraper extracts only **publicly available** information from **public** **VK** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** you have permission to scrape data from **VK** profiles or pages
⚖️ **Only** extract publicly available information to respect user privacy
⚖️ **Do not** use **VK** Email Scraper for illegal or unethical purposes
⚖️ Comply with **VK**s terms of service and usage policies
⚖️ **Avoid** scraping sensitive or private data without explicit consent
⚖️ **Use** the extracted data responsibly and for legitimate purposes only
⚖️ Regularly review data privacy laws applicable to your region
⚖️ **Do not** resell or distribute scraped data without proper authorization

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["VK Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "VK",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (VK) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "VK",
    "keyword": "VK Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies VK as the source |
| keyword | Keyword that triggered the result (VK Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct VK profile link |
| email | Extracted email address |

### FAQ ❓

#### What is VK **Email Scraper**?

VK Email Scraper is a tool designed to extract email addresses and other data from VK profiles and pages.

#### Is VK **Email Scraper** **legal** to use?

**Yes**, it is legal if used to extract **publicly available** data and comply with VK's terms of service.

#### Can I scrape data from VK groups?

**Yes**, VK Email Scraper supports data extraction from VK groups and communities.

#### What formats can I **export** the data in?

You can export the data in formats like **CSV** and **JSON** for easy use.

#### Is the tool user-friendly?

**Yes**, VK Email Scraper features a simple interface for easy operation.

#### Does it support bulk data scraping?

**Yes**, the tool is designed for efficient bulk data scraping.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with VK platform changes.

#### Is **customer support** available?

**Yes**, we offer 24/7 customer support for all users.

#### Can I customize the scraping filters?

**Yes**, you can set filters like location or group size to refine your results.

#### Is my data **secure** during the scraping process?

**Yes**, VK Email Scraper ensures **secure** and encrypted data handling.

#### Can I scrape **private** VK profiles?

**No**, the tool only extracts data from **publicly available** VK profiles.

#### What is the pricing for VK **Email Scraper**?

Please visit our website for detailed pricing plans and options.

#### Can I use VK **Email Scraper** for research purposes?

**Yes**, the tool is ideal for market research and data analysis.

#### Does it work with all VK accounts?

**Yes**, as long as the data is publicly accessible on VK.

#### Is there a free trial available?

Please check our website for information on free trials and demo versions.

# Actor input Schema

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

List of keywords to search for on Vk (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Vk profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `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`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Vk",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/vk-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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/vk-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": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/vk-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VK Email Scraper",
        "version": "0.1",
        "x-build-id": "7bgVdGbPJRvlku8uD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~vk-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-vk-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/scrapapi~vk-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-vk-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/scrapapi~vk-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-vk-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": "List of keywords to search for on Vk (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Vk profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Vk"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Vk"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "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": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```