# Tiktok Profiles Email Scraper (`scrapebridge/tiktok-profiles-email-scraper`) Actor

TikTok Profiles Email Scraper extracts publicly available email addresses from TikTok profiles at scale. Collect emails, usernames, bios, follower counts, website links, and profile details for lead generation, outreach, influencer marketing, sales prospecting, and market research.

- **URL**: https://apify.com/scrapebridge/tiktok-profiles-email-scraper.md
- **Developed by:** [Scrape Bridge](https://apify.com/scrapebridge) (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 $3.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 Leads Generator - B2B & B2C Email Finder ⚡
Cold outreach dies when your prospecting list is “almost right” and you still need to manually hunt for emails from TikTok profiles. **TikTok Leads Generator - B2B & B2C Email Finder** helps you generate TikTok leads in bulk and returns contact emails (when available), so you can move faster from discovery to outreach. Use it for TikTok email finder, TikTok B2B lead generation, and TikTok influencer email lookup. It’s built for sales teams, marketing agencies, and researchers who want structured TikTok lead generation for email marketing without wasting hours per lead—getting results quickly in a single run.

---

### See the Data: Sample Output
Here's a real record from a single run:

```json
{
  "keyword": "marketing",
  "username": "marketingops_hq",
  "full_name": "Marketing Ops HQ",
  "emails": ["contact@marketingopshq.com"],
  "profile_url": "https://www.tiktok.com/@marketingops_hq",
  "followers_count": 48200,
  "following_count": 612,
  "video_count": 340,
  "likes_count": 128400,
  "bio": "We help brands scale growth 🚀 contact@marketingopshq.com",
  "is_verified": true,
  "avatar_url": "https://example.com/avatar_medium.jpg",
  "status": "success",
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which search keyword this lead matched, so you can segment your outreach lists. |
| `username` | string | The TikTok handle you can reference in your messaging or CRM. |
| `full_name` | string | Creator or brand name pulled from the profile details. |
| `emails` | array | The email address(es) found in the profile bio, ready for outreach workflows. |
| `profile_url` | string | Direct link back to the profile for validation and relationship-building. |
| `followers_count` | number | Audience size signal to prioritize high-potential TikTok leads generator targets. |
| `following_count` | number | Shows how broad the creator’s network is (useful for context). |
| `video_count` | number | Indicates how active the profile is and how established the account may be. |
| `likes_count` | number | Engagement proxy for sorting leads in your pipeline. |
| `bio` | string | Raw bio text for transparency and manual review when needed. |
| `is_verified` | boolean | Helps you flag accounts that appear verified on TikTok. |
| `avatar_url` | string | Lets you display a recognizable profile image inside tools or reports. |
| `status` | string | Run outcome indicator to make downstream handling easier. |
| `error_message` | string | Error details when something goes wrong (null on success). |

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

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

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

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for TikTok profiles (for example, “marketing”, “fitness”, or “real estate”). |
| `country` | ⬜ | Filters results to a target country. Leave empty for worldwide search. |
| `maxLeadsPerKeyword` | ⬜ | Sets the maximum number of leads to generate per keyword (1–100). |
| `scrapeLeadsWithEmail` | ⬜ | When enabled, only profiles containing email addresses in their bio are returned; when disabled, all matching profiles are returned. |

***

### What It Does

This actor searches TikTok profiles by your keywords and enriches them with publicly available contact details.

#### Keyword-driven TikTok lead generation

You provide `keywords`, and the actor processes each keyword to generate a lead list for your TikTok outreach email list or prospecting workflow. This makes it easy to build TikTok B2B lead generation and TikTok B2C lead generation segments without manual searching.

#### Email-focused mode for faster outreach

When `scrapeLeadsWithEmail` is enabled, the actor returns only profiles that contain email addresses in their bio. This gives you a more targeted TikTok email finder output for sales and marketing teams who want to skip “no email” profiles.

#### Clean, structured lead records

Each enriched lead record includes profile metadata and contact fields such as `profile_url`, `username`, `full_name`, `bio`, and `emails`. The dataset is designed so it’s ready for analysis, CRM import, or outreach list creation without you stitching data from multiple sources.

#### Handles profile enrichment in batches

The actor enriches profile data concurrently (with a controlled concurrency setting) to keep runs efficient when you have multiple keywords and higher lead counts. It’s built to support real prospecting workloads rather than one-off lookups.

#### Resilient execution with retries

If a profile fetch or enrichment attempt fails, the actor uses retries and continues processing other profiles. This helps reduce the “all or nothing” problem when generating TikTok leads generator datasets.

Overall, TikTok Leads Generator - B2B & B2C Email Finder turns keyword ideas into structured TikTok lead generation for email marketing—fast enough for day-to-day prospecting.

***

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

There are plenty of ways to pull data from social profiles—here's why TikTok Leads Generator - B2B & B2C Email Finder stands out.

#### Built for email outreach, not just discovery

With `scrapeLeadsWithEmail`, you can force the output to include only leads where email addresses appear in the bio. That means your TikTok influencer email lookup results are immediately more useful for outreach email list building.

#### Practical output fields for sorting and prioritizing

The actor returns `followers_count`, `likes_count`, `video_count`, `is_verified`, and `avatar_url` alongside `emails`. This lets you prioritize TikTok prospects for B2B TikTok lead generation email outreach instead of only collecting usernames.

#### Reliable enrichment workflow

The actor enriches profiles in batches and applies retries during profile fetching and parsing. When you’re building a TikTok contact email scraper dataset, this reduces friction and helps you keep progress even when individual profiles fail.

***

### Real-World Use Cases

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

**Sales Teams**\
A SDR team wants to build a fresh pipeline of TikTok leads generator prospects by niche (e.g., “marketing” and “real estate”). They run the actor with `scrapeLeadsWithEmail: true`, then import the resulting dataset into their CRM, so outreach messages go to leads with email addresses in their bio—reducing time wasted on dead ends.

**Marketing Agencies**\
An agency building TikTok prospecting tool lists for client campaigns needs fast lead discovery across multiple verticals. They run keyword batches, review `profile_url` and `bio` fields for relevance, and use `emails` to create ready-to-send outreach segments that align with their campaign targeting.

**Freelance Researchers**\
A researcher compiling influencer contact data wants consistent fields for analysis across accounts. They generate TikTok B2C lead generation results with a country filter and `maxLeadsPerKeyword`, then analyze follower and engagement metrics alongside the extracted email addresses.

**Data Engineers & Automations Specialists**\
An automation setup pulls results into a downstream workflow for enrichment and scoring. They trigger TikTok Leads Generator - B2B & B2C Email Finder, then use the exported dataset fields (`keyword`, `emails`, `followers_count`, `profile_url`, and more) to run scoring rules and deduplicate leads across runs.

**Creators and Community Managers**\
A community manager looking for partnership leads searches for niches relevant to their audience. They run TikTok email finder mode with email filtering enabled, then use the structured output to contact brands and collaborators directly using `emails` and verify context using `bio` and `profile_url`.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Go to the actor page on Apify**\
   Open the actor on Apify: [console.apify.com](https://console.apify.com).

2. **Enter your inputs**\
   Add your `keywords` (required). Optionally set `country`, `maxLeadsPerKeyword`, and `scrapeLeadsWithEmail`.

3. **Configure proxy settings (if needed)**\
   Use Apify’s proxy support for reliable scraping. You generally don’t need to change anything unless you have special networking requirements.

4. **Start the run and watch the live log**\
   The actor logs progress while it processes each keyword and enriches profiles.

5. **Open the Dataset tab to see live results**\
   You’ll see leads appear as they’re pushed to the dataset.

6. **Export your results**\
   Download as JSON, CSV, or Excel from the dataset tab to use in your outreach workflows.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

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

You can export your results (including `emails` and `profile_url`) from the Apify dashboard as JSON, CSV, or Excel. This is useful for importing TikTok outreach email list data into CRMs, spreadsheets, and reporting tools.

For automation and programmatic use, you can pull results via the Apify API and connect downstream actions using tools like Zapier/Make and webhooks. You can also schedule runs to refresh your TikTok lead generation for email marketing regularly.

***

### Pricing

TikTok Leads Generator - B2B & B2C Email Finder runs on Apify, which includes a free tier — no credit card needed to start. You can test with a few keywords and export a small dataset to validate email quality before scaling.

After the free tier, usage is billed based on Actor compute units (CU) on Apify, which is aligned with your workload rather than a fixed monthly fee lock-in. Start free at [apify.com](https://apify.com) — scale up when you need.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Rate-limiting pressure | Built-in request pacing and controlled concurrency during enrichment |
| Proxy reliability | Built-in proxy support for more reliable scraping |
| Profile fetch hiccups | Retries and fallbacks during enrichment attempts |
| Partial progress | Leads are written to the dataset as results are generated |
| Empty / missing emails | With `scrapeLeadsWithEmail` enabled, only profiles with emails in their bio are returned |

Limitations: this actor targets publicly available profile data and extracts what’s present in profile details (especially the bio for email addresses). Login-gated or non-public profiles aren’t accessible, and profiles without emails in their bio won’t appear in email-filtered output.

For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify offers a free tier with platform credits so you can run a few tests before committing to heavier scraping jobs.

#### Do I need to log in or create an account on TikTok?

No. The actor operates on publicly available profile data and does not require you to log into TikTok.

#### How accurate is the extracted email data?

Accuracy depends on what the profile owner has published. The actor extracts email addresses from publicly available bio text, so results reflect the content that’s actually present on the profile.

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

You control the size with `maxLeadsPerKeyword`, which supports values from 1 to 100. The actor processes each keyword independently using that limit.

#### How fresh is the data?

Data freshness depends on when TikTok profile information is accessible during the run. If you schedule recurring runs, you can refresh your TikTok sales leads email list regularly.

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

The actor works with publicly available data, but legal compliance depends on how you store and use the results. You’re responsible for complying with GDPR, CCPA, and platform Terms of Service.

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

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, and then import into Google Sheets or other tools.

#### Can I schedule this to run automatically?

Yes. You can schedule Apify runs (for example, via the Apify scheduler) to keep your TikTok data mining leads lists updated.

#### Can I access results via the API?

Yes. Apify provides API access so you can pull dataset results programmatically as part of your automation pipeline.

#### What happens when the actor encounters an error?

The actor uses retries and continues processing other profiles. If individual profiles fail enrichment, you’ll see the run progress in logs and the dataset will include successful results that were generated.

***

### Get Help & Use Responsibly

Got a question about TikTok Leads Generator - B2B & B2C Email Finder or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We welcome requests like adding new filtering options for outreach emails or improving dataset field coverage for TikTok influencer email lookup workflows.

**publicly available data** — the actor does not access private accounts, login-gated pages, or password-protected content. You are responsible for compliance with GDPR, CCPA, and platform ToS when using the results. 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("scrapebridge/tiktok-profiles-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "country": "United States",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapebridge/tiktok-profiles-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "country": "United States"
}' |
apify call scrapebridge/tiktok-profiles-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Profiles Email Scraper",
        "description": "TikTok Profiles Email Scraper extracts publicly available email addresses from TikTok profiles at scale. Collect emails, usernames, bios, follower counts, website links, and profile details for lead generation, outreach, influencer marketing, sales prospecting, and market research.",
        "version": "1.0",
        "x-build-id": "NjNRackljDcyI8xy3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebridge~tiktok-profiles-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebridge-tiktok-profiles-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapebridge~tiktok-profiles-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebridge-tiktok-profiles-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapebridge~tiktok-profiles-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebridge-tiktok-profiles-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
