# Tiktok B2b Email Scraper (`api-empire/tiktok-b2b-email-scraper`) Actor

A high-performance TikTok B2B email scraper that extracts publicly available business emails from TikTok profiles at scale. Using advanced scraping logic

- **URL**: https://apify.com/api-empire/tiktok-b2b-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

### **TikTok** Email Scraper 📱

Tiktok B2B Email Scraper enables users to **extract** key **data** points from **TikTok** profiles for B2B purposes. It focuses on collecting publicly available business email addresses to help users connect with potential leads.

The tool also captures other relevant details such as profile names, follower counts, and bio descriptions. By using this email scraper for **TikTok** leads, businesses can build targeted outreach lists quickly and efficiently.

It is designed to ensure that the **extract**ed **data** is accurate and up-to-date, providing valuable insights for marketing and sales campaigns. This B2B email **extract**ion tool for **TikTok** is suitable for professionals in various industries looking to expand their network and grow their business.

Tiktok B2B Email Scraper is a powerful tool designed to extract business emails from TikTok profiles efficiently. It helps businesses streamline lead generation by collecting accurate contact information from TikTok users.

With the increasing popularity of TikTok among businesses, finding B2B contacts on the platform has become essential. This scraper simplifies the process by automating email extraction for TikTok leads.

Tiktok B2B Email Scraper is ideal for marketers, recruiters, and sales teams looking to connect with businesses on TikTok. It provides a fast and reliable way to gather email data for outreach 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 |
| --- | --- |
| Business Email | Extract publicly available business email addresses from TikTok profiles. |
| Profile Name | Retrieve the name associated with the TikTok profile. |
| Profile URL | Get the direct link to the TikTok user’s profile. |
| Follower Count | Collect the number of followers for each TikTok profile. |
| Bio Description | Extract the bio or description text from TikTok profiles. |
| Profile Category | Identify the category or niche of the TikTok profile. |
| Engagement Metrics | Gather data on likes, comments, and shares for the profile. |
| Location | Extract location details if available on the TikTok profile. |

### 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**:

- ⭐ Extract business emails from **TikTok** profiles with high accuracy
- ⭐ Automate the process of gathering B2B contact information from **TikTok**
- ⭐ Retrieve additional profile data such as follower count and bio description
- ⭐ Supports bulk scraping for multiple **TikTok** profiles simultaneously
- ⭐ User-friendly interface for easy setup and operation
- ⭐ **Advanced** filtering options to target specific niches or categories
- ⭐ **Regular** updates to ensure compatibility with **TikTok**s platform changes
- ⭐ Export extracted data in multiple formats such as CSV or Excel
- ⭐ Built-in error handling to minimize inaccuracies in data extraction
- ⭐ Compliant with legal and ethical guidelines for data scraping

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

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

1. ✅ **Sign up** or **log in** to your account on the Tiktok B2B Email Scraper platform
2. ✅ Enter the **TikTok** profile URLs or keywords you want to scrape data from
3. ✅ Customize the scraping settings such as target data types and filters
4. ✅ **Start** the scraping process and monitor the progress in real-time
5. ✅ Wait for the tool to complete the data extraction process
6. ✅ **Review** the extracted data to ensure accuracy and completeness
7. ✅ **Export** the data to your preferred format such as CSV or Excel
8. ✅ Use the extracted data for your B2B marketing or outreach campaigns

### Use Cases 🎯

Lead Generation for B2B Marketing
🎯 Extract business emails from **TikTok** profiles for targeted outreach
🎯 Build a database of potential clients or partners from **TikTok** users

Recruitment and Talent Acquisition
🎯 **Find** contact information of influencers or professionals on **TikTok**
🎯 Reach out to potential candidates for collaborations or job opportunities

Market Research and Analysis
🎯 **Analyze** **TikTok** profiles to understand trends in specific industries
🎯 **Collect** data on engagement metrics and follower demographics

Sales Prospecting
🎯 **Identify** and contact decision-makers using **TikTok** for business
🎯 Expand your sales pipeline with verified email leads from **TikTok**

### Why choose us? 💎

