# TikTok Competitor Engagement Leads (`piquant_hare/tiktok-competitor-engagement-leads`) Actor

Find creators who engage with your competitors on TikTok. Paste a competitor's profile URL and get a qualified lead list of creators who comment on their videos — complete with emails, follower counts, and engagement rates. Built for influencer marketing agencies, D2C brands & TikTok Shop sellers.

- **URL**: https://apify.com/piquant\_hare/tiktok-competitor-engagement-leads.md
- **Developed by:** [Barnabás Czifra](https://apify.com/piquant_hare) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / qualified creator lead

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Competitor Engagement Leads

**Paste a competitor's TikTok URL → get a list of creators who engage with their content, complete with their emails and the comments they left.**

### What does this actor do?

This actor turns a single competitor TikTok profile URL into a qualified creator-lead list. It finds the creators who actually comment on your competitor's videos, enriches their profiles with follower counts and contact details (email, link-in-bio, social links), captures the comments they left, and outputs a clean, outreach-ready dataset. Because the input is a **competitor**, not a generic keyword, every lead has already demonstrated interest in your category — warmer than a random search.

### Use cases

- **Influencer marketing agencies** — build campaign shortlists from creators engaging with a brand's competitors.
- **D2C brands** — find creators already interested in your competitor's products.
- **TikTok Shop sellers** — recruit affiliate creators who engage with competitor content.
- **Brand partnership / outreach teams** — assemble contactable lead lists with personalization context.

### How it works

A 4-stage pipeline:

1. **Fetch competitor videos** — collects the competitor's most recent videos (up to `maxVideos`).
2. **Scrape commenters** — extracts who commented on each video (up to `maxCommentsPerVideo`), deduplicates them, and tracks how often each person engaged.
3. **Enrich & filter profiles** — resolves each commenter's profile (follower count, bio, badges, bio email), then keeps only high-value leads (meets `minFollowers` and is contactable).
4. **Crawl link-in-bio** *(optional)* — for creators with a Linktree/Beacons/bio.link page but no email in their bio, visits the page to find emails, websites, and social links.

> **How the TikTok data is sourced:** Stages 1–3 delegate the raw TikTok scraping to maintained, battle-tested TikTok scraper Actors on the Apify Store, and this actor layers the lead-generation pipeline (dedup, qualification filtering, contact enrichment, lead output) on top. This keeps results reliable as TikTok changes, instead of fighting TikTok's anti-bot/login wall directly. Note that the upstream scrapers incur their own Apify usage cost in addition to this actor's Pay Per Event charges.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `competitorUrls` | array (required) | — | One or more TikTok profile URLs to analyze. |
| `maxVideos` | integer | 3 | Recent videos to scrape per competitor (1–50). |
| `maxCommentsPerVideo` | integer | 30 | Max comments to extract per video (10–500). |
| `minFollowers` | integer | 500 | Minimum follower count to qualify a creator (0–10,000,000). |
| `maxLeads` | integer | 10 | Stop after this many qualified leads per competitor, so the cost of a run is predictable. The default of 10 keeps a first/trial run cheap (~$2–3). Raise it (or set `0` for unlimited) for production runs to capture every qualified lead. |
| `maxCommentersToScreen` | integer | 0 | Optional cap on how many of the most-engaged commenters get screened in the profile stage (bounds cost on very large inputs). `0` means screen all unique commenters. |
| `onlyWithEmail` | boolean | false | Only output creators where an email was found. |
| `enrichLinkInBio` | boolean | true | Crawl link-in-bio pages to find more emails. |
| `includeEngagementRate` | boolean | false | Fetch several recent videos per qualified lead to estimate an engagement rate (adds cost, qualified leads only). When off (default), the engagement fields are left empty. The estimate is capped at 100%. |
| `bioKeywords` | array | `[]` | Only include creators whose bio contains one of these keywords. |
| `proxyConfiguration` | object | RESIDENTIAL | Proxy for this actor's own direct requests (e.g. link-in-bio enrichment). The upstream TikTok scrapers handle their own proxies. |

### Output data

One dataset row per qualified creator lead:

```json
{
  "username": "creator_handle",
  "displayName": "Creator Display Name",
  "profileUrl": "https://www.tiktok.com/@creator_handle",
  "profilePicUrl": "https://p16-sign-va.tiktokcdn.com/...",
  "followerCount": 45200,
  "followingCount": 312,
  "totalLikesReceived": 1200000,
  "videoCount": 234,
  "isVerified": false,
  "isBusinessAccount": true,
  "isPrivate": false,
  "bio": "Fitness creator 💪 | Collabs: creator@email.com | Based in LA",
  "bioEmail": "creator@email.com",
  "linkInBio": "https://linktr.ee/creator_handle",
  "linkInBioEmail": "creator.business@gmail.com",
  "primaryEmail": "creator@email.com",
  "additionalLinks": {
    "instagram": "https://instagram.com/creator_handle",
    "youtube": "https://youtube.com/@creator_handle",
    "website": "https://creatorbrand.com"
  },
  "engagementRate": 4.7,
  "avgVideoLikes": 2100,
  "avgVideoComments": 89,
  "competitorEngagement": {
    "competitorUrl": "https://www.tiktok.com/@brandname",
    "competitorUsername": "brandname",
    "videosCommentedOn": 3,
    "totalComments": 5,
    "sampleComments": [
      { "videoUrl": "https://www.tiktok.com/@brandname/video/123456", "commentText": "Love this product! 🔥", "commentLikes": 12 }
    ]
  },
  "scrapedAt": "2026-06-04T14:30:00.000Z",
  "dataSource": "tiktok-competitor-engagement-leads"
}
````

> **Note:** `engagementRate`, `avgVideoLikes`, and `avgVideoComments` are only populated when `includeEngagementRate` is enabled. On a default run they are returned as `null`.

Key fields:

- **`primaryEmail`** — the field to use for outreach. Set to `bioEmail` when present, otherwise `linkInBioEmail`.
- **`engagementRate`** — estimated `(avgVideoLikes + avgVideoComments) / followerCount * 100`, capped at 100%. Only populated when `includeEngagementRate` is enabled (otherwise `null`).
- **`sampleComments`** — up to 3 comments the creator left on the competitor, for personalized outreach.

### Pricing (Pay Per Event)

| Event | Price |
|---|---|
| Actor run started | **$0.50** per run |
| Qualified creator lead | **$0.20** per lead |

You are **never charged** for commenters that get filtered out (below `minFollowers`, no contact info, private without email, or skipped). You only pay for leads that pass every filter and get written to the dataset.

> **Example:** A default run (capped at 10 leads) costs about **$2–3** and returns ~10 real, contactable creator leads (~$0.22 per lead). Raise `maxLeads` for production runs to capture every qualified creator — 10–50× cheaper than Favikon/Modash monthly subscriptions.

### Tips for best results

- Pick competitors with **active comment sections** — that's where the leads come from.
- Set `minFollowers` to match your niche: the default of 500 captures micro-creators; raise it (e.g. 5,000+) for established creators.
- Use `bioKeywords` to narrow to relevant creators (e.g. `["fitness", "gym", "workout"]`).
- Leave `enrichLinkInBio` on to significantly improve email discovery.
- Turn on `onlyWithEmail` when you want a 100% contactable list (at the cost of volume).

### FAQ

**What about proxies / anti-blocking?** The actor delegates TikTok scraping to maintained upstream scrapers that handle their own proxies and anti-blocking, so you don't have to. The `proxyConfiguration` input only applies to this actor's own direct requests — mainly the optional link-in-bio enrichment — where residential proxies help but aren't strictly required.

**Why are some commenters filtered out?** Casual consumers below `minFollowers`, accounts with no way to contact them, and private accounts without a public email are removed so you only pay for usable leads.

**How accurate are the emails?** Emails are extracted only when creators publish them in their bio or link-in-bio page for business contact. We reject placeholders and invalid patterns, but always sanity-check before sending.

**Is this legal?** This actor extracts only publicly available data creators have intentionally shared. See the disclaimer below; you are responsible for compliant outreach.

### Integrations

Connect via Apify's built-in integrations: **Make, Zapier, n8n, Google Sheets**, and webhooks. Example workflow: *run weekly on a schedule → push new leads to a Google Sheet → trigger an outreach sequence in your email tool.*

***

#### Legal disclaimer

This actor extracts only publicly available data that creators have intentionally shared on their TikTok profiles (bios, link-in-bio pages). Emails are only extracted when creators have explicitly published them for business contact purposes. Users are responsible for complying with applicable laws (GDPR, CAN-SPAM, CASL) when contacting extracted leads. This actor does not access private data, bypass authentication, or violate TikTok's technical access controls beyond standard web browsing.

# Actor input Schema

## `competitorUrls` (type: `array`):

One or more TikTok profile URLs to analyze. Example: https://www.tiktok.com/@brandname

## `maxVideos` (type: `integer`):

How many of the competitor's most recent videos to scrape comments from. More videos = more leads but longer runtime and higher cost.

## `maxCommentsPerVideo` (type: `integer`):

Maximum number of comments to extract from each video. TikTok sorts by relevance, so top comments tend to be from more engaged/popular accounts.

## `minFollowers` (type: `integer`):

Only include creators with at least this many followers. Set to 1000+ to filter out casual consumers and focus on actual creators/businesses.

## `onlyWithEmail` (type: `boolean`):

If true, only output creators where an email was found (in bio or link-in-bio page). Reduces output size but ensures every lead is contactable.

## `enrichLinkInBio` (type: `boolean`):

If true, visit each qualified creator's link-in-bio page (Linktree, Beacons, etc.) to find email addresses not visible in the TikTok bio itself. Increases runtime but significantly improves email discovery rate.

## `includeEngagementRate` (type: `boolean`):

If true, fetch several recent videos per QUALIFIED lead to estimate an engagement rate (avg likes+comments / followers). Adds upstream scraping cost but only for qualified leads. When off, engagement fields are left empty and the run is cheaper. The estimate is capped at 100%.

## `maxCommentersToScreen` (type: `integer`):

Optional safety cap: only screen the top N most-engaged commenters (by how many of the competitor's videos they commented on) in the profile stage. Bounds cost on very large inputs. 0 means screen all unique commenters.

## `maxLeads` (type: `integer`):

Stop after this many qualified leads per competitor, so the cost of a run is predictable. The default of 10 keeps a first/trial run cheap (~$2-3). RAISE THIS (or set 0 for unlimited) for production runs to capture every qualified lead.

## `bioKeywords` (type: `array`):

Only include creators whose bio contains at least one of these keywords. Useful for niche filtering. Example: \['fitness', 'gym', 'workout']. Leave empty to include all.

## `proxyConfiguration` (type: `object`):

Residential proxies are REQUIRED for TikTok. Datacenter proxies will be blocked immediately.

## Actor input object example

```json
{
  "competitorUrls": [
    "https://www.tiktok.com/@elfyeahuk"
  ],
  "maxVideos": 3,
  "maxCommentsPerVideo": 30,
  "minFollowers": 500,
  "onlyWithEmail": false,
  "enrichLinkInBio": true,
  "includeEngagementRate": false,
  "maxCommentersToScreen": 0,
  "maxLeads": 10,
  "bioKeywords": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `leads` (type: `string`):

One row per qualified creator lead (default dataset).

# 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 = {
    "competitorUrls": [
        "https://www.tiktok.com/@elfyeahuk"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("piquant_hare/tiktok-competitor-engagement-leads").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 = {
    "competitorUrls": ["https://www.tiktok.com/@elfyeahuk"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("piquant_hare/tiktok-competitor-engagement-leads").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 '{
  "competitorUrls": [
    "https://www.tiktok.com/@elfyeahuk"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call piquant_hare/tiktok-competitor-engagement-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Competitor Engagement Leads",
        "description": "Find creators who engage with your competitors on TikTok. Paste a competitor's profile URL and get a qualified lead list of creators who comment on their videos — complete with emails, follower counts, and engagement rates. Built for influencer marketing agencies, D2C brands & TikTok Shop sellers.",
        "version": "0.1",
        "x-build-id": "eqeN6NTthLDUSieDz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piquant_hare~tiktok-competitor-engagement-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piquant_hare-tiktok-competitor-engagement-leads",
                "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/piquant_hare~tiktok-competitor-engagement-leads/runs": {
            "post": {
                "operationId": "runs-sync-piquant_hare-tiktok-competitor-engagement-leads",
                "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/piquant_hare~tiktok-competitor-engagement-leads/run-sync": {
            "post": {
                "operationId": "run-sync-piquant_hare-tiktok-competitor-engagement-leads",
                "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": [
                    "competitorUrls"
                ],
                "properties": {
                    "competitorUrls": {
                        "title": "Competitor TikTok profile URLs",
                        "type": "array",
                        "description": "One or more TikTok profile URLs to analyze. Example: https://www.tiktok.com/@brandname",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "Max videos to analyze per competitor",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many of the competitor's most recent videos to scrape comments from. More videos = more leads but longer runtime and higher cost.",
                        "default": 3
                    },
                    "maxCommentsPerVideo": {
                        "title": "Max comments to scrape per video",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of comments to extract from each video. TikTok sorts by relevance, so top comments tend to be from more engaged/popular accounts.",
                        "default": 30
                    },
                    "minFollowers": {
                        "title": "Minimum follower count",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Only include creators with at least this many followers. Set to 1000+ to filter out casual consumers and focus on actual creators/businesses.",
                        "default": 500
                    },
                    "onlyWithEmail": {
                        "title": "Only include profiles with email",
                        "type": "boolean",
                        "description": "If true, only output creators where an email was found (in bio or link-in-bio page). Reduces output size but ensures every lead is contactable.",
                        "default": false
                    },
                    "enrichLinkInBio": {
                        "title": "Crawl link-in-bio pages for emails",
                        "type": "boolean",
                        "description": "If true, visit each qualified creator's link-in-bio page (Linktree, Beacons, etc.) to find email addresses not visible in the TikTok bio itself. Increases runtime but significantly improves email discovery rate.",
                        "default": true
                    },
                    "includeEngagementRate": {
                        "title": "Compute engagement rate (extra cost)",
                        "type": "boolean",
                        "description": "If true, fetch several recent videos per QUALIFIED lead to estimate an engagement rate (avg likes+comments / followers). Adds upstream scraping cost but only for qualified leads. When off, engagement fields are left empty and the run is cheaper. The estimate is capped at 100%.",
                        "default": false
                    },
                    "maxCommentersToScreen": {
                        "title": "Max commenters to screen (0 = no limit)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Optional safety cap: only screen the top N most-engaged commenters (by how many of the competitor's videos they commented on) in the profile stage. Bounds cost on very large inputs. 0 means screen all unique commenters.",
                        "default": 0
                    },
                    "maxLeads": {
                        "title": "Max qualified leads per competitor (0 = no limit)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many qualified leads per competitor, so the cost of a run is predictable. The default of 10 keeps a first/trial run cheap (~$2-3). RAISE THIS (or set 0 for unlimited) for production runs to capture every qualified lead.",
                        "default": 10
                    },
                    "bioKeywords": {
                        "title": "Bio keyword filter (optional)",
                        "type": "array",
                        "description": "Only include creators whose bio contains at least one of these keywords. Useful for niche filtering. Example: ['fitness', 'gym', 'workout']. Leave empty to include all.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are REQUIRED for TikTok. Datacenter proxies will be blocked immediately."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
