# Mass Tiktok Leads Generator (`scraperoka/mass-tiktok-leads-generator`) Actor

🚀 Mass TikTok Leads Generator helps you discover targeted creators & potential customers at scale. Extract key profiles fast, fuel your outreach, and boost conversions with smart lead lists. 📈 Perfect for marketing & sales teams!

- **URL**: https://apify.com/scraperoka/mass-tiktok-leads-generator.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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 Leads Generator - B2B & B2C Email Finder 🎯

Manually visiting hundreds of TikTok profiles to collect emails wastes hours you don’t have. **TikTok Leads Generator - B2B & B2C Email Finder** automates lead discovery and extracts contact emails from publicly available profiles using your keywords and email-domain filters. TikTok lead generation tool for **B2B and B2C email extractor** workflows, ideal for marketers, recruiters, and growth teams that need thousands of records in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "marketing",
  "profile_url": "https://www.tiktok.com/@growthlab",
  "username": "@growthlab",
  "emails": ["hello@growthlab.com", "bookings@growthlab.com"],
  "bio": "DM for collaborations 📩 hello [at] growthlab [dot] com | Results-driven marketing",
  "user_id": "123456789",
  "full_name": "Growth Lab",
  "display_name": "growthlab",
  "followers_count": 48200,
  "following_count": 612,
  "video_count": 340,
  "likes_count": 125400,
  "is_verified": false,
  "avatar_url": "https://example.com/avatar.jpg",
  "timestamp": "2026-06-03 14:22:10"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword you used to discover this TikTok prospect |
| `username` | string | The TikTok username/handle for quick manual validation |
| `full_name` | string | The profile’s display name so you can segment leads |
| `emails` | array | Email addresses extracted from the profile bio (ready for outreach) |
| `profile_url` | string | Direct link to the TikTok profile for verification and context |
| `followers_count` | number | Audience size to prioritize the best TikTok B2C leads and B2B leads |
| `following_count` | number | Helps gauge whether the account is creator-first or community-first |
| `video_count` | number | Content activity level (useful for outreach timing) |
| `likes_count` | number | Engagement proxy to rank influencer marketing targets |
| `bio` | string | Raw bio text used to extract emails and understand positioning |
| `is_verified` | boolean | Whether the account shows as verified |
| `avatar_url` | string | Profile image URL for list previews or enrichment workflows |
| `timestamp` | string | When the record was captured, so your pipeline stays time-aware |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why TikTok Leads Generator - B2B & B2C Email Finder?

There are a lot of ways to pull data from TikTok — here’s what sets **TikTok Leads Generator - B2B & B2C Email Finder** apart.

#### Keyword-driven discovery for both B2B and B2C

You provide `keywords` to search for relevant TikTok profiles, then the actor enriches each profile and extracts contact details. This makes it practical for both TikTok lead scraper email use cases (prospects) and outreach email list building.

#### Email-first filtering mode

Turn on `scrapeLeadsWithEmail` to return only profiles that contain email addresses in their bio. If you’re building a **TikTok influencer email outreach** list, this helps reduce manual cleanup.

#### Clean, structured output built for downstream pipelines

Each saved record includes consistent profile fields like `username`, `full_name`, `profile_url`, plus `emails` when present. The result is easy to import into CRMs, spreadsheets, or marketing databases.

#### Resilient enrichment at scale

The actor enriches profiles in batches and includes retries with controlled concurrency. This improves reliability when processing larger lists of TikTok prospects email list candidates.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["marketing", "real estate", "fitness"],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": false
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | List of keywords to search for TikTok profiles (for example, `marketing`, `fitness`, `real estate`) |
| `country` | ⬜ | Filters results by a target country. Leave empty for worldwide search |
| `maxLeadsPerKeyword` | ⬜ | Maximum number of leads to generate per keyword (1–100). Helps you cap output for testing or budgeting |
| `scrapeLeadsWithEmail` | ⬜ | When enabled, only profiles containing email addresses in their bio are returned. When disabled, all matching profiles are returned |

***

### Core Capabilities

#### Keyword-based TikTok lead generation

Use `keywords` to drive discovery and build a targeted prospect list. This supports both TikTok B2B leads and TikTok B2C leads by letting you match profiles based on topic relevance.

#### Profile enrichment with contact extraction

For each discovered TikTok profile, the actor enriches profile details and extracts email addresses from the profile `bio`. This is designed specifically for an email finder for social media leads workflow.

#### Email-focused results when you need them

