# TikTok Email Scraper (`scraperx/tiktok-email-scraper`) Actor

📩 TikTok Email Scraper (tiktok-email-scraper) extracts emails from TikTok profiles to help you grow leads faster. 🚀 Perfect for outreach, B2B sales, influencer marketing & recruiting—save time, boost prospecting, and stay compliant.

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

### **TikTok** Email Scraper 📱

The **TikTok** Email Scraper allows you to **extract** valuable **contact** information from **TikTok** profiles. This includes publicly available **data** that can be used for marketing, outreach, or research purposes.

You can gather verified email addresses from **TikTok** influencers and users efficiently. The tool focuses on **extract**ing only relevant and accurate information to ensure you get the most out of your scraping efforts.

By using the **TikTok** Email Scraper, you can build targeted email lists for campaigns or collaborations. It is designed to handle large-scale **data** **extract**ion while maintaining high accuracy.

This tool is perfect for businesses, marketers, and researchers looking to connect with **TikTok** users effectively.

TikTok Email Scraper is a powerful tool designed to extract emails from TikTok profiles efficiently and accurately. It helps businesses and marketers connect with TikTok influencers and users for collaborations and outreach.

With the TikTok Email Scraper, you can automate the process of finding contact emails from TikTok profiles, saving time and effort. This tool is ideal for anyone looking to build email lists for marketing or networking purposes.

Scraping TikTok emails is now easier than ever with this automated solution. It eliminates the need for manual searching, providing you with verified email addresses quickly.

### 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 from TikTok profiles. |
| Profile Names | Retrieve the names associated with TikTok profiles. |
| Usernames | Collect TikTok usernames for better identification. |
| Follower Counts | Access the number of followers for each TikTok profile. |
| Profile Links | Get direct links to TikTok profiles for easy access. |
| Bio Information | Extract bio details from TikTok profiles for additional context. |
| Engagement Metrics | Retrieve likes, comments, and shares for influencer evaluation. |
| Location Data | Collect location details if publicly available on profiles. |

### Key Features of **TikTok** Email Scraper

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

- ⭐ **Automated** extraction of emails from **TikTok** profiles
- ⭐ **High** accuracy in retrieving verified contact information
- ⭐ Ability to scrape data at scale for large campaigns
- ⭐ User-friendly interface for easy operation and setup
- ⭐ **Customizable** filters to target specific profiles or niches
- ⭐ **Fast** data processing to save time and resources
- ⭐ **Secure** and compliant with ethical scraping practices
- ⭐ Detailed reporting and export options for extracted data
- ⭐ Support for scraping multiple profiles simultaneously
- ⭐ **Regular** updates to ensure compatibility with **TikTok** changes
- ⭐ **Advanced** error handling for uninterrupted scraping
- ⭐ **Comprehensive** customer support for troubleshooting

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

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

1. ✅ **Sign up** for the **TikTok** Email Scraper and **log in** to your account
2. ✅ Install the scraper tool or access it via the provided platform
3. ✅ Enter the **TikTok** profiles or keywords you want to target
4. ✅ Customize filters to refine your search based on specific criteria
5. ✅ **Start** the scraping process and monitor progress in real-time
6. ✅ **Review** the extracted data for accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or Excel
8. ✅ Use the extracted emails for marketing outreach or research

### Use Cases 🎯

Influencer Marketing
🎯 **Find** **TikTok** influencer emails for collaboration opportunities
🎯 Build targeted email lists for influencer outreach campaigns

Business Networking
🎯 Connect with **TikTok** users relevant to your industry
🎯 Expand your professional network with verified contact details

Market Research
🎯 Gather data on **TikTok** profiles for audience analysis
🎯 **Identify** trends and user preferences through profile information

Content Promotion
🎯 Reach out to **TikTok** users for promoting your content or products
🎯 Leverage email marketing to engage with **TikTok** audiences

### Why choose us? 💎

