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

Automate email extraction from Douyin with Douyin Email Scraper. The actor scans profiles and external links to pull available contact emails into structured datasets for CRM enrichment.

- **URL**: https://apify.com/api-empire/douyin-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, Social media
- **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 📱

The **Douyin** Email Scraper allows users to **extract** a variety of **data** from **Douyin** profiles with ease. This includes email addresses, usernames, follower counts, and more, providing a comprehensive **data**set for analysis and outreach.

By using this **Douyin** **contact** scraper, you can gather essential information to enhance your marketing strategies or build valuable connections. The tool is designed to ensure accurate and efficient **data** **extract**ion, saving you time and effort.

Whether you're a marketer, researcher, or business owner, this email scraping tool for **Douyin** delivers the **data** you need in a structured and organized format. With its advanced features, the **Douyin** email finder simplifies the process of collecting user **data** while adhering to ethical guidelines.

This makes it a reliable and effective solution for scraping **Douyin** user **data** at scale.

Douyin Email Scraper is a powerful tool designed to extract email addresses and related contact information from Douyin profiles efficiently. This tool is perfect for businesses and marketers looking to connect with influencers or potential customers on Douyin.

Douyin, known as the Chinese version of TikTok, is a popular platform for short videos and creative content. With millions of users, it offers a wealth of opportunities for data extraction and targeted outreach.

Using a Douyin email extraction software allows you to automate the process of gathering valuable contact data. This saves time and ensures you have accurate and up-to-date information for your campaigns.

### 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 | Extracts email addresses linked to Douyin profiles for outreach purposes. |
| Usernames | Captures the usernames of Douyin profiles for identification and follow-up. |
| Follower counts | Retrieves the number of followers for each profile to assess influence. |
| Profile URLs | Collects direct links to Douyin profiles for easy access. |
| Bio descriptions | Extracts the bio information from profiles for additional context. |
| Associated links | Gathers links shared in profiles, such as websites or social media. |
| Profile images | Downloads profile pictures for visual identification. |
| Engagement metrics | Collects data on likes and comments for content analysis. |

### 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 scraping from **Douyin** profiles for efficiency
- ⭐ User-friendly interface for seamless operation and navigation
- ⭐ Ability to extract multiple data types including emails usernames and follower counts
- ⭐ **High** accuracy in data collection to ensure reliable results
- ⭐ Scalable scraping capabilities to handle large datasets effectively
- ⭐ **Customizable** filters to target specific profiles based on your criteria
- ⭐ **Fast** data processing to save time and resources
- ⭐ **Secure** data handling to protect user privacy and comply with ethical standards
- ⭐ **Regular** updates to ensure compatibility with **Douyin**s platform changes
- ⭐ Detailed export options for structured and organized datasets

### 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 **Douyin** Email Scraper platform
2. ✅ Download and install the **Douyin** email extraction software on your device
3. ✅ Log in to the tool using your credentials
4. ✅ Enter the keywords or profile URLs you want to scrape data from
5. ✅ Set your data extraction preferences such as filters for specific criteria
6. ✅ **Start** the scraping process and monitor the progress in real-time
7. ✅ Once completed review the extracted data for accuracy
8. ✅ **Export** the data in your preferred format such as CSV or Excel
9. ✅ Use the collected data for your marketing research or outreach campaigns
10. ✅ Repeat the process as needed to gather additional data

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted email lists for **Douyin**-based campaigns
🎯 **Identify** and connect with influencers for brand collaborations
🎯 Expand your customer base by reaching out to potential clients

Market Research
🎯 **Analyze** user demographics and engagement metrics on **Douyin**
🎯 Gather insights into competitor profiles and their followers
🎯 **Identify** trends and patterns in **Douyin** user behavior

Networking and Collaboration
🎯 **Find** professionals and creators in your industry on **Douyin**
🎯 Establish partnerships with relevant individuals or businesses
🎯 Expand your professional network with verified contacts

Content Strategy Development
🎯 Discover popular content types and topics on **Douyin**
🎯 **Analyze** user feedback and comments for content improvement
🎯 **Identify** high-performing profiles for inspiration and benchmarking

