# Shopee Email Scraper (`scraperx/shopee-email-scraper`) Actor

📩 Shopee Email Scraper extracts seller contact emails from Shopee pages with smart, automated scraping. 🚀 Perfect for lead generation, B2B outreach, and market research—save time and boost your workflow with accurate results.

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

## Pricing

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

### **Shopee** Email Scraper 📱

**Shopee** Email Scraper allows you to **extract** a wide range of **data** points from the **Shopee** platform. This includes seller **contact** information, email addresses, and other relevant profile details.

The scraper is designed to provide accurate and up-to-date **data** for your marketing, outreach, or analytical needs. By using this tool, you can streamline your **data** collection process and focus on leveraging the insights gained.

It is particularly useful for businesses looking to expand their customer base or connect with **Shopee** sellers. The **data** is **extract**ed in a structured format, making it easy to integrate with your existing systems or workflows.

Whether you are a small business owner or a large enterprise, this tool can be customized to meet your specific requirements. **Shopee** Email Scraper ensures that you can access the **data** you need without manual effort, saving you time and resources.

Shopee Email Scraper is a powerful tool designed to help businesses and individuals extract email addresses and contact information from Shopee. It simplifies the process of gathering seller and customer data for marketing, analytics, and outreach purposes.

Using Shopee Email Scraper, you can automate the extraction of essential contact details from Shopee's platform. This tool is ideal for anyone looking to save time and effort in collecting accurate and reliable data.

Shopee is a leading e-commerce platform, and accessing its vast database of sellers and customers can be invaluable. Our scraper ensures that you can retrieve this information efficiently and ethically.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Seller emails | Retrieve email addresses of Shopee sellers for outreach and marketing. |
| Seller names | Extract the names of Shopee sellers for identification and personalization. |
| Shop URLs | Collect URLs of seller shops for further exploration or analysis. |
| Contact numbers | Access phone numbers of sellers where available for direct communication. |
| Shop ratings | Gather ratings and reviews of sellers for quality assessment. |
| Product categories | Identify the categories of products sold by Shopee sellers. |
| Location details | Extract location information of sellers to target specific regions. |
| Social media links | Retrieve social media profiles linked to seller accounts for broader engagement. |

### Key Features of **Shopee** Email Scraper

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

- ⭐ **Automated** extraction of **Shopee** seller emails and contact details
- ⭐ User-friendly interface with customizable scraping options
- ⭐ **Accurate** and up-to-date data collection from **Shopee**s platform
- ⭐ Supports bulk data extraction for large-scale operations
- ⭐ Structured output format for easy integration with other tools
- ⭐ **High**-speed scraping to save time and resources
- ⭐ Compliance with legal and ethical data collection guidelines
- ⭐ Real-time updates to ensure data relevancy
- ⭐ **Secure** handling of extracted data to protect privacy
- ⭐ **Customizable** filters to target specific sellers or product categories
- ⭐ Detailed logs and reports for tracking scraping activities
- ⭐ Responsive customer support for troubleshooting and assistance

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

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

1. ✅ **Sign up** for an account on our platform and **log in**
2. ✅ Navigate to the **Shopee** Email Scraper tool in the dashboard
3. ✅ Enter your target keywords or specify the product categories you want to scrape
4. ✅ Set your filters such as location or seller ratings for more precise results
5. ✅ **Configure** the output format and destination for the extracted data
6. ✅ Click the **Start** Scraping button to begin the data extraction process
7. ✅ Monitor the scraping progress in real-time through the dashboard
8. ✅ Download the extracted data once the process is complete
9. ✅ **Review** the data for accuracy and integrate it into your workflows
10. ✅ Adjust your scraping parameters as needed for future extractions
11. ✅ Contact customer support if you encounter any issues during the process
12. ✅ Regularly check for updates to ensure optimal scraper performance

### Use Cases 🎯

Marketing Campaigns
🎯 Extract seller emails to create targeted email marketing campaigns
🎯 **Use** contact information to promote your products or services to **Shopee** sellers

Competitor Analysis
🎯 **Analyze** seller profiles and shop ratings to understand competitor performance
🎯 **Identify** top-performing sellers in specific categories for benchmarking

Customer Relationship Management
🎯 Build a database of **Shopee** sellers for long-term relationship management
🎯 **Use** extracted data to personalize communication and improve engagement

