# TikTok Lead Scraper (`scrapapi/tiktok-lead-scraper`) Actor

- **URL**: https://apify.com/scrapapi/tiktok-lead-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (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

from $2.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** Lead Scraper 📱

**TikTok** Lead Scraper allows users to **extract** valuable **data** from **TikTok** profiles seamlessly. It focuses on gathering lead addresses and other **contact** details that are publicly available.

This tool ensures **data** accuracy and relevance by targeting specific profiles or hashtags. Extracted **data** is organized and ready for immediate use in marketing campaigns or research projects.

With features like bulk **extract**ion and filtering options, users can customize their **data** collection process. **TikTok** Lead Scraper is designed to handle large **data**sets while maintaining high performance and speed.

It is a reliable solution for businesses and individuals seeking actionable insights from **TikTok**.

TikTok Lead Scraper is a powerful tool designed to extract lead addresses from TikTok profiles efficiently. It helps users gather contact information for marketing, outreach, or research purposes.

With TikTok's massive user base, extracting relevant data can be challenging without automation. TikTok Lead Scraper simplifies this process by providing accurate and organized results.

This TikTok data extraction tool is ideal for businesses, marketers, and researchers looking to access TikTok user data. It ensures compliance with legal guidelines while delivering high-quality data.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead addresses | Publicly available lead addresses from TikTok profiles. |
| Profile usernames | Usernames of TikTok accounts being scraped. |
| Profile URLs | Direct links to TikTok profiles for reference. |
| Follower count | Number of followers for each TikTok profile. |
| Profile bio | Details from the bio section of TikTok profiles. |
| Hashtags used | Popular hashtags associated with the profiles. |
| Engagement metrics | Likes, comments, and shares on recent posts. |
| Location data | Geographical information if publicly available. |

### Key Features of **TikTok** Lead Scraper

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

- ⭐ Efficiently extracts lead addresses from **TikTok** profiles
- ⭐ Supports bulk data extraction for large-scale operations
- ⭐ Provides filtering options to target specific hashtags or profiles
- ⭐ Organizes extracted data for easy access and analysis
- ⭐ Ensures compliance with **TikTok**s terms of service and legal guidelines
- ⭐ Offers high-speed scraping with minimal system requirements
- ⭐ User-friendly interface for seamless operation
- ⭐ **Advanced** algorithms for accurate and reliable data extraction
- ⭐ Compatible with various operating systems and devices
- ⭐ Includes detailed documentation and customer support for assistance
- ⭐ **Customizable** settings to meet individual data extraction needs
- ⭐ **Secure** data handling to protect user privacy and integrity

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

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

1. ✅ Install the **TikTok** Lead Scraper on your device following the provided instructions
2. ✅ Log in to your **TikTok** account to access public profiles for scraping
3. ✅ Enter specific hashtags or usernames to target relevant profiles
4. ✅ **Configure** the scraping settings including filters and data types to extract
5. ✅ **Start** the scraping process and monitor its progress through the dashboard
6. ✅ **Export** the extracted data in your preferred format such as CSV or JSON
7. ✅ **Review** the data for accuracy and organize it for further use
8. ✅ Use the extracted data for outreach marketing or research purposes

### Use Cases 🎯

Influencer Marketing
🎯 **Identify** **TikTok** influencers by extracting lead addresses
🎯 Reach out to influencers for collaborations using contact details

Market Research
🎯 **Analyze** **TikTok** user trends by gathering profile data
🎯 Extract engagement metrics to study audience behavior

Business Outreach
🎯 **Find** potential customers by scraping **TikTok** profiles
🎯 **Use** lead addresses for targeted marketing campaigns

Content Analysis
🎯 Extract hashtags and bio information for content strategy
🎯 **Study** follower counts and engagement for competitive analysis

### Why choose us? 💎

**TikTok** Lead Scraper stands out as the **best** **TikTok** scraper tool due to its **advanced** features and reliability. It is designed to cater to businesses, marketers, and researchers who need accurate and organized data from **TikTok** profiles.

