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

📧 Taobao Email Scraper extracts seller emails from Taobao listings fast and efficiently. Perfect for B2B prospecting, sales outreach, and lead generation. 🔍 Save time, improve targeting, and scale campaigns with ease. 🚀

- **URL**: https://apify.com/scraperx/taobao-email-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Automation, Lead generation, Social media
- **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

### **Taobao** Email Scraper 📱

The **Taobao** Email Scraper allows users to **extract** a range of valuable **data** from **Taobao** sellers. It focuses primarily on collecting email addresses, ensuring that users gain access to accurate and verified **contact** information.

In addition to **emails**, the scraper can gather supplementary details about sellers to provide a comprehensive **data**set. This tool is designed to streamline the process of **data** collection, saving users time and effort.

By automating the **extract**ion process, it eliminates the need for manual intervention and ensures consistent results. The **extract**ed **data** can be used for various purposes, such as marketing campaigns, customer outreach, or business analysis.

The **Taobao** Email Scraper is built to handle large-scale **data** requests, making it suitable for businesses of all sizes. It provides structured outputs that are easy to integrate into existing workflows or **data**bases.

Taobao Email Scraper is a powerful tool designed to help users extract valuable email data from Taobao efficiently and accurately. It simplifies the process of gathering contact information from sellers on this vast e-commerce platform.

With the Taobao Email Scraper, businesses and individuals can streamline their communication efforts by accessing verified seller emails directly from Taobao. This tool is ideal for those looking to enhance their marketing strategies or build partnerships.

Scraping Taobao seller emails can be a time-consuming task, but our automated solution ensures a seamless and reliable experience. It eliminates manual efforts and provides structured data in a user-friendly format.

### 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 |
| --- | --- |
| Email Addresses | Extract verified email addresses of Taobao sellers for communication purposes. |
| Seller Names | Retrieve the names of sellers associated with the extracted email addresses. |
| Store Names | Collect the names of the stores operated by the sellers on Taobao. |
| Product Categories | Identify the product categories associated with the sellers. |
| Contact Details | Gather additional contact details such as phone numbers if available. |
| Store URLs | Extract the URLs of the sellers' stores for further exploration. |
| Ratings and Reviews | Retrieve seller ratings and reviews to assess credibility. |
| Location Information | Collect location details of the sellers for targeted outreach. |

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

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

- ⭐ **Automated** extraction of verified email addresses from **Taobao** sellers
- ⭐ User-friendly interface for seamless operation and data retrieval
- ⭐ Ability to extract additional seller details such as store names and contact information
- ⭐ Supports large-scale data extraction for businesses of all sizes
- ⭐ Provides structured data outputs for easy integration into workflows
- ⭐ **Advanced** filtering options to target specific product categories or sellers
- ⭐ **High** accuracy and reliability in extracting data from **Taobao**
- ⭐ **Regular** updates to ensure compatibility with **Taobao**s platform changes
- ⭐ **Customizable** scraping settings to meet unique user requirements
- ⭐ **Secure** and ethical data extraction practices to comply with legal guidelines
- ⭐ **Fast** processing speeds to save time and enhance productivity
- ⭐ **Comprehensive** support and documentation for easy setup and use

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

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

1. ✅ **Sign up** for an account and **log in** to access the **Taobao** Email Scraper
2. ✅ Enter the specific search criteria or product categories you want to target
3. ✅ **Configure** the scraping settings to match your data extraction needs
4. ✅ **Start** the scraper and monitor the progress through the dashboard
5. ✅ Wait for the scraper to complete the extraction process and collect the data
6. ✅ Download the extracted data in your preferred format such as CSV or JSON
7. ✅ **Review** the data to ensure accuracy and completeness before use
8. ✅ **Integrate** the extracted data into your marketing or business workflows
9. ✅ Use the filtering options to refine the data for specific campaigns
10. ✅ Schedule regular scraping tasks to keep your data up to date
11. ✅ Refer to the documentation or contact support for troubleshooting
12. ✅ Ensure compliance with legal and ethical guidelines when using the data

### Use Cases 🎯

Marketing Campaigns
🎯 **Collect** seller emails for targeted email marketing campaigns
🎯 Promote your products or services to relevant **Taobao** sellers

Business Partnerships
🎯 **Identify** potential business partners by extracting contact details
🎯 Reach out to sellers for collaboration opportunities

Market Research
🎯 **Analyze** seller data to understand market trends and competition
🎯 Gather insights into popular product categories and seller performance

Customer Outreach
🎯 Communicate directly with sellers for inquiries or feedback
🎯 Build relationships with sellers to enhance customer engagement

Data Analysis
🎯 **Use** extracted data for comprehensive business analysis
🎯 Integrate the data into analytics tools for deeper insights