Market Research
🎯 Gather data on product categories and seller locations for market analysis
🎯 **Identify** trends and opportunities within **Shopee**s ecosystem

Lead Generation
🎯 Generate leads by extracting contact information of potential partners or clients
🎯 Expand your business network by connecting with **Shopee** sellers

### Why choose us? 💎

**Shopee** Email Scraper is designed to provide a seamless and efficient data extraction experience. Our tool is built with **advanced** algorithms to ensure accuracy and reliability in the data collected.

We prioritize user satisfaction by offering a **user-friendly** interface and customizable options to meet diverse needs. Whether you are a small business owner or part of a large enterprise, our scraper can adapt to your specific requirements.

By using our **Shopee** email scraping software, you can save time and resources while gaining valuable insights. We also emphasize data security and compliance with legal guidelines to protect your interests.

Our customer support team is always ready to assist you with any issues or queries. Choose **Shopee** Email Scraper for a **reliable**, efficient, and ethical data extraction solution.

### **Shopee** Email Scraper Scalability 📈

**Shopee** Email Scraper is designed to handle data extraction tasks of any scale. Whether you need to extract information from a few seller profiles or thousands, our tool can accommodate your needs.

The scraper is optimized for high-speed performance, ensuring that **large-scale** operations are completed **efficient**ly. We offer **customizable** options to help you target specific data points or categories, making it suitable for both small and large businesses.

Our platform is built to scale with your growing needs, allowing you to expand your data collection efforts without limitations. By using our **Shopee** email automation tool, you can streamline your operations and focus on leveraging the extracted data.

Scalability is a core feature of our scraper, ensuring that it grows with your business demands.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** that you comply with **Shopee**s terms of service when using the scraper
⚖️ **Do not** use the extracted data for spamming or unethical marketing practices
⚖️ **Obtain** proper consent before contacting individuals using the scraped data
⚖️ **Avoid** scraping sensitive or personal information that is not publicly available
⚖️ **Use** the tool only for legitimate business or research purposes
⚖️ Regularly review and adhere to local data privacy laws and regulations
⚖️ **Do not** share or sell the extracted data to unauthorized third parties
⚖️ **Ensure** transparency and ethical practices in all data collection activities

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Shopee **Email Scraper**?

Shopee Email Scraper is a tool designed to extract email addresses and contact information from Shopee.

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

**Yes**, it is legal if used in **compliance** with Shopee's terms of service and local data privacy laws.

#### What data can I **extract** using this tool?

You can extract seller **emails**, names, shop URLs, contact numbers, ratings, product categories, and more.

#### How accurate is the **extract**ed data?

The tool is designed to provide accurate and up-to-date data from Shopee's platform.

#### Can I use this tool for bulk data **extract**ion?

**Yes**, Shopee Email Scraper supports bulk data extraction for large-scale operations.

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

**Yes**, we prioritize data security and ensure that all extracted data is handled **secure**ly.

#### Can I customize the scraping parameters?

**Yes**, you can customize filters such as location, ratings, and product categories.

#### Does this tool comply with data privacy laws?

**Yes**, it is designed to comply with legal and ethical data collection guidelines.

#### What output formats are supported?

The tool supports various formats, including **CSV**, Excel, and **JSON**.

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

**Yes**, our responsive customer support team is available to assist you.

#### Can I scrape data from **specific** regions?

**Yes**, you can filter data by location to target specific regions.

#### How often is the tool updated?

The tool is regularly updated to ensure optimal performance and data accuracy.

#### What are the system requirements for using this tool?

Shopee Email Scraper is a cloud-based tool and does not require additional system installations.

#### Can I use this tool for competitor analysis?

**Yes**, you can analyze seller profiles and shop ratings for competitor insights.

#### Is there a free trial available?

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

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopee Email Scraper",
        "description": "📩 Shopee Email Scraper extracts seller contact emails from Shopee pages with smart, automated scraping. 🚀 Perfect for lead generation, B2B outreach, and market research—save time and boost your workflow with accurate results.",
        "version": "0.1",
        "x-build-id": "eidvy8g2YkwbeeESl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~shopee-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-shopee-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/scraperx~shopee-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-shopee-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/scraperx~shopee-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-shopee-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 Shopee (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Shopee profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Shopee"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Shopee"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```