Choosing the **TikTok** Email Scraper ensures you receive a **reliable** and efficient tool for extracting emails from **TikTok** profiles. Our software is designed with accuracy and speed in mind, allowing you to gather verified contact information effortlessly.

We prioritize ethical scraping practices to ensure compliance with legal guidelines and platform policies. Our tool is **user-friendly** and equipped with **advanced** features like customizable filters and detailed reporting.

Whether you are a marketer, business owner, or researcher, the **TikTok** Email Scraper is tailored to meet your needs. With **regular** updates and dedicated customer support, we ensure a seamless experience for all users.

By choosing our scraper, you gain access to a powerful solution for **TikTok** email extraction that saves time and resources. Trust us to help you connect with **TikTok** influencers and users effectively and ethically.

### **TikTok** Email Scraper Scalability 📈

The **TikTok** Email Scraper is designed to handle **large-scale** data extraction with ease. Whether you need to scrape emails from a few profiles or thousands, our tool can manage the workload **efficient**ly.

It is built with **advanced** algorithms to process data quickly without compromising accuracy. Our scraper supports simultaneous processing of multiple profiles, ensuring faster results for large campaigns.

You can customize the scraping process to target specific niches or demographics, making it highly versatile. With robust infrastructure and regular updates, the **TikTok** Email Scraper remains reliable even as your data needs grow.

It is the perfect solution for businesses and marketers looking to scale their email extraction efforts on **TikTok**.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **TikTok**s terms of service when using the scraper
⚖️ **Only** extract publicly available information from **TikTok** profiles
⚖️ **Avoid** using the scraper for spamming or unauthorized marketing purposes
⚖️ Respect user privacy and do not scrape sensitive or private data
⚖️ **Use** the extracted data ethically and for legitimate purposes only
⚖️ **Adhere** to local data protection laws and regulations when handling scraped data
⚖️ **Do not** attempt to bypass **TikTok**s security measures or restrictions
⚖️ **Ensure** proper storage and handling of extracted data to prevent misuse

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

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

The TikTok Email Scraper is a tool designed to extract **emails** from TikTok profiles for marketing, outreach, or research purposes.

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

**Yes**, the scraper is **user-friendly** and requires minimal technical knowledge to operate.

#### What information can I **extract** using the TikTok **Email Scraper**?

You can extract email addresses, profile names, usernames, follower counts, bio information, and more.

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

**Yes**, as long as you comply with TikTok's terms of service and only extract **publicly available** data.

#### Can I use the scraper for influencer marketing?

**Yes**, the scraper is ideal for finding TikTok influencer **emails** for collaborations and outreach.

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

The scraper is designed to provide high accuracy by verifying contact information during the extraction process.

#### Can I customize the scraping process?

**Yes**, you can apply filters to target specific profiles or niches for more precise results.

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

**Yes**, the tool is designed to handle large-scale data extraction efficiently.

#### How do I **export** the **extract**ed data?

You can export the data in formats like **CSV** or Excel for easy use.

#### Does the scraper work with **private** profiles?

**No**, the scraper only extracts data from **publicly available** TikTok profiles.

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

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

#### Can I scrape data from multiple profiles simultaneously?

**Yes**, the scraper supports simultaneous processing for faster results.

#### Are regular updates provided?

**Yes**, we provide **regular updates** to ensure compatibility with TikTok's platform changes.

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

The scraper can be accessed via a web platform or installed on compatible devices.

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

**Yes**, the scraper is designed with robust security measures to protect your data and ensure ethical use.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Email Scraper",
        "description": "📩 TikTok Email Scraper (tiktok-email-scraper) extracts emails from TikTok profiles to help you grow leads faster. 🚀 Perfect for outreach, B2B sales, influencer marketing & recruiting—save time, boost prospecting, and stay compliant.",
        "version": "0.1",
        "x-build-id": "eFdLgf6mGuLtTePzl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~tiktok-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-tiktok-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~tiktok-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-tiktok-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~tiktok-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-tiktok-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 Tiktok (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Tiktok profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Tiktok"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Tiktok"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```