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

Automate email extraction from Shopee with Shopee Email Scraper. The actor scans product and seller pages and pulls available contact emails into structured datasets for CRM enrichment and lead automation.

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

## Pricing

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

### **Shopee** Email Scraper 📱

**Shopee** Email Scraper allows users to **extract** a wide range of **data** from **Shopee**'s platform efficiently. This includes email addresses, seller names, product details, and more, making it a versatile tool for various applications.

The scraper is designed to capture accurate and up-to-date information, ensuring that users have access to the most relevant **data**. It can be customized to target specific categories, sellers, or products, depending on your requirements.

By automating the **data** **extract**ion process, **Shopee** Email Scraper saves users significant time and effort. Whether you're looking for seller **contact** details or product insights, this tool provides a comprehensive solution for all your **data** scraping needs.

Shopee Email Scraper is a powerful tool designed to help users extract email addresses and other essential data from Shopee. It simplifies the process of gathering contact information, making it an essential resource for businesses and researchers.

Shopee is one of the leading e-commerce platforms in Southeast Asia, hosting millions of sellers and buyers. Extracting data from Shopee can provide valuable insights and contact details for marketing and analysis purposes.

With Shopee Email Scraper, you can automate the process of collecting seller or customer emails from Shopee. This tool ensures accuracy and efficiency, saving you time and effort compared to manual data collection.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract verified email addresses of Shopee sellers or customers. |
| Seller Names | Retrieve the names of sellers associated with specific products or categories. |
| Product Details | Gather information about product titles, descriptions, and pricing. |
| Shop Names | Collect the names of shops or stores listed on Shopee. |
| Ratings and Reviews | Extract customer ratings and reviews for specific products or sellers. |
| Contact Numbers | Retrieve contact numbers provided by sellers on Shopee. |
| Category Information | Extract data related to specific product categories on Shopee. |
| Seller Locations | Gather location details of sellers for targeted outreach. |

### 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 email addresses and other essential data from **Shopee**
- ⭐ **Customizable** scraping options to target specific sellers products or categories
- ⭐ User-friendly interface that simplifies the data extraction process
- ⭐ **Accurate** and up-to-date data collection for reliable results
- ⭐ Supports large-scale data scraping for extensive research or marketing campaigns
- ⭐ Compliance with legal and ethical guidelines for data scraping
- ⭐ **Fast** and efficient performance saving time and resources
- ⭐ **Secure** handling of extracted data to ensure user privacy and protection
- ⭐ Detailed logs and reports for tracking scraping activities
- ⭐ **Integration** options with third-party tools or software for enhanced functionality
- ⭐ **Regular** updates to maintain compatibility with **Shopee**s platform
- ⭐ 247 customer support to assist with any issues or queries

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

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

1. ✅ **Sign up** for the **Shopee** Email Scraper service and **log in** to your account
2. ✅ Download and install the scraper tool on your device
3. ✅ Open the tool and configure your scraping preferences such as target categories or sellers
4. ✅ Enter the specific keywords or URLs you wish to scrape data from on **Shopee**
5. ✅ Set the parameters for data extraction such as email addresses or product details
6. ✅ **Start** the scraping process and monitor the progress through the tools interface
7. ✅ Once the scraping is complete review the extracted data for accuracy
8. ✅ **Export** the data in your preferred format such as CSV or Excel
9. ✅ Use the extracted data for your marketing research or analysis purposes
10. ✅ Regularly update the tool to ensure compatibility with **Shopee**s platform
11. ✅ Contact customer support if you encounter any issues during the scraping process
12. ✅ Follow legal guidelines to ensure ethical use of the extracted data

### Use Cases 🎯

Marketing Campaigns
🎯 **Collect** seller email addresses for targeted email marketing campaigns
🎯 **Identify** potential partners or collaborators on **Shopee**

Market Research
🎯 **Analyze** product trends and customer preferences using extracted data
🎯 Gather insights on seller performance and customer feedback

Business Development
🎯 Expand your network by reaching out to **Shopee** sellers
🎯 **Identify** new opportunities for partnerships or collaborations

