# Aliexpress Email Scraper (`api-empire/aliexpress-email-scraper`) Actor

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

- **URL**: https://apify.com/api-empire/aliexpress-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (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

$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

### **AliExpress** Email Scraper 📱

The **AliExpress** Email Scraper allows users to **extract** a variety of **data** types from the **AliExpress** platform. This includes customer or vendor email addresses, which are crucial for communication and marketing efforts.

Additionally, the tool can retrieve associated names, company information, and product details where available. By automating the **data** **extract**ion process, it ensures accuracy and saves time.

The scraper is designed to handle large volumes of **data**, making it suitable for scaling business operations. Users can also customize their scraping preferences to target specific categories or regions.

With its advanced capabilities, this tool is an essential resource for businesses seeking to **extract** customer **emails** from **AliExpress** efficiently.

AliExpress Email Scraper is a powerful tool designed to help users extract contact email addresses from AliExpress efficiently and accurately. It simplifies the process of gathering customer or vendor emails for various business needs.

With the AliExpress email extraction tool, you can save time and effort by automating the tedious task of email collection. This software is ideal for businesses looking to build contact lists or enhance marketing campaigns.

Scraping emails from AliExpress has never been easier, thanks to this automated AliExpress email extractor. It ensures precise data retrieval while adhering to ethical guidelines and platform policies.

### 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 | Retrieve customer or vendor email addresses from AliExpress. |
| Names | Extract associated names of customers or vendors. |
| Company details | Gather company information linked to the email addresses. |
| Product details | Retrieve product information related to the email source. |
| Location data | Extract location details of vendors or customers if available. |
| Contact numbers | Collect phone numbers associated with the email addresses. |
| Category-specific data | Target specific product categories for email scraping. |
| Custom fields | Extract additional custom data based on user preferences. |

### Key Features of **AliExpress** Email Scraper

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

- ⭐ Automates the process of extracting emails from **AliExpress** efficiently
- ⭐ Supports bulk email scraping for handling large datasets
- ⭐ **Customizable** settings to target specific categories or regions on **AliExpress**
- ⭐ Ensures accuracy and reliability through advanced data parsing algorithms
- ⭐ User-friendly interface suitable for both beginners and advanced users
- ⭐ Provides detailed reports of extracted data for easy analysis
- ⭐ Adheres to ethical guidelines and **AliExpress** platform policies
- ⭐ Supports integration with other tools or software for seamless workflows
- ⭐ Offers real-time data extraction to ensure up-to-date information
- ⭐ Compatible with various operating systems and environments
- ⭐ Includes advanced filtering options to refine data collection
- ⭐ Provides customer support for troubleshooting and assistance

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

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

1. ✅ **Sign up** for an account or **log in** to access the **AliExpress** Email Scraper
2. ✅ Download and install the scraper software on your preferred device
3. ✅ Open the tool and configure your scraping preferences such as categories or regions
4. ✅ Enter the specific keywords or URLs for targeted email extraction
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once completed review the extracted data in the provided report format
7. ✅ **Export** the data to your preferred file format such as CSV or Excel
8. ✅ Use the extracted data for marketing campaigns or customer outreach

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 Enhance customer engagement with personalized outreach

Business Networking
🎯 **Identify** and connect with potential vendors or partners
🎯 Expand your professional network using **AliExpress** email finder software

Market Research
🎯 **Analyze** customer trends and preferences through email data
🎯 Gather insights on competitor activities and strategies

Customer Support
🎯 Reach out to customers for feedback or support queries
🎯 Improve customer satisfaction with direct communication

### Why choose us? 💎

The **AliExpress** Email Scraper stands out as the **best** tool for extracting emails from **AliExpress** due to its efficiency and reliability. It automates the tedious process of email collection, saving users valuable time and resources.

With **advanced** features like real-time data extraction and customizable settings, this tool caters to diverse business needs. Whether you are a small business owner or part of a large enterprise, the scraper can handle data volumes of any scale.

Our software is designed with user-friendliness in mind, making it accessible to both beginners and experienced users. We prioritize accuracy and ensure that the extracted data is error-free and relevant.

By adhering to ethical guidelines and **AliExpress** policies, we provide a trustworthy solution for your email scraping needs. Choose us to experience seamless integration, excellent customer support, and a tool that grows with your business requirements.

### **AliExpress** Email Scraper Scalability 📈

The **AliExpress** Email Scraper is built to handle projects of any size, making it highly scalable for businesses. Whether you need to extract a few hundred emails or millions, the tool can accommodate your requirements.

Its robust infrastructure ensures smooth performance even with large datasets. Users can customize their scraping preferences to focus on specific regions, categories, or keywords, enhancing the tool's flexibility.

The scraper also supports batch processing, allowing you to run multiple tasks simultaneously. As your business grows, the **AliExpress** Email Scraper adapts to your increasing data needs without compromising on speed or accuracy.

This makes it an ideal solution for businesses looking to scale their operations **efficient**ly.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **AliExpress** terms of service while using the scraper
⚖️ **Obtain** consent from individuals before using their email data for marketing purposes
⚖️ **Avoid** using the tool for spamming or other unethical activities
⚖️ **Do not** scrape sensitive or private information from the platform
⚖️ **Use** the extracted data responsibly and in accordance with applicable laws
⚖️ Regularly review updates to **AliExpress** policies to ensure continued compliance
⚖️ Respect user privacy and avoid unauthorized data collection
⚖️ Limit scraping activities to publicly available information only

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

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

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

#### Can I scrape emails from **specific** product categories?

**Yes**, the tool allows you to customize your scraping preferences to target specific product categories.

#### Is the AliExpress **Email Scraper** user-friendly?

**Yes**, the scraper features a **user-friendly** interface suitable for both beginners and advanced users.

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

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

#### Does the tool comply with AliExpress policies?

**Yes**, the scraper is designed to adhere to AliExpress terms of service and ethical guidelines.

#### Can I use the tool for bulk email scraping?

**Yes**, the AliExpress Email Scraper supports bulk email extraction to handle large datasets.

#### Is **customer support** available for troubleshooting?

**Yes**, we provide customer support to assist with any issues or questions you may have.

#### Does the scraper work in real-time?

**Yes**, the tool offers real-time data extraction to ensure you get the most up-to-date information.

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

**Yes**, the scraper supports integration with various tools or software for **seamless** workflows.

#### Is the tool compatible with all operating systems?

**Yes**, the AliExpress Email Scraper is compatible with various operating systems and environments.

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

You can extract email addresses, names, company details, product information, and more.

#### How do I ensure ethical use of the scraper?

Follow legal guidelines, respect user privacy, and avoid scraping sensitive or unauthorized data.

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

**Yes**, you can configure the scraper to target specific regions on AliExpress.

#### Is there a **limit** to the amount of data I can scrape?

**No**, the scraper is scalable and can handle projects of any size based on your requirements.

#### What makes this the best AliExpress email scraping tool?

Its efficiency, accuracy, scalability, and adherence to ethical guidelines make it the best tool for email scraping from AliExpress.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Aliexpress Email Scraper",
        "description": "Automate email extraction from AliExpress with AliExpress Email Scraper. The actor scans product and seller pages and pulls available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "FJphxtCOYZedugfjD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~aliexpress-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-aliexpress-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~aliexpress-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-aliexpress-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~aliexpress-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-aliexpress-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 Aliexpress (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Aliexpress profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Aliexpress"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Aliexpress"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```