### Why choose us? 💎

Our **Taobao** Email Scraper stands out as a **reliable** and efficient tool for extracting data from **Taobao**. It is designed to cater to the diverse needs of businesses, marketers, and researchers.

With **advanced** automation and filtering options, it ensures that you get the most relevant and accurate data. The tool is built to handle large-scale data extraction tasks, making it suitable for enterprises and small businesses alike.

We prioritize user experience by offering a simple and intuitive interface that requires minimal technical expertise. Regular updates ensure that the scraper remains compatible with **Taobao**'s platform changes.

Our commitment to ethical data extraction practices ensures compliance with legal guidelines. By choosing our **Taobao** Email Scraper, you gain access to a powerful tool that saves time, enhances productivity, and delivers **reliable** results.

Whether you are looking to extract emails from **Taobao** for marketing, research, or analysis, our tool provides the perfect solution. Trust us to help you unlock the potential of **Taobao** data with ease and efficiency.

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

The **Taobao** Email Scraper is designed to scale with your business needs, whether you are a small startup or a large enterprise. It can handle high volumes of data requests without compromising on speed or accuracy.

Our tool is built with robust infrastructure to ensure **seamless** performance even during peak usage. It offers **customizable** settings that allow you to tailor the scraping process to your specific requirements.

The scraper supports batch processing, enabling you to extract data from multiple categories or sellers simultaneously. This scalability makes it an ideal solution for businesses looking to expand their data collection efforts.

Whether you need to scrape a few hundred emails or thousands, our tool can adapt to your needs. With its flexible and **efficient** design, the **Taobao** Email Scraper ensures that your data extraction process remains smooth and reliable as your business grows.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Taobao**s terms of service when using the scraper
⚖️ **Use** the extracted data only for legitimate and ethical purposes
⚖️ **Avoid** scraping personal information that is not publicly available
⚖️ Respect the privacy of **Taobao** sellers and their contact details
⚖️ **Do not** use the scraper for spamming or unauthorized marketing activities
⚖️ **Adhere** to local data protection laws and regulations when using the tool
⚖️ Regularly review the legal guidelines to stay updated on compliance requirements
⚖️ Seek legal advice if you are unsure about the permissible use of the extracted data

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Taobao Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Taobao",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Taobao) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Taobao",
    "keyword": "Taobao Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Taobao as the source |
| keyword | Keyword that triggered the result (Taobao Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Taobao profile link |
| email | Extracted email address |

### FAQ ❓

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

The Taobao Email Scraper is a tool designed to extract email addresses and other data from Taobao sellers efficiently.

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

**Yes**, the scraper features a **user-friendly** interface that simplifies the data extraction process for all users.

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

You can extract email addresses, seller names, store names, product categories, and more.

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

**Yes**, the Taobao Email Scraper is designed to provide accurate and verified data.

#### Can I use this tool for **large-scale** data **extract**ion?

**Yes**, the scraper is built to handle large-scale data requests efficiently.

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

**Yes**, as long as you comply with Taobao's terms of service and relevant legal guidelines.

#### Does the scraper support batch processing?

**Yes**, the tool allows you to process multiple categories or sellers simultaneously.

#### What formats are available for downloading the data?

You can download the data in formats such as **CSV** or **JSON** for easy integration.

#### Can I customize the scraping settings?

**Yes**, the scraper offers customizable settings to meet your specific requirements.

#### Is technical expertise required to use this tool?

**No**, the scraper is designed for users with minimal technical knowledge.

#### How often is the tool updated?

The Taobao Email Scraper is regularly updated to ensure compatibility with Taobao's platform changes.

#### What support options are available?

We provide comprehensive documentation and customer support to assist users.

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

**Yes**, the scraper includes advanced **filtering** options for targeted data extraction.

#### Is the tool **secure** to use?

**Yes**, the Taobao Email Scraper is built with security measures to protect user data.

#### What is the pricing for this tool?

Please visit our website for detailed pricing information and subscription plans.

# Actor input Schema

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

List of keywords to search for on Taobao (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Taobao profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Taobao",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperx/taobao-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperx/taobao-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperx/taobao-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Taobao Email Scraper",
        "description": "📧 Taobao Email Scraper extracts seller emails from Taobao listings fast and efficiently. Perfect for B2B prospecting, sales outreach, and lead generation. 🔍 Save time, improve targeting, and scale campaigns with ease. 🚀",
        "version": "0.1",
        "x-build-id": "APEFXZOQHOdVTa6Ng"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~taobao-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-taobao-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperx~taobao-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-taobao-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperx~taobao-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-taobao-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Taobao (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Taobao profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Taobao"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Taobao"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```