### Why choose us? 💎

Our **Douyin** Email Scraper stands out as the **best** **Douyin** scraper tool for several reasons. It combines **advanced** features with a **user-friendly** interface, making it accessible to both beginners and professionals.

The tool is designed to provide accurate and **reliable** data, ensuring you get the most value from your scraping efforts. We prioritize data security and adhere to strict ethical guidelines, so you can trust that your data collection is compliant and safe.

With customizable filters and **scalable** capabilities, our **Douyin** data scraper can handle projects of any size. Whether you're a marketer, researcher, or business owner, this email scraping tool for **Douyin** is tailored to meet your specific needs.

We also offer dedicated customer support to assist you at every step of the process. By choosing our automated **Douyin** email scraper, you gain access to a powerful and efficient solution for extracting emails from **Douyin**.

Trust us to deliver the tools you need to succeed in your data-driven campaigns.

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

The **Douyin** Email Scraper is built to handle projects of all sizes, making it a versatile tool for businesses and individuals alike. Whether you need to scrape a few profiles or thousands, the tool adapts to your requirements without compromising on speed or accuracy.

Our **Douyin** email extraction software is optimized for performance, ensuring that **large-scale** data scraping is completed **efficient**ly. With its robust infrastructure, the tool can process vast amounts of data while maintaining reliability.

This makes it ideal for enterprises looking to scale their data collection efforts on **Douyin**. The best **Douyin** scraper tool also offers flexible options for exporting and managing large datasets.

No matter the scope of your project, our **Douyin** contact scraper delivers consistent and high-quality results. Trust our solution to grow with your needs, providing a scalable and **efficient** way to extract emails from **Douyin**.

### **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
⚖️ Always obtain consent before using scraped data for marketing or outreach purposes
⚖️ **Ensure** compliance with **Douyin**s terms of service when using the scraper
⚖️ **Avoid** scraping private or sensitive information from **Douyin** profiles
⚖️ **Use** the **Douyin** Email Scraper only for ethical and lawful purposes
⚖️ **Do not** resell or distribute scraped data without proper authorization
⚖️ **Adhere** to data protection laws such as GDPR or CCPA when handling user information
⚖️ Respect the privacy of **Douyin** users and avoid intrusive data collection practices
⚖️ Regularly review and update your scraping practices to align with legal requirements

### 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 the Douyin **Email Scraper**?

The Douyin Email Scraper is a tool designed to extract email addresses and related data from Douyin profiles.

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

**Yes**, the tool features a **user-friendly** interface that simplifies the data scraping process.

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

You can extract **emails**, usernames, follower counts, profile URLs, bio descriptions, and more.

#### Is the Douyin **Email Scraper** scalable?

**Yes**, the tool is designed to handle projects of all sizes, from small-scale scraping to large datasets.

#### Is the tool compliant with Douyin's policies?

The scraper is designed to operate within Douyin's terms of service and ethical guidelines.

#### Can I **export** the scraped data?

**Yes**, the tool allows you to export data in formats such as **CSV** or Excel for easy analysis.

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

**No**, the Douyin Email Scraper is designed to be accessible to users without technical expertise.

#### Is the data collected accurate?

**Yes**, the tool is built to ensure high accuracy in data extraction.

#### Can I customize the scraping process?

**Yes**, you can apply filters and preferences to target specific profiles or data types.

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

**Yes**, we offer dedicated customer support to assist you with any issues or questions.

#### How often is the tool updated?

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

#### Is the Douyin **Email Scraper** **secure**?

**Yes**, we prioritize data security and adhere to strict privacy standards.

#### Can I scrape **private** profiles?

**No**, the tool is designed to scrape **publicly available** data only.

#### What are the **legal** considerations for using this tool?

You must comply with data protection laws and obtain consent before using scraped data for outreach.

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

**Yes**, the Douyin Email Scraper is ideal for gathering data for market research and analysis.

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

```

## MCP server setup

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

```

## OpenAPI specification

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