# Tiktok Email Scraper (`scrapio/tiktok-email-scraper`) Actor

TikTok Email Scraper helps you collect creator emails directly from TikTok accounts. Use the data for sponsorship outreach, collaborations, and PR campaigns. Fast, scalable scraping with clean, export-ready results.

- **URL**: https://apify.com/scrapio/tiktok-email-scraper.md
- **Developed by:** [Scrapio](https://apify.com/scrapio) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 16 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$14.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 📱

The **TikTok** Email Scraper allows users to **extract** a wide range of **data** from **TikTok** profiles. This **data** can be used for marketing, research, or building **contact** lists.

The tool is designed to retrieve publicly available information from **TikTok** profiles efficiently and accurately. By using this scraper, you can access essential **data** points such as email addresses, profile names, follower counts, and more.

This makes it an ideal solution for businesses, marketers, and researchers who need reliable and actionable **data**. The **TikTok** Email Scraper ensures that all **data** is collected in compliance with ethical and legal guidelines.

It is designed to handle large-scale **data** **extract**ion while maintaining accuracy and speed. With this tool, you can streamline your **data** collection process and focus on your core objectives.

TikTok Email Scraper is a powerful tool designed to help users extract valuable email data from TikTok profiles efficiently and accurately. It simplifies the process of gathering contact information for outreach, marketing, or research purposes.

With the TikTok Email Scraper, you can automate the tedious task of manually searching for emails on TikTok profiles. This tool is perfect for businesses, marketers, and researchers looking to streamline their data collection efforts.

TikTok is one of the fastest-growing social media platforms, making it a goldmine for valuable contact information. By using a TikTok email extraction tool, you can gain access to critical data while saving time and resources.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from TikTok profiles. |
| Profile names | Retrieve the names associated with TikTok profiles. |
| Follower counts | Access the number of followers for each TikTok profile. |
| Profile URLs | Collect direct links to TikTok profiles for easy access. |
| Bio descriptions | Extract bio information from TikTok profiles. |
| Profile pictures | Download profile pictures from TikTok accounts. |
| Engagement metrics | Retrieve data on likes, comments, and shares for specific profiles. |
| Location (if available) | Extract location details if shared publicly on TikTok 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** email extraction from **TikTok** profiles for fast and accurate results
- ⭐ User-friendly interface suitable for both beginners and advanced users
- ⭐ Ability to extract multiple data points including emails profile names and follower counts
- ⭐ **High**-speed scraping capabilities for large-scale data collection
- ⭐ **Customizable** scraping options to target specific profiles or data types
- ⭐ Ensures compliance with ethical and legal data collection guidelines
- ⭐ Provides detailed reports of extracted data for easy analysis
- ⭐ Supports integration with other tools and software for seamless workflows
- ⭐ **Regular** updates to maintain compatibility with **TikTok**s platform changes
- ⭐ **Secure** data handling to protect user privacy and collected information
- ⭐ 247 customer support to assist with any issues or questions
- ⭐ Scalable solution designed to handle projects of any size

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

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

1. ✅ **Sign up** for an account and **log in** to access the **TikTok** Email Scraper
2. ✅ **Input** the **TikTok** profile URLs or keywords you want to target
3. ✅ **Select** the data types you wish to extract such as emails or profile names
4. ✅ Customize the scraping parameters to fit your specific needs
5. ✅ **Start** the scraper and monitor the progress in real-time
6. ✅ Download the extracted data in your preferred format such as CSV or JSON
7. ✅ **Review** the collected data to ensure accuracy and completeness
8. ✅ Use the data for your intended purpose such as marketing or research

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted email lists for **TikTok** influencers
🎯 Enhance outreach campaigns with accurate contact information
🎯 **Identify** potential collaboration opportunities with **TikTok** creators

Market Research
🎯 **Analyze** **TikTok** profiles to understand audience demographics
🎯 Gather data on popular **TikTok** trends and influencers
🎯 **Study** competitor profiles for strategic insights

Lead Generation
🎯 **Find** new leads by extracting emails from **TikTok** profiles
🎯 Expand your contact database with verified email addresses
🎯 Target specific niches or industries using **TikTok** data

Content Creation
🎯 **Identify** trending topics and content ideas from **TikTok** profiles
🎯 Connect with influencers for content collaborations
🎯 **Analyze** engagement metrics to refine your content strategy

### Why choose us? 💎

Our **TikTok** Email Scraper is the **best** **TikTok** email extraction tool available for businesses, marketers, and researchers. It combines speed, accuracy, and ease of use to deliver **reliable** results every time.

Unlike other tools, our scraper is designed to handle large-scale data extraction projects with minimal effort. We prioritize user experience by offering a simple and intuitive interface that anyone can use.

Our tool is **regular**ly updated to ensure compatibility with **TikTok**'s platform changes. Additionally, we provide 24/7 customer support to address any issues or questions you may have.

We take data security seriously and ensure that all collected information is handled responsibly. By choosing our **TikTok** Email Scraper, you can save time, reduce manual effort, and focus on achieving your goals.

Whether you're building a contact list, conducting research, or enhancing your outreach campaigns, our scraper is the ideal solution. With our tool, you can extract emails and other data from **TikTok** profiles quickly and efficiently.

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

The **TikTok** Email Scraper is designed to handle projects of any size, making it a scalable solution for businesses and individuals. Whether you need to extract data from a few profiles or thousands, our tool can manage the workload with ease.

It features high-speed scraping capabilities that ensure fast and accurate results, even for **large-scale** projects. Our scraper also allows you to customize parameters to focus on specific data types or profiles.

This flexibility makes it suitable for both small-scale and enterprise-level data extraction needs. Additionally, our tool is optimized to handle **TikTok**'s platform changes, ensuring uninterrupted performance.

With its robust infrastructure, the **TikTok** Email Scraper can support your data collection efforts as your needs grow. It is the perfect solution for users looking for a reliable and scalable **TikTok** data scraping software.

### **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** that all data collected is publicly available on **TikTok** profiles
⚖️ **Do not** use the scraper to access private or restricted information
⚖️ Comply with **TikTok**s terms of service and data usage policies
⚖️ **Avoid** using the tool for spamming or unsolicited email campaigns
⚖️ Respect user privacy and handle collected data responsibly
⚖️ **Use** the scraper only for ethical and legal purposes such as research or marketing
⚖️ **Do not** sell or distribute extracted data without proper authorization
⚖️ Stay informed about data protection laws in your region such as GDPR or CCPA

### 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** and other data from TikTok profiles efficiently.

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

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

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

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

#### Is the scraper compatible with TikTok's platform?

**Yes**, the scraper is regularly updated to ensure compatibility with TikTok's platform changes.

#### Can I use the scraper for **large-scale** projects?

**Yes**, the TikTok Email Scraper is designed to handle projects of any size with high-speed performance.

#### Is the data collection process compliant with **legal** guidelines?

**Yes**, the scraper ensures **compliance** with ethical and legal data collection practices.

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

You can download the extracted data in formats like **CSV** or **JSON** for easy analysis.

#### Can I customize the scraping parameters?

**Yes**, the tool allows you to customize parameters to target specific profiles or data types.

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

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

#### Can I integrate the scraper with other tools?

**Yes**, the TikTok Email Scraper supports integration with other tools for **seamless** workflows.

#### Is my data **secure** while using the scraper?

**Yes**, we prioritize data security and ensure that all collected information is handled responsibly.

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

The scraper is compatible with most modern operating systems and requires an internet connection.

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

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

#### How often is the scraper updated?

The scraper is regularly updated to maintain compatibility with TikTok's platform changes.

#### Is there a free trial available?

Please check our website for information on free trials or demo versions of the TikTok Email Scraper.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapio/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 helps you collect creator emails directly from TikTok accounts. Use the data for sponsorship outreach, collaborations, and PR campaigns. Fast, scalable scraping with clean, export-ready results.",
        "version": "0.1",
        "x-build-id": "8OieCqKarZPgw936A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~tiktok-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-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/scrapio~tiktok-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-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/scrapio~tiktok-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```