Tiktok B2B Email Scraper is designed to meet the needs of modern businesses looking for **reliable** email scraping tools. Our software is built with **advanced** algorithms to ensure high accuracy and efficiency in extracting business emails from **TikTok** profiles.

We understand the importance of data quality, which is why our tool focuses on providing up-to-date and verified email information. With a **user-friendly** interface, even non-technical users can easily navigate and use our software.

Our platform supports bulk scraping, making it ideal for large-scale lead generation campaigns. We prioritize compliance with legal and ethical guidelines, ensuring that our tool is safe and trustworthy to use.

Whether you are a marketer, recruiter, or sales professional, our Tiktok B2B Email Scraper offers a comprehensive solution to streamline your outreach efforts. Choose us for a **reliable**, efficient, and legally compliant email scraping experience.

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

Tiktok B2B Email Scraper is designed to handle projects of all sizes, making it a scalable solution for businesses of any scale. Whether you need to extract data from a few profiles or thousands, our tool can accommodate your requirements.

The software supports bulk scraping, allowing users to process multiple **TikTok** profiles simultaneously without compromising speed or accuracy. Our **advanced** infrastructure ensures that the tool remains fast and responsive even during high-volume data extraction tasks.

Regular updates and optimizations keep the software compatible with **TikTok**’s platform changes, ensuring consistent performance. With flexible plans and robust features, Tiktok B2B Email Scraper is suitable for startups, small businesses, and enterprises alike.

### **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
⚖️ **Do not** use the tool to collect personal or sensitive data without consent
⚖️ **Avoid** using the scraper for spamming or unsolicited marketing activities
⚖️ Respect data privacy laws such as GDPR and CCPA during data extraction
⚖️ **Use** the extracted data responsibly and for legitimate business purposes only
⚖️ **Do not** attempt to bypass **TikTok**s security measures or restrictions
⚖️ Regularly review legal and ethical guidelines to ensure compliance

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Tiktok B2B 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 B2B 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 B2B 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 Tiktok B2B **Email Scraper**?

Tiktok B2B Email Scraper is a tool designed to extract business **emails** and other data from TikTok profiles for lead generation.

#### How does the tool **extract** emails from TikTok?

The tool uses advanced algorithms to scrape **publicly available** business email addresses from TikTok profiles.

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

**Yes**, as long as you extract **publicly available** information and comply with TikTok’s terms of service and data privacy laws.

#### Can I use this scraper for bulk data **extract**ion?

**Yes**, Tiktok B2B Email Scraper supports bulk scraping for multiple profiles simultaneously.

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

The tool allows you to export data in formats such as **CSV** and Excel.

#### Is this tool suitable for non-technical users?

**Yes**, the **user-friendly** interface makes it easy for non-technical users to operate the scraper.

#### Can I customize the scraping settings?

**Yes**, the tool offers customizable settings to target specific data types and filters.

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

The tool is designed to provide accurate and up-to-date data from TikTok profiles.

#### Does the scraper work with all TikTok profiles?

The tool works with profiles that have **publicly available** information, but private or restricted accounts may not be accessible.

#### What industries can benefit from this tool?

Industries such as marketing, sales, recruitment, and research can benefit from using Tiktok B2B Email Scraper.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with TikTok’s platform changes.

#### Can I use this tool for influencer outreach?

**Yes**, the scraper is ideal for finding contact information of influencers on TikTok.

#### Is there a **limit** to the number of profiles I can scrape?

The limit depends on your subscription plan, but the tool supports high-volume data extraction.

#### What support options are available?

We provide customer support to assist with any issues or questions regarding the tool.

#### Is the tool compatible with all devices?

The scraper is compatible with most modern devices and browsers for **seamless** operation.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok B2b Email Scraper",
        "description": "A high-performance TikTok B2B email scraper that extracts publicly available business emails from TikTok profiles at scale. Using advanced scraping logic",
        "version": "0.1",
        "x-build-id": "EaPCv2iy811LY2mad"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~tiktok-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-tiktok-b2b-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~tiktok-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-tiktok-b2b-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~tiktok-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-tiktok-b2b-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```