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

🚀 Mass TikTok Leads Generator helps you find & capture high-intent TikTok leads at scale. 🧲 Automate prospecting, streamline outreach, and grow your pipeline faster—perfect for marketers, agencies, and B2B sales teams.

- **URL**: https://apify.com/scrapers-hub/mass-tiktok-leads-generator.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 (Free 100 Emails) 📬

**TikTok Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** is a lead generation actor that scrapes publicly available TikTok profiles using your keywords, extracts contact details from bios, and builds an email-enriched dataset you can use for outreach. Whether you’re a marketer, recruiter, or data enthusiast looking for a **TikTok lead generation tool** or a **TikTok email finder**, this actor helps you quickly turn profile data into actionable leads—saving you hours of manual work at scale.

---

### Why choose TikTok Leads Generator - B2B & B2C Email Finder (Free 100 Emails)?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one lead + email finding** | Extracts TikTok profile data plus email addresses in one run |
| ✅ **Free tier included (100 emails/run cap)** | Lets you test a **free email finder 100** workflow before upgrading |
| ✅ **Reliability with retries** | Includes retry logic (up to **3** attempts) to improve enrichment success |
| ✅ **Structured dataset output** | Saves leads to a dataset with consistent fields for easy export and analysis |
| ✅ **Scale across multiple keywords** | Generates leads per keyword, with a global cap enforced for free users |
| ✅ **Built-in proxy support for reliable scraping** | Uses proxy configurations to help maintain stable scraping sessions |

---

### Key features

- 🔎 **Keyword-driven lead discovery:** Provide one or more `keywords` and the actor generates TikTok leads aligned to your niche (e.g., **TikTok B2B lead generator** and **TikTok B2C email scraper** use cases).
- 📧 **Email extraction from public bios:** Extracts emails from profile bio text and returns them as an `emails` array.
- 🧾 **Complete profile enrichment:** Includes `followers_count`, `following_count`, `video_count`, `likes_count`, `bio`, `full_name`, `is_verified`, and `avatar_url`.
- 🛡️ **Resilience for real-world runs:** Uses retries during profile enrichment to improve the chance of successful data extraction.
- 💾 **Real-time saving to the dataset:** Leads are pushed as soon as they’re enriched, so you don’t have to wait for the entire batch to finish.
- 🧠 **Email-only mode option:** With `scrapeLeadsWithEmail` enabled, it will only return profiles that have a public email address in their bio.
- 🌐 **Country targeting:** Choose a `country` to focus your lead prospecting leads by region.

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | Yes | List of keywords to search for TikTok profiles (for example: `marketing`, `fitness`, `real estate`). |
| `country` | No | Select the target country for leads. Defaults to `United States`. |
| `maxLeadsPerKeyword` | No | Maximum number of leads to generate per keyword. Free users are capped at **100 emails total per run**. Defaults to `20`. |
| `scrapeLeadsWithEmail` | No | If enabled, only returns profiles that have a public email address in their bio. Defaults to `false`. |

***

### Output

The actor saves each enriched profile’s data in JSON format to the **TikTok Leads Dataset** dataset (view name: **Scraped Leads**).

Example output item:

```json
{
  "keyword": "marketing",
  "username": "someuser",
  "full_name": "Some Name",
  "emails": ["contact@example.com"],
  "profile_url": "https://www.tiktok.com/@someuser",
  "followers_count": 12345,
  "following_count": 678,
  "video_count": 90,
  "likes_count": 1200,
  "bio": "Your bio text here contact@example.com",
  "is_verified": false,
  "avatar_url": "https://example.com/avatar.jpg"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | The keyword that was used to find this TikTok profile. |
| `username` | string | The TikTok username for the profile. |
| `full_name` | string | The profile’s full name (when available). |
| `emails` | array | Extracted email addresses found in the profile bio. |
| `profile_url` | string | The normalized TikTok profile URL. |
| `followers_count` | number | Number of followers on the profile. |
| `following_count` | number | Number of accounts the profile is following. |
| `video_count` | number | Total number of videos posted. |
| `likes_count` | number | Total likes count (as returned by the enrichment). |
| `bio` | string | The raw bio text from the profile. |
| `is_verified` | boolean | Whether the profile is verified on TikTok. |
| `avatar_url` | string | URL to the profile avatar image. |

> Exports: you can export the dataset from the Apify UI in common formats like JSON/CSV.

***

### How to use TikTok Leads Generator - B2B & B2C Email Finder (Free 100 Emails) (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** tab.

2. **Find the actor**\
   Search for **TikTok Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** and open the actor page.

3. **Go to the INPUT section**\
   Paste your input JSON in the input editor. You can set `keywords`, choose a `country`, and optionally enable `scrapeLeadsWithEmail`.

4. **Review lead limits before running**\
   `maxLeadsPerKeyword` controls how many leads you aim to generate per keyword, and free users are capped at **100 emails total per run**.

5. **Start the run**\
   Click **Run**. During execution, watch the logs for progress. You’ll see enrichment happen in batches per keyword.

6. **Monitor logs for retries and progress**\
   The actor uses retry logic during enrichment, and it also applies email-only filtering when `scrapeLeadsWithEmail` is enabled.

7. **Open the output dataset**\
   After the run completes, open the **Scraped Leads** dataset view to review the TikTok leads and emails.

8. **Export your results**\
   Export the dataset to JSON/CSV and import into your CRM or analysis pipeline.

No coding required — get accurate **TikTok sales leads** data in minutes.

***

### Advanced features & SEO optimization

- 🔄 **Engineered-for-purpose for TikTok email prospecting:** Built specifically for **TikTok profile email scraper** and **TikTok outreach email list** workflows, combining profile metrics with email extraction.
- 🧩 **Email-only filtering for cleaner lead lists:** Turn on `scrapeLeadsWithEmail` to focus only on profiles that include a public email address in their bio.
- 🌍 **Country-focused lead targeting:** Use `country` to tailor results for outreach by region—useful for both **TikTok B2B lead generator** and **TikTok B2C email scraper** campaigns.
- 💾 **Structured data ready for automation:** Consistent dataset fields make it straightforward to pipe results into spreadsheets, BI tools, or automation jobs.
- 📝 **Built-in resilience for real-world web conditions:** Includes retries and fallback behavior to improve enrichment success rate during scraping runs.

***

### Best use cases

- 📈 **Marketing teams building outreach lists:** Generate **TikTok outreach email list** leads by niche keywords and enrich them with follower and engagement metrics.
- 🤝 **Sales teams qualifying creators/influencers:** Use follower counts and `profile_url` to shortlist **TikTok influencer email list** candidates quickly.
- 🧑‍💼 **Recruiters and talent sourcing:** Discover relevant TikTok profiles and extract **email extraction from social media** when available in bios.
- 🧪 **Market researchers analyzing social presence:** Compare profiles across keywords and countries with consistent structured output fields.
- 🧠 **CRM enrichment workflows:** Feed `emails`, `username`, `followers_count`, and `bio` into lead scoring and outreach automation pipelines.
- 🛠️ **Developers running scheduled data collection:** Automate repeated prospecting using `keywords` and export the updated **TikTok email finder** dataset on a schedule.
- 📣 **B2B and B2C campaign ops:** Run targeted **TikTok prospecting leads** for both B2B and B2C by adjusting your `keywords` and country filter.

***

### Technical specifications

- ✅ **Supported Input Formats**
  - `keywords` (array of strings)
  - `country` (string, selected from the provided list)
  - `maxLeadsPerKeyword` (integer)
  - `scrapeLeadsWithEmail` (boolean)

- ✅ **Proxy Support**
  - Uses proxy configurations for improved scraping reliability (built-in support is included).

- ✅ **Retry Mechanism**
  - Enrichment includes retry logic (up to **3** attempts per profile fetch).

- ✅ **Dataset Structure**
  - Dataset: **TikTok Leads Dataset**
  - View: **Scraped Leads**
  - Fields: `keyword`, `username`, `full_name`, `emails`, `profile_url`, `followers_count`, `following_count`, `video_count`, `likes_count`, `bio`, `is_verified`, `avatar_url`

- ✅ **Rate Limits & Performance**
  - Runs scrape and enrich profiles in batches; exact speed depends on web conditions and chosen settings.

- ✅ **Limitations**
  - If `scrapeLeadsWithEmail` is enabled, profiles without emails in their bios will be filtered out.
  - Free users have a global cap of **100 emails per run**.

***

### FAQ

#### ✅ Is “TikTok Leads Generator - B2B & B2C Email Finder (Free 100 Emails)” free?

Yes—there is a free tier. For free users, the run is capped at **100 emails total per run**, even if you request more via `maxLeadsPerKeyword`.

#### ✅ What inputs do I need to start scraping TikTok leads?

You must provide `keywords` (an array). You can also optionally set `country`, `maxLeadsPerKeyword`, and enable `scrapeLeadsWithEmail` to return only profiles with a public email address in their bio.

#### ✅ Does the actor require any login or special API keys?

No login is required for the actor’s interface beyond using Apify Console to run the actor. You only provide the `input.json` settings in the UI.

#### ✅ What data does the actor return for each TikTok profile?

Each saved dataset row includes `keyword`, `username`, `full_name`, `emails`, `profile_url`, follower and engagement metrics (`followers_count`, `following_count`, `video_count`, `likes_count`), plus `bio`, `is_verified`, and `avatar_url`.

#### ✅ Can I export the results after the run?

Yes. The actor saves leads into the **Scraped Leads** dataset, which you can export from the Apify UI (for example, JSON/CSV).

#### ❌ Does it return profiles without emails?

By default (`scrapeLeadsWithEmail: false`), it can include profiles even if emails aren’t present. If you enable `scrapeLeadsWithEmail`, it filters to profiles that have a public email address in their bio.

#### 💻 How would I use this in an automated lead pipeline?

You can run the actor with your chosen `keywords` and `country`, then export the dataset and push it into your CRM or data warehouse. The consistent field structure makes it suitable for analytics and outreach automation.

#### ⚖️ Is it legal to use scraped emails for outreach?

You’re responsible for ensuring compliance with applicable laws and platform policies (including GDPR/CCPA and spam regulations). This actor only helps you collect from publicly available sources; you must use the data responsibly.

***

### Support & feature requests

Want to improve **TikTok Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** or request enhancements for your **TikTok email finder** workflow?

- 💡 **Feature Requests:** For example, CSV export improvements, additional lead filtering options, or better formatting for CRM ingestion.
- 📧 **Contact:** Email <dataforleads@gmail.com>

We review feedback and use it to shape the roadmap for better TikTok lead generation tool experiences.

***

*If you’re serious about TikTok sales leads and need a reliable TikTok lead generation tool, **TikTok Leads Generator - B2B & B2C Email Finder (Free 100 Emails)** gives you structured results designed for speed and scale.*

***

### Disclaimer

**This actor accesses publicly available sources only.** It does not access private profiles, authenticated data, or password-protected pages. You are responsible for complying with applicable laws (including GDPR/CCPA), spam regulations, and platform Terms of Service.

For data removal requests, contact <dataforleads@gmail.com>. Always use this actor responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

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

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

Select the target country for leads.

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

Maximum number of leads to generate per keyword. Free users are capped at 100 emails total per run.

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

If enabled, only returns profiles that have a public email address in their bio.

## 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("scrapers-hub/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("scrapers-hub/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 scrapers-hub/mass-tiktok-leads-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapers-hub/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 find & capture high-intent TikTok leads at scale. 🧲 Automate prospecting, streamline outreach, and grow your pipeline faster—perfect for marketers, agencies, and B2B sales teams.",
        "version": "1.0",
        "x-build-id": "MZT6T02cg2kZflkH7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~mass-tiktok-leads-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-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/scrapers-hub~mass-tiktok-leads-generator/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-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/scrapers-hub~mass-tiktok-leads-generator/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-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": "Search 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": "Select the target country for leads.",
                        "default": "United States"
                    },
                    "maxLeadsPerKeyword": {
                        "title": "Max Leads Per Keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of leads to generate per keyword. Free users are capped at 100 emails total per run.",
                        "default": 20
                    },
                    "scrapeLeadsWithEmail": {
                        "title": "Only Scrape Leads With Email",
                        "type": "boolean",
                        "description": "If enabled, only returns profiles that have a public email address in their bio.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