Competitive Analysis
🎯 Monitor competitor products and pricing strategies on **Shopee**
🎯 **Analyze** customer reviews and ratings for market positioning

Data Enrichment
🎯 Enhance your existing databases with updated **Shopee** seller information
🎯 Add valuable details like email addresses and contact numbers

### 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 accurate and up-to-date data collection from **Shopee**.

We prioritize user convenience by offering a **user-friendly** interface and customizable options to meet diverse needs. Whether you're a marketer, researcher, or developer, our scraper is tailored to deliver high-quality results.

We adhere to strict legal and ethical guidelines, ensuring compliance with data privacy regulations. Our team provides **regular** updates to maintain compatibility with **Shopee**'s platform and improve functionality.

With 24/7 customer support, we ensure that you have assistance whenever you need it. Choose **Shopee** Email Scraper for a **reliable** and efficient solution to your data extraction needs.

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

**Shopee** Email Scraper is designed to handle data extraction tasks of any scale. Whether you need to scrape a few dozen records or millions of entries, our tool can accommodate your requirements.

It supports **large-scale** data scraping for **extensive** research or marketing campaigns. The scraper's **advanced** algorithms ensure fast and **efficient** performance, even when processing large datasets.

Our tool is optimized for scalability, making it suitable for businesses of all sizes. By automating the data collection process, **Shopee** Email Scraper saves time and resources, allowing you to focus on analysis and decision-making.

With regular updates and robust infrastructure, our scraper is equipped to handle the growing demands of data extraction.

### **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** compliance with **Shopee**s terms of service when using the scraper
⚖️ **Do not** use the extracted data for spamming or unethical activities
⚖️ **Obtain** consent from individuals before using their contact information for marketing purposes
⚖️ **Avoid** scraping sensitive or personal data that violates privacy laws
⚖️ **Use** the tool responsibly and adhere to local data protection regulations
⚖️ Regularly review **Shopee**s policies to stay updated on any changes affecting data scraping
⚖️ **Do not** share or sell extracted data to unauthorized third parties
⚖️ **Ensure** that your use of the scraper aligns with ethical and legal standards

### 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 other data from Shopee efficiently.

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

**Yes**, as long as you comply with Shopee's terms of service and relevant data protection laws.

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

**Yes**, the scraper allows you to target specific sellers, products, or categories on Shopee.

#### What data formats are supported for **export**?

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

#### Does Shopee **Email Scraper** support **large-scale** data scraping?

**Yes**, the tool is designed to handle data extraction tasks of any scale efficiently.

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

**Yes**, Shopee Email Scraper uses advanced algorithms to ensure accurate and up-to-date data collection.

#### Can I use the scraper for market research?

**Yes**, the tool is ideal for analyzing product trends, customer preferences, and seller performance.

#### How often is the tool updated?

Shopee Email Scraper is regularly updated to maintain compatibility with Shopee's platform.

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

**Yes**, we offer 24/7 customer support to assist with any issues or queries.

#### Can I integrate the scraper with other tools?

**Yes**, Shopee Email Scraper supports integration with third-party tools or software.

#### Does the tool comply with data privacy regulations?

**Yes**, we adhere to strict legal and ethical guidelines to ensure **compliance** with data privacy laws.

#### What are the system requirements for the scraper?

The tool is compatible with most modern operating systems and requires an active internet connection.

#### Can I scrape contact numbers using this tool?

**Yes**, Shopee Email Scraper can extract contact numbers provided by sellers on Shopee.

#### Is there a trial version available?

Please contact our support team for information on trial versions or demo access.

#### How do I ensure ethical use of the **extract**ed data?

Follow legal guidelines, obtain consent for marketing purposes, and avoid sharing data with unauthorized parties.

# 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("api-empire/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("api-empire/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 api-empire/shopee-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopee Email Scraper",
        "description": "Automate email extraction from Shopee with Shopee Email Scraper. The actor scans product and seller pages and pulls available contact emails into structured datasets for CRM enrichment and lead automation.",
        "version": "0.1",
        "x-build-id": "s38HmR6fMGENFfuR1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~shopee-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-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/api-empire~shopee-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-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/api-empire~shopee-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```