# Taobao Email Scraper (`scrapapi/taobao-email-scraper`) Actor

- **URL**: https://apify.com/scrapapi/taobao-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

### **Taobao** Email Scraper 📱

The **Taobao** Email Scraper is designed to **extract** essential **contact** information from **Taobao** sellers. It focuses on gathering email addresses, seller details, and other relevant **data** to help you connect with businesses.

This tool ensures that the **extract**ed **data** is accurate and up-to-date, providing reliable results for your needs. It can **extract** **data** from multiple seller profiles, making it a scalable solution for businesses of any size.

The scraper also allows you to customize your **data** **extract**ion process, ensuring you get the specific information you need. With its advanced capabilities, the **Taobao** Email Scraper is a versatile tool for email collection and **data** analysis.

Taobao Email Scraper is a powerful tool designed to help you extract email addresses from Taobao efficiently. It simplifies the process of gathering contact information from sellers and businesses on the platform.

With the Taobao Email Scraper, you can automate email collection, saving time and effort. This tool is ideal for businesses, marketers, and researchers looking to connect with Taobao sellers.

Our Taobao contact extractor ensures accurate and reliable data extraction. It is built to handle large-scale scraping while maintaining compliance with ethical guidelines.

### 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 seller email addresses from Taobao profiles. |
| Seller names | Retrieve the names of Taobao sellers for better identification. |
| Store details | Collect information about Taobao stores, including store names and descriptions. |
| Product links | Fetch links to products listed by the sellers. |
| Contact numbers | Extract available phone numbers from seller profiles. |
| Location details | Retrieve location information of the sellers, if available. |
| Seller ratings | Gather ratings and reviews associated with Taobao sellers. |
| Social media links | Extract links to social media profiles shared by sellers. |

### Key Features of **Taobao** Email Scraper

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

- ⭐ Automates the process of extracting emails from **Taobao** seller profiles
- ⭐ Supports large-scale data scraping for businesses of all sizes
- ⭐ Provides accurate and up-to-date email and contact information
- ⭐ User-friendly interface requiring no advanced technical skills
- ⭐ **Customizable** scraping options to meet specific data extraction needs
- ⭐ Ensures compliance with ethical and legal data scraping guidelines
- ⭐ Offers detailed reports and organized data output formats
- ⭐ Compatible with various devices and operating systems
- ⭐ Includes advanced filtering options for targeted email collection
- ⭐ Provides seamless integration with other data analysis tools

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

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

1. ✅ **Sign up** for the **Taobao** Email Scraper and **log in**to your account
2. ✅ Install the scraper tool on your preferred device or access it via the web interface
3. ✅ Enter the **Taobao** URLs or keywords you want to scrape data from
4. ✅ **Configure** the scraping settings to customize the data extraction process
5. ✅ **Start** the scraper and allow it to collect the required information
6. ✅ Monitor the scraping progress through the dashboard or logs
7. ✅ Download the extracted data in your preferred format such as CSV or JSON
8. ✅ **Review** the data for accuracy and use it for your intended purpose

### Use Cases 🎯

Business Development
🎯 **Identify** and connect with **Taobao** sellers to expand your business network
🎯 Gather contact information to establish partnerships with **Taobao** businesses

Marketing Campaigns
🎯 Build a database of seller emails for targeted email marketing campaigns
🎯 Reach out to sellers with promotional offers and product updates

Market Research
🎯 **Analyze** seller data to understand market trends and competition
🎯 **Collect** information about product listings and seller ratings

Lead Generation
🎯 Generate high-quality leads by extracting contact details of **Taobao** sellers
🎯 Streamline the process of identifying potential clients or partners

### Why choose us? 💎

Our **Taobao** Email Scraper stands out as the **best** **Taobao** scraper tool due to its accuracy and efficiency. It is designed to handle large-scale data extraction while ensuring compliance with ethical guidelines.

The tool is **user-friendly**, making it accessible to both technical and non-technical users. We prioritize data reliability, providing you with accurate and up-to-date information every time.

With customizable scraping options, the tool allows you to tailor the data extraction process to your specific needs. Our scraper is compatible with various devices and operating systems, ensuring seamless integration into your workflow.

We also offer excellent customer support to assist you with any issues or queries. By choosing our **Taobao** Email Scraper, you are investing in a **reliable** and efficient solution for your data scraping needs.

### **Taobao** Email Scraper Scalability 📈

The **Taobao** Email Scraper is built to handle data extraction at any scale. Whether you need to scrape a few profiles or thousands, the tool ensures consistent performance.

It is optimized for speed and accuracy, allowing you to gather large volumes of data without compromising quality. Our scraper supports batch processing, enabling you to extract data from multiple URLs simultaneously.

With its **advanced** filtering options, you can focus on specific data points, making the process more **efficient**. The tool is also designed to adapt to changes in **Taobao**'s structure, ensuring long-term usability.

For businesses with growing data needs, the **Taobao** Email Scraper provides a scalable and reliable solution.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Taobao**s terms of service when using the scraper
⚖️ **Use** the **Taobao** Email Scraper only for lawful and ethical purposes
⚖️ **Avoid** scraping personal data without the explicit consent of the individual
⚖️ **Do not** use the tool to send spam or unsolicited emails to scraped contacts
⚖️ Respect the privacy of **Taobao** sellers and their provided information
⚖️ Regularly review and adhere to data protection laws in your jurisdiction
⚖️ **Use** the scraper responsibly to avoid overloading **Taobao**s servers
⚖️ **Do not** share or sell extracted data without proper authorization

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Taobao Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Taobao",
  "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 (Taobao) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Taobao",
    "keyword": "Taobao 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 Taobao as the source |
| keyword | Keyword that triggered the result (Taobao Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Taobao profile link |
| email | Extracted email address |

### FAQ ❓

#### What is the Taobao **Email Scraper**?

The Taobao Email Scraper is a tool designed to extract email addresses and other contact information from Taobao seller profiles.

#### Is the Taobao **Email Scraper** easy to use?

**Yes**, the scraper is **user-friendly** and requires no advanced technical skills to operate.

#### Can I customize the data **extract**ion process?

**Yes**, the tool offers customizable scraping options to meet your specific needs.

#### Is the **extract**ed data accurate?

The Taobao Email Scraper ensures accurate and up-to-date data extraction.

#### Does the scraper comply with **legal** guidelines?

**Yes**, the scraper is designed to operate within ethical and legal boundaries.

#### What formats are available for the **extract**ed data?

The extracted data can be downloaded in formats such as **CSV** or **JSON**.

#### Can I scrape data from multiple Taobao profiles simultaneously?

**Yes**, the scraper supports batch processing for efficient data extraction.

#### Is the scraper compatible with all devices?

The Taobao Email Scraper is compatible with various devices and operating systems.

#### How do I ensure compliance with Taobao's terms of service?

Review Taobao's terms of service and use the scraper responsibly to avoid violations.

#### What support is available for the Taobao **Email Scraper**?

We offer excellent customer support to assist you with any issues or queries.

# Actor input Schema

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

List of keywords to search for on Taobao (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Taobao 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": "Taobao",
  "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/taobao-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/taobao-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/taobao-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Taobao Email Scraper",
        "version": "0.1",
        "x-build-id": "gGqjova2RGlumZxfE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~taobao-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-taobao-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~taobao-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-taobao-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~taobao-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-taobao-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 Taobao (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Taobao profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Taobao"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Taobao"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```