# Douyin Email Scraper (`scraper-engine/douyin-email-scraper`) Actor

Douyin Email Scraper extracts publicly available email addresses from Douyin profiles and linked pages. Build targeted contact lists for creator partnerships, brand collaborations, and direct outreach at scale.

- **URL**: https://apify.com/scraper-engine/douyin-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Social media, Other
- **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

### **Douyin** Email Scraper 📱

**Douyin** Email Scraper allows you to **extract** a wide range of **data** from **Douyin** profiles efficiently. It focuses on gathering email addresses, but it can also collect additional public information to enhance your **contact** **data**base.

This tool is designed to provide accurate and up-to-date **data**, ensuring that you have reliable information for your campaigns. Whether you're building a marketing list or conducting research, the scraper can handle your needs effectively.

The **extract**ed **data** is organized and ready to use, saving you time and effort. By automating the process, this **Douyin** email harvesting tool eliminates the need for manual **data** collection.

It is ideal for businesses, marketers, and researchers who want to access **Douyin** user **emails** quickly and securely.

Douyin Email Scraper is a powerful tool designed to help you extract email addresses from Douyin profiles efficiently. With this scraper, you can gather valuable contact information for marketing, outreach, or research purposes.

Douyin is one of the fastest-growing social media platforms, making it a goldmine for businesses and marketers. By using the Douyin Email Scraper, you can streamline your efforts and build a targeted email database quickly.

Scraping emails from Douyin can save you hours of manual work while ensuring accuracy and reliability. This automated Douyin email extraction tool is built to handle large-scale data collection with ease.

### 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 Address | Extract email addresses associated with Douyin user profiles. |
| Username | Retrieve the usernames of Douyin accounts for better identification. |
| Profile Name | Collect the display names of users to match emails with profiles. |
| Follower Count | Get the number of followers for each Douyin user. |
| Profile Bio | Scrape the bio information provided by Douyin users. |
| Profile URL | Extract the direct URL to the Douyin profile for easy access. |
| Location | Retrieve location details if publicly available on the profile. |
| Profile Picture URL | Collect the URL of the profile picture for additional context. |

### Key Features of **Douyin** Email Scraper

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

- ⭐ **Automated** email extraction from **Douyin** profiles for efficiency
- ⭐ Supports large-scale data scraping with high accuracy
- ⭐ User-friendly interface suitable for both beginners and experts
- ⭐ Ability to extract additional profile details like username and bio
- ⭐ **Customizable** scraping options to target specific data fields
- ⭐ **Fast** and reliable data processing for quick results
- ⭐ **Secure** and compliant with data privacy standards
- ⭐ Export data in various formats such as CSV or JSON
- ⭐ **Regular** updates to ensure compatibility with **Douyin**s platform
- ⭐ **Advanced** filtering options to refine your data collection
- ⭐ 247 customer support for troubleshooting and assistance
- ⭐ Scalable solution for businesses of all sizes

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

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

1. ✅ **Sign up** for an account on the platform hosting the **Douyin** Email Scraper
2. ✅ Log in to the dashboard and locate the **Douyin** Email Scraper tool
3. ✅ **Input** your search criteria such as keywords or profile URLs
4. ✅ Customize the data fields you want to extract like emails or usernames
5. ✅ Set any additional filters to narrow down your scraping results
6. ✅ Click on the start button to initiate the scraping process
7. ✅ Monitor the progress of the scraper through the dashboard
8. ✅ Once completed review the extracted data for accuracy
9. ✅ **Export** the data in your preferred format such as CSV or JSON
10. ✅ Use the data for your marketing research or outreach campaigns
11. ✅ Adjust your scraping settings for future extractions as needed
12. ✅ Contact support if you encounter any issues during the process

### Use Cases 🎯

Marketing Campaigns
🎯 Build a targeted email list for **Douyin**-focused marketing campaigns
🎯 Reach out to influencers and creators for collaborations

Business Development
🎯 **Identify** potential partners or clients on **Douyin**
🎯 Expand your network by connecting with **Douyin** users