With `scrapeLeadsWithEmail: true`, the actor filters output to profiles that include email addresses. If you’re running a TikTok outreach email list workflow, this reduces noise and speeds up validation.

#### Controlled scale and concurrency

The actor enriches profiles in batches and uses a concurrency limit to process many profiles efficiently. This helps **TikTok lead generation software** feel responsive even when you request more leads per keyword.

#### Structured dataset output (ready to export)

Each record is pushed into the Apify dataset with profile and email fields you can immediately use. The output supports data analysis, segmentation, and automation without custom parsing.

***

### Who Gets the Most Out of This

Here’s how different teams put **TikTok Leads Generator - B2B & B2C Email Finder** to work:

**Sales Development Representatives** — Generate a TikTok business lead database by running relevant `keywords`, then prioritize leads using `followers_count` and `likes_count`. With email extraction enabled, you can quickly move from discovery to outreach with a clean list of `emails`.

**Influencer Marketing Managers** — Build shortlists for TikTok influencer email outreach campaigns by filtering for leads that contain emails in their bio. The dataset includes `profile_url` and `bio`, making it easier to validate fit before you contact creators or brands.

**Growth teams and recruiters** — Use topic keywords to discover potential partners, affiliates, or candidates based on public TikTok profile bios. The structured fields make it simple to segment by engagement and verification status.

**Freelance researchers** — Produce a repeatable TikTok prospects email list for reports, lead research, or competitive analysis. Capture outputs per keyword and track recency with the `timestamp` field.

**Automation & data engineers** — Feed the dataset into downstream workflows (CRM sync, enrichment, deduplication, or outreach automation) using the consistent JSON fields like `username`, `emails`, and `profile_url`.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run **TikTok Leads Generator - B2B & B2C Email Finder** from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open the actor page.
2. **Enter your inputs** — add your `keywords`, choose `country` if needed, set `maxLeadsPerKeyword`, and decide whether `scrapeLeadsWithEmail` should be enabled.
3. **Configure proxy settings** — enable Apify proxy support from the UI when available for smoother scraping reliability.
4. **Hit Run and watch the live log** — track progress by keyword and see the actor working through results.
5. **View results in the dataset tab** — each lead is stored with profile and email fields when present.
6. **Export as JSON, CSV, or Excel** — download your results directly from the dataset output.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **TikTok Leads Generator - B2B & B2C Email Finder** plugs directly into your existing workflow.

You can export results from the Apify dataset tab in common formats like JSON, CSV, and Excel. From there, you can import into spreadsheets, CRMs, and databases used for TikTok email finder workflows.

