# Lazada Email Scraper (`scrapier/lazada-email-scraper`) Actor

Lazada Email Scraper gathers public email contacts for agencies and consultants analyzing Lazada sellers. Identify partners, suppliers, or advertisers while reducing manual research time.

- **URL**: https://apify.com/scrapier/lazada-email-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$24.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

### **Lazada** Email Scraper 📱

**Lazada** Email Scraper allows you to **extract** a variety of **data** types from the **Lazada** platform. This includes email addresses of sellers, customers, and business **contact**s.

The tool ensures that the **data** collected is accurate, up-to-date, and relevant to your business needs. Users can **extract** information such as seller profiles, **contact** details, and other meta**data** associated with email addresses.

This **data** can be used to build targeted email campaigns, expand your customer base, or analyze market trends. The **Lazada** email **extract**or tool is designed to handle large **data**sets, making it suitable for businesses of all sizes.

### 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 verified email addresses from Lazada sellers and customers. |
| Seller Profiles | Retrieve detailed profiles of Lazada sellers, including their contact information. |
| Customer Information | Collect email data from customers for targeted marketing campaigns. |
| Product Metadata | Gather metadata related to products, including associated seller information. |
| Business Contact Details | Extract contact details of businesses operating on Lazada. |
| Email Domains | Identify and categorize email domains for better segmentation. |
| Location Data | Collect location-based data linked to email addresses. |
| Timestamps | Retrieve timestamps associated with email collection for tracking purposes. |

### Key Features of **Lazada** Email Scraper

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

- ⭐ **Automated** scraping of email addresses from **Lazada**s platform for efficiency and accuracy
- ⭐ Supports large-scale data extraction to handle extensive datasets with ease
- ⭐ User-friendly interface for seamless operation and minimal learning curve
- ⭐ **Advanced** filtering options to extract only relevant and targeted email data
- ⭐ Compliance with legal and ethical guidelines for secure data collection
- ⭐ **Customizable** settings to tailor the scraping process to your specific needs
- ⭐ Real-time data extraction to ensure the information is always up-to-date
- ⭐ Export data in multiple formats for easy integration with other tools
- ⭐ Built-in error handling to minimize disruptions during the scraping process
- ⭐ **Regular** updates to ensure compatibility with **Lazada**s platform changes
- ⭐ **High**-speed performance to complete scraping tasks quickly and efficiently
- ⭐ Detailed documentation and customer support for a smooth user experience

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

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

1. ✅ **Sign up** for an account on the **Lazada** Email Scraper platform
2. ✅ Download and install the **Lazada** email scraping software on your device
3. ✅ Log in to the tool using your credentials and access the dashboard
4. ✅ Enter your search criteria such as keywords or seller categories to target specific data
5. ✅ **Configure** the scraping settings including filters and output format as per your requirements
6. ✅ **Start** the scraping process and monitor the progress in real-time on the dashboard
7. ✅ Once the scraping is complete review the extracted data for accuracy and relevance
8. ✅ **Export** the data in your preferred format such as CSV or Excel for further use
9. ✅ **Integrate** the exported data with your CRM or email marketing tools for campaigns
10. ✅ Regularly update the tool to ensure compatibility with **Lazada**s platform changes
11. ✅ Refer to the detailed documentation for troubleshooting or advanced configurations
12. ✅ Contact customer support if you encounter any issues during the scraping process

### Use Cases 🎯

Marketing Campaigns
🎯 Extract emails from **Lazada** to create targeted email marketing campaigns
🎯 Build a **Lazada** email database for promotional activities and offers

Business Outreach
🎯 **Use** the **Lazada** email harvesting tool to connect with sellers and businesses
🎯 Expand your professional network by collecting business contact details

Market Analysis
🎯 **Analyze** seller profiles and customer data to identify market trends
🎯 Gather product metadata to understand consumer preferences on **Lazada**

Customer Engagement
🎯 **Use** the **Lazada** email collection tool to engage with potential customers
🎯 Send personalized emails to improve customer relationships and retention

### Why choose us? 💎

**Lazada** Email Scraper is the **best** email scraper for **Lazada** due to its **advanced** features and **user-friendly** design. It ensures accurate and efficient data extraction, saving you time and effort.

Our tool is equipped with customizable settings, allowing you to tailor the scraping process to your specific needs. We prioritize compliance with legal and ethical guidelines, ensuring secure and responsible data collection.

The software supports large-scale data extraction, making it suitable for businesses of all sizes. Regular updates keep the tool compatible with **Lazada**'s platform changes, ensuring uninterrupted performance.

Our dedicated customer support team is always available to assist you with any issues or questions. By choosing our **Lazada** email extractor tool, you gain access to a **reliable** and efficient solution for your email scraping needs.

Whether you are a marketer, business owner, or analyst, our tool is designed to help you achieve your goals.

### **Lazada** Email Scraper Scalability 📈

The **Lazada** Email Scraper is designed to handle **large-scale** data extraction with ease. It supports high-speed performance, ensuring you can collect **extensive** datasets quickly and **efficient**ly.

Our tool is built to accommodate the needs of businesses of all sizes, from small startups to large enterprises. With **advanced** filtering options, you can target specific data without compromising on accuracy.

The software's robust architecture ensures stability and reliability, even during heavy usage. Regular updates and maintenance keep the tool optimized for **Lazada**'s platform changes.

Whether you need to extract a few hundred emails or build a massive email database, our tool can scale to meet your requirements. By automating the data collection process, the **Lazada** email extractor tool saves time and resources, allowing you to focus on your core business activities.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Lazada**s terms of service when using the email scraper
⚖️ **Do not** use the tool to collect emails for spamming or unethical marketing practices
⚖️ Respect user privacy and avoid extracting sensitive or personal information
⚖️ **Use** the tool only for legitimate business purposes and with proper consent where required
⚖️ Regularly review and adhere to data protection laws in your region such as GDPR or CCPA
⚖️ **Avoid** overloading **Lazada**s servers to maintain platform integrity and avoid potential bans
⚖️ **Do not** sell or distribute extracted data without proper authorization
⚖️ Always disclose your data collection practices to relevant stakeholders

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Lazada **Email Scraper**?

Lazada Email Scraper is a tool designed to extract email addresses and related data from the Lazada platform efficiently.

#### Is the Lazada email **extract**or tool **legal** to use?

**Yes**, it is legal when used in **compliance** with Lazada's terms of service and applicable data protection laws.

#### Can I **extract** emails from Lazada sellers?

**Yes**, the tool allows you to extract email addresses and other details from Lazada seller profiles.

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

You can export the extracted data in formats such as **CSV** or Excel for easy integration.

#### Is the tool suitable for **large-scale** data **extract**ion?

**Yes**, the Lazada Email Scraper is designed to handle large-scale data collection efficiently.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Lazada's platform changes.

#### Can I customize the scraping process?

**Yes**, the tool offers advanced **filtering** and customization options to meet your specific needs.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lazada Email Scraper",
        "description": "Lazada Email Scraper gathers public email contacts for agencies and consultants analyzing Lazada sellers. Identify partners, suppliers, or advertisers while reducing manual research time.",
        "version": "0.1",
        "x-build-id": "1EzPFDurqNqiILBTm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~lazada-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-lazada-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/scrapier~lazada-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-lazada-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/scrapier~lazada-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-lazada-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 Lazada (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Lazada profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Lazada"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Lazada"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```