Market Research
🎯 **Analyze** **Douyin** user demographics and trends
🎯 Gather data to understand user behavior and preferences

Content Promotion
🎯 Promote your products or services to **Douyin** users via email
🎯 Leverage **Douyin** user data to boost your content outreach

### Why choose us? 💎

Our **Douyin** Email Scraper is designed to provide a seamless and efficient data extraction experience. With its **advanced** features, you can gather accurate and **reliable** email addresses from **Douyin** profiles effortlessly.

This tool is ideal for businesses, marketers, and researchers looking to save time and resources. We prioritize user satisfaction by offering a **user-friendly** interface and customizable options.

Our scraper is built to handle large-scale data collection, making it suitable for projects of any size. Additionally, we ensure compliance with data privacy regulations to protect your interests.

Regular updates and 24/7 customer support ensure that you have a smooth scraping experience. Choose our **Douyin** email extraction tool for its reliability, scalability, and ease of use.

### **Douyin** Email Scraper Scalability 📈

**Douyin** Email Scraper is built to handle projects of all sizes, from small-scale extractions to enterprise-level operations. Its robust infrastructure ensures that you can scrape large volumes of data without compromising on speed or accuracy.

Whether you're targeting a few profiles or thousands, the scraper adapts to your needs **seamless**ly. With **customizable** options and **advanced** filtering, you can refine your data collection process for optimal results.

Our tool is designed to grow with your business, providing a scalable solution for evolving requirements. By automating the data extraction process, you can focus on analyzing and utilizing the information effectively.

Experience unmatched scalability with our **Douyin** email harvesting tool.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Douyin**s terms of service before using the scraper
⚖️ **Only** collect publicly available information from **Douyin** profiles
⚖️ **Do not** use the scraper for spamming or unsolicited marketing purposes
⚖️ Respect user privacy and avoid extracting sensitive or private data
⚖️ **Use** the extracted data responsibly and ethically for legitimate purposes
⚖️ Stay updated on data privacy laws and regulations in your region
⚖️ **Obtain** user consent if required for your specific use case
⚖️ **Avoid** overloading **Douyin**s servers to prevent disruptions

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Douyin **Email Scraper**?

Douyin Email Scraper is a tool designed to extract email addresses and other public data from Douyin profiles efficiently.

#### Is it **legal** to scrape emails from Douyin?

**Yes**, as long as you comply with Douyin's terms of service and only collect **publicly available** information.

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

You can extract email addresses, usernames, profile names, follower counts, bios, profile URLs, and more.

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

The scraper is designed to provide accurate and up-to-date data, but accuracy depends on the availability of public information.

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

**Yes**, the Douyin Email Scraper is built to handle large-scale data extraction efficiently.

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

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

#### Is the scraper easy to use?

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

#### Do you provide **customer support**?

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

#### How often is the tool updated?

The scraper is regularly updated to ensure compatibility with Douyin's platform.

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

**Yes**, you can customize the scraping settings to target specific data fields and profiles.

#### Is my data **secure** when using this tool?

**Yes**, we prioritize data security and ensure **compliance** with privacy standards.

#### Can I scrape **private** profiles with this tool?

**No**, the tool only extracts **publicly available** information from Douyin profiles.

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

The scraper is cloud-based and does not require specific system requirements.

#### Do I need technical skills to use this tool?

**No**, the tool is designed to be **user-friendly** and does not require advanced technical knowledge.

#### Can I try the scraper before purchasing?

**Yes**, we offer a free trial so you can test the tool before committing to a subscription.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Douyin Email Scraper",
        "description": "Douyin Email Scraper extracts publicly available email addresses from Douyin profiles and linked pages. Build targeted contact lists for creator partnerships, brand collaborations, and direct outreach at scale.",
        "version": "0.1",
        "x-build-id": "ouNOfZaOT6RrHFaJ7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~douyin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-douyin-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/scraper-engine~douyin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-douyin-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/scraper-engine~douyin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-douyin-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 Douyin (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Douyin profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Douyin"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Douyin"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```