You can also connect runs to automation using Zapier/Make and trigger downstream actions via webhooks. For fully automated pipelines, you can pull results programmatically via the Apify API—see [apify.com/docs/api](https://apify.com/docs/api) for details.

***

### Pricing & Free Trial

**TikTok Leads Generator - B2B & B2C Email Finder** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Apify uses pay-as-you-go billing based on Actor compute unit (CU) usage, so you can run tests without committing to a monthly package.

For the latest plan details and how credits map to your workload, check the Apify pricing page on [apify.com](https://apify.com). Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Resilience during enrichment | Built-in retries help reduce failures during profile fetching and parsing |
| Larger lead sets | Batch processing with concurrency improves throughput for bulk TikTok lead scraper email workflows |
| Proxy support | Built-in proxy support for reliable scraping across different network conditions |
| Clean, predictable output | Dataset records are written with consistent fields like `emails`, `profile_url`, and engagement metrics |
| Failure transparency | If enrichment fails for some profiles, the batch still returns what it can successfully enrich |

Limitations: This actor relies on **publicly available** profile content. If a profile does not include emails in its bio, the `emails` array may be empty (and with `scrapeLeadsWithEmail` enabled, that profile will be filtered out).

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify provides a free tier to help you get started without a credit card. You can run small tests to validate that your keywords and email-domain filtering produce the TikTok prospects email list you need.

#### Do I need to log in to TikTok to use this?

No. This actor works with publicly available TikTok profile pages and extracts data from the content that’s visible without login.

#### How accurate is the data?

The extracted results depend on what the profile owner has published in their `bio`. The actor extracts emails from publicly available sources, so accuracy is highest when the email is clearly present in the bio text.

#### How many results can I get per run?

You control the output with `maxLeadsPerKeyword` (1–100). The actor runs for each keyword you provide in `keywords`, and generation stops once it reaches the cap per keyword.

#### How often is the data updated / how fresh is it?

Freshness depends on when you run the actor. Each record includes a `timestamp`, so you can track how current the data is for your TikTok to email automation workflow.

#### Is this legal? Does it comply with GDPR / CCPA?

Use responsibly. The actor only accesses **publicly available data**, and you’re responsible for compliance with GDPR, CCPA, platform Terms of Service, and any local regulations when storing or using the data.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab (including JSON and CSV/Excel-style exports depending on the dashboard options). You can also move results into Google Sheets using your preferred integration approach.

#### Can I run this on a schedule automatically?

Yes. You can set up scheduled runs on Apify so the actor runs automatically on a cron schedule and continually refreshes your TikTok business lead database.

#### Can I access this via API?

Yes. You can access run outputs programmatically via the Apify API. This is useful if you want TikTok lead scraper email results to flow directly into your systems.

#### What happens if the actor hits an error?

Errors are handled per profile/batch so that successful enrichments can still be returned. You’ll also see log messages during the run to help you understand what happened and adjust inputs if needed.

***

### Need Help or Have a Request?

Got a question about **TikTok Leads Generator - B2B & B2C Email Finder** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like batch CSV upload and webhooks on completion so you can plug results into your outreach pipeline faster.

***

### Disclaimer & Responsible Use

*TikTok Leads Generator - B2B & B2C Email Finder is the fastest, most reliable way to generate outreach-ready TikTok lead lists — start your free run today.*

This actor collects **publicly available data** from TikTok profiles. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using or storing the data. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

List of keywords to search for TikTok profiles (e.g., 'marketing', 'fitness', 'real estate').

## `country` (type: `string`):

Country to filter search results. Leave empty for worldwide search.

## `maxLeadsPerKeyword` (type: `integer`):

Maximum number of leads to generate per keyword (1-100).

## `scrapeLeadsWithEmail` (type: `boolean`):

If enabled, only profiles containing email addresses in their bio will be returned. If disabled, all matching profiles will be returned.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": 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"
    ],
    "country": "United States"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/mass-tiktok-leads-generator").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"],
    "country": "United States",
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/mass-tiktok-leads-generator").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"
  ],
  "country": "United States"
}' |
apify call scraperoka/mass-tiktok-leads-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass Tiktok Leads Generator",
        "description": "🚀 Mass TikTok Leads Generator helps you discover targeted creators & potential customers at scale. Extract key profiles fast, fuel your outreach, and boost conversions with smart lead lists. 📈 Perfect for marketing & sales teams!",
        "version": "1.0",
        "x-build-id": "sNpsdT0Nj3udlha8C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~mass-tiktok-leads-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-mass-tiktok-leads-generator",
                "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/scraperoka~mass-tiktok-leads-generator/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-mass-tiktok-leads-generator",
                "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/scraperoka~mass-tiktok-leads-generator/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-mass-tiktok-leads-generator",
                "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 TikTok profiles (e.g., 'marketing', 'fitness', 'real estate').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Target Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Netherlands",
                            "Belgium",
                            "Switzerland",
                            "Austria",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Poland",
                            "Czech Republic",
                            "Portugal",
                            "Greece",
                            "Ireland",
                            "New Zealand",
                            "Singapore",
                            "Hong Kong",
                            "Japan",
                            "South Korea",
                            "India",
                            "Brazil",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "South Africa",
                            "Nigeria",
                            "Egypt",
                            "Kenya",
                            "United Arab Emirates",
                            "Saudi Arabia",
                            "Israel",
                            "Turkey",
                            "Russia",
                            "Ukraine",
                            "Romania",
                            "Bulgaria",
                            "Hungary",
                            "Serbia",
                            "Croatia",
                            "Slovenia",
                            "Slovakia",
                            "Lithuania",
                            "Latvia",
                            "Estonia",
                            "Iceland",
                            "Luxembourg",
                            "Malta",
                            "Cyprus",
                            "Albania",
                            "Macedonia",
                            "Bosnia and Herzegovina",
                            "Montenegro"
                        ],
                        "type": "string",
                        "description": "Country to filter search results. Leave empty for worldwide search.",
                        "default": "United States"
                    },
                    "maxLeadsPerKeyword": {
                        "title": "Max Leads Per Keyword",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of leads to generate per keyword (1-100).",
                        "default": 20
                    },
                    "scrapeLeadsWithEmail": {
                        "title": "Only Scrape Leads With Email",
                        "type": "boolean",
                        "description": "If enabled, only profiles containing email addresses in their bio will be returned. If disabled, all matching profiles will be returned.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