Our tool ensures compliance with legal guidelines and **TikTok**'s terms of service, making it a safe option for data extraction. With high-speed scraping capabilities, **TikTok** Lead Scraper handles large datasets efficiently, saving time and effort.

We offer customizable settings and filtering options to meet diverse user needs, ensuring relevant and actionable results. Our **user-friendly** interface and detailed documentation make it accessible to users of all skill levels.

Additionally, our dedicated customer support team is available to assist with any issues or queries. Choose **TikTok** Lead Scraper for a **reliable**, efficient, and legally compliant solution to your **TikTok** data extraction needs.

### **TikTok** Lead Scraper Scalability 📈

**TikTok** Lead Scraper is built to handle data extraction tasks of any scale, making it suitable for individual users and large organizations alike. Its **advanced** algorithms ensure high-speed performance even when scraping thousands of profiles.

The tool supports bulk data extraction, allowing users to gather information from multiple profiles simultaneously. With **customizable** settings, users can target specific hashtags or profiles, optimizing the scraping process for their needs.

**TikTok** Lead Scraper is designed to adapt to growing data requirements, ensuring consistent performance as your operations expand. Whether you're conducting small-scale research or managing large marketing campaigns, this tool provides reliable and scalable solutions.

It is a robust **TikTok** automation tool for lead scraping and other data extraction needs.

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

**Yes**—scraping **TikTok** is **legal** as long as you follow **ethical** and **compliant** practices. The **TikTok** Lead 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 data that is publicly available on **TikTok** profiles
⚖️ **Avoid** scraping private or restricted information from **TikTok** accounts
⚖️ **Use** extracted data responsibly and within legal boundaries
⚖️ **Do not** use the scraper for spamming or unauthorized marketing activities
⚖️ Respect user privacy and adhere to data protection regulations
⚖️ Consult legal experts if unsure about data usage policies
⚖️ Follow ethical practices when using **TikTok** Lead Scraper for data extraction

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["TikTok Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "TikTok",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads 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 Lead 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",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies TikTok as the source |
| keyword | Keyword that triggered the result (TikTok Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct TikTok profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is TikTok **Lead Scraper**?

TikTok Lead Scraper is a tool designed to extract lead addresses and other data from TikTok profiles.

#### Is TikTok **Lead Scraper** **legal** to use?

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

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

**No**, TikTok Lead Scraper only extracts data from public profiles.

#### What data can I **extract** using TikTok **Lead Scraper**?

You can extract lead addresses, usernames, profile URLs, follower counts, bios, hashtags, engagement metrics, and location data.

#### Is TikTok **Lead Scraper** user-friendly?

**Yes**, it features a simple interface and detailed documentation for easy operation.

#### Can I use TikTok **Lead Scraper** for bulk data **extract**ion?

**Yes**, the tool supports bulk data extraction for large-scale operations.

#### Does TikTok **Lead Scraper** ensure data accuracy?

**Yes**, it uses advanced algorithms to deliver accurate and reliable results.

#### What formats can I **export** the data in?

You can export the data in formats like **CSV** or **JSON** for further use.

#### Is TikTok **Lead Scraper** suitable for businesses?

**Yes**, it is ideal for **businesses**, marketers, and researchers seeking actionable TikTok user data.

#### Does TikTok **Lead Scraper** offer **customer support**?

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

#### Can I customize the scraping settings?

**Yes**, the tool offers customizable settings to target specific profiles or hashtags.

#### Does TikTok **Lead Scraper** work on all devices?

**Yes**, it is compatible with various operating systems and devices.

#### How fast is TikTok **Lead Scraper**?

The tool is designed for high-speed scraping, even with large datasets.

#### Is TikTok **Lead Scraper** **secure**?

**Yes**, it ensures **secure** data handling to protect user privacy and integrity.

#### Can I use TikTok **Lead Scraper** for influencer marketing?

**Yes**, it helps identify influencers by extracting their lead addresses and other profile data.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Lead Scraper",
        "version": "0.1",
        "x-build-id": "8hRzUj7Vaq2aKIZyT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~tiktok-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-tiktok-lead-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/scrapapi~tiktok-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-tiktok-lead-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/scrapapi~tiktok-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-tiktok-lead-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```