# TikTok Creator Email Finder (`nexgendata/tiktok-creator-email-finder`) Actor

Scrape public TikTok creator profiles for business contact emails (bio + link-in-bio) for influencer/creator outreach.

- **URL**: https://apify.com/nexgendata/tiktok-creator-email-finder.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 creator profile scanneds

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 Creator Email Finder — MX-Verified Business Emails for Influencer Outreach

Build influencer-outreach lists in minutes. Give this actor a list of TikTok `@handles` (or profile URLs) and it returns one clean record per creator — name, followers, likes, category, verified status, region — plus the creator's **published business contact email**, pulled from both the **bio** and the **link-in-bio** (Linktree, Beacons, personal site), and **MX-verified** before it lands in your dataset. No login, no TikTok API key, no manual profile-by-profile copy-paste. Optional one-run delivery straight to your **Notion CRM**.

### 📊 Sample Output

[![TikTok Creator Email Finder sample output — public TikTok creator profiles enriched with MX-verified business contact emails, follower counts, category, and email source (bio or link-in-bio) for influencer outreach and creator lead generation](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/tiktok-creator-email-sample)](https://apify.com/nexgendata/tiktok-creator-email-finder?fpr=2ayu9b)

Real creators returned by this actor — every email below was **MX-verified** in the same run:

| Creator | Followers | Category | Verified Business Email | Source |
|---|---|---|---|---|
| @mrbeast | 128.5M | Shopping & Retail | chucky@mrbeastbusiness.com | link-in-bio |
| @dudewipes | 403.2K | Shopping & Retail | help@dudeproducts.com | link-in-bio |
| @washingtonpost | 2.0M | Media & Entertainment | universe@washpost.com | bio |

> Two of the three emails above were only reachable by **resolving the link-in-bio** — a pure bio-regex scraper would have missed them. The actor pulls the inline-bio email *and* follows Linktree/Beacons/website links to find the address the creator actually publishes for business.

### ⚖️ vs the alternatives

| | NexGenData TikTok Creator Email Finder | scraper-mind (category leader) | jurassic_jove |
|---|---|---|---|
| Email source | **Bio + link-in-bio (Linktree / Beacons / website)** | Bio scrape | Bio + website visit |
| Email validation | **MX-verified** (real mail server, not just regex) | Regex match | Regex match |
| One-run CRM delivery | **Built-in Notion connector** | No | No |
| Login / API key | **None** | None | None |
| Pricing model | Flat per-profile, emails included | ~$0.01 / profile | $0.02 / profile |
| Output | Flat typed fields, ready for outreach | Profile fields | Profile + email |

Most teams pick this actor not because it's the cheapest per-profile line item, but because the emails are **MX-verified** (your outreach list isn't full of dead addresses), it resolves the **link-in-bio** (where most creators actually park their business email), and it can drop the whole enriched list straight into your **Notion CRM** in one run. It's a quality + workflow bundle, not a race to the bottom.

### What you get

Per creator, a flat, typed record:

- **Identity** — `handle`, `name` (nickname), `user_id`, `profile_url`, `avatar_url`
- **Audience** — `followers`, `following`, `likes`, `video_count`
- **Classification** — `category`, `verified` (blue check), `region`
- **Bio** — `bio`, `bio_link`, `bio_link_type` (`linktree` / `beacons` / `personal-site` / `none`)
- **Contact** — `emails[]` (all addresses found), `primary_email`, `email_source` (`bio` / `bio_link` / `none`), `email_verified` (MX check)
- **Status** — `status` (`ok` / `no_email` / error), `scraped_at`

### Sample inputs

**1. Enrich a hand-picked creator list**
```json
{ "handles": ["@gymshark", "@mrbeast", "@dudewipes"], "maxProfiles": 50 }
````

**2. Bio-only (skip link-in-bio resolution for the fastest run)**

```json
{ "handles": ["@washingtonpost", "@nasa"], "followBioLinks": false, "maxProfiles": 25 }
```

**3. Enrich and deliver straight to your Notion CRM**

```json
{ "handles": ["@gymshark", "@gordonramsay"], "maxProfiles": 100, "notionConnector": "your-notion-mcp-connector" }
```

### 📄 Sample record (JSON)

One representative record straight from a live run:

```json
{
  "handle": "mrbeast",
  "name": "MrBeast",
  "user_id": "6614519312189947909",
  "bio": "Watch my latest video! 👇",
  "bio_link": "https://youtu.be/GpQSUjNsNm0",
  "bio_link_type": "personal-site",
  "followers": 128500000,
  "following": 351,
  "likes": 1300000000,
  "video_count": 458,
  "category": "Shopping & Retail",
  "verified": true,
  "region": null,
  "profile_url": "https://www.tiktok.com/@mrbeast",
  "emails": ["chucky@mrbeastbusiness.com"],
  "primary_email": "chucky@mrbeastbusiness.com",
  "email_source": "bio_link",
  "email_verified": true,
  "status": "ok",
  "scraped_at": "2026-06-14T20:23:44Z"
}
```

### ⚙️ How it works

1. **Embedded-JSON parse** — each profile is fetched through Apify **residential** proxy (TikTok hard-blocks datacenter IPs) in a headless browser with images, media, fonts, and CSS blocked. The actor reads the profile fields straight from the page's **embedded JSON** — no brittle DOM scraping, low compute.
2. **Bio regex + deobfuscation** — it scans the bio for email addresses, including common obfuscations creators use to dodge bots (`name [at] domain [dot] com`, spaced/character-swapped variants), and normalizes them back to real addresses.
3. **Link-in-bio resolution** — when there's no inline-bio email but the profile has a link-in-bio, the actor resolves that page (Linktree, Beacons, or the creator's own site) and extracts emails from it. This is where most creators actually publish their business contact, so it materially raises yield. (Toggle off with `followBioLinks: false`.)
4. **MX verification** — every candidate email is checked against the domain's real mail servers (MX records) before it's marked `email_verified: true`, so your outreach list isn't full of typo'd or dead addresses.

### 📈 Yield — set the right expectation

Not every creator publishes a reachable business email — that's a property of TikTok, not the scraper. In practice roughly **30–50%** of scanned creators have a reachable, MX-verified business email (bio or link-in-bio); the rest come back with `status: no_email`. You pay the **flat per-profile rate** for every profile scanned, and the **emails are included at no extra charge** — you're never billed extra for a hit. Profiles with no published email still return full audience + category data, which is useful on its own.

### 💰 Pricing example

- **Actor start:** $0.02
- **Per profile scanned:** $0.025 (flat — emails included, no per-email surcharge)

A **100-profile run = $0.02 + (100 × $0.025) = $2.52**. A quick 25-profile test = $0.645. No monthly minimum, no seats, no per-email upcharge. You pay for profiles scanned, whether or not each one publishes an email.

### ⚖️ Legal & ToS

This actor reads **only public TikTok creator profiles** and the **business contact emails creators themselves publish** in their bio or link-in-bio for exactly this purpose — to be contacted by brands and agencies. It does not access private account data, DMs, or anything behind authentication, and it does not harvest personal/consumer emails. The intended use case is **B2B influencer outreach** — reaching creators who have invited business contact. You are responsible for using the output in line with TikTok's terms, anti-spam laws (e.g. CAN-SPAM, GDPR), and your local regulations.

### 🔗 Related Actors

Pair this with the rest of the NexGenData lead-gen & outreach stack:

- [📍 Google Maps Extractor — Local Business Data](https://apify.com/nexgendata/google-maps-extractor?fpr=2ayu9b) — pull business locations, ratings, and contact data at scale
- [🎯 B2B Leads Finder — Apollo / ZoomInfo Alternative](https://apify.com/nexgendata/b2b-leads-finder?fpr=2ayu9b) — build targeted prospect lists by industry, geo, and tech stack
- [✉️ Website Email Extractor — Crawl & Find Emails](https://apify.com/nexgendata/website-email-extractor?fpr=2ayu9b) — extract verified emails from any list of websites
- [🗂️ Leads to Notion CRM — Auto-Sync Pipeline](https://apify.com/nexgendata/leads-to-notion-crm?fpr=2ayu9b) — push scraped records straight into a Notion CRM
- 🏢 **About NexGenData** — we maintain 260+ production Apify actors for lead-gen, competitive intelligence, and web data. Browse the full catalog at [apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b).

### ❓ FAQ

**Q: Do I need a TikTok login or API key?**
A: No. The actor works entirely off public creator profiles — no login, no app review, no access token.

**Q: Where do the emails come from?**
A: Two places: the creator's **bio** (inline text, including obfuscated forms like `name [at] domain`) and their **link-in-bio** (Linktree, Beacons, or personal website). `email_source` tells you which one each email came from.

**Q: What does "MX-verified" actually mean?**
A: Before an email is marked `email_verified: true`, the actor checks that the domain has live mail-exchange (MX) records — i.e. a real mail server that can receive mail. This filters out typos and dead domains so your outreach bounces less. It does not send a test email.

**Q: Why did some creators come back with no email?**
A: They simply didn't publish a reachable business email in their bio or link-in-bio (`status: no_email`). Roughly 30–50% of creators publish one; the rest don't. You still get their full audience and category data.

**Q: Can results go straight into Notion?**
A: Yes — authorize a Notion MCP connector in Apify Console → Settings

# Actor input Schema

## `handles` (type: `array`):

A list of TikTok creators to enrich. Accepts @usernames, bare usernames, or full profile URLs (https://www.tiktok.com/@handle). The actor scrapes each public profile for a business contact email (bio + link-in-bio).

## `maxProfiles` (type: `integer`):

Hard limit on how many profiles are fetched. The actor stops the moment this is hit so compute stays predictable. Server-clamped to 500.

## `followBioLinks` (type: `boolean`):

When a profile has no inline bio email but does have a link-in-bio (Linktree, Beacons, personal site), resolve that page and extract emails from it. This materially raises yield. Leave on unless you only want bio emails.

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

Residential proxies are REQUIRED for the browser fallback tier (any challenged profile). The default Apify residential proxy works. The cheap HTTP profile tier additionally uses datacenter proxy automatically.

## `notionConnector` (type: `string`):

Optional. Connect your Notion workspace and the creators + emails are also written as a Notion page in the same run — the Actor never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here.

## `notionParentId` (type: `string`):

Optional. The Notion page ID to create the page under. If blank, Notion creates a private page at workspace root.

## Actor input object example

```json
{
  "handles": [
    "@gymshark",
    "@mrbeast"
  ],
  "maxProfiles": 10,
  "followBioLinks": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "handles": [
        "@gymshark",
        "@mrbeast"
    ],
    "maxProfiles": 10,
    "followBioLinks": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/tiktok-creator-email-finder").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 = {
    "handles": [
        "@gymshark",
        "@mrbeast",
    ],
    "maxProfiles": 10,
    "followBioLinks": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/tiktok-creator-email-finder").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 '{
  "handles": [
    "@gymshark",
    "@mrbeast"
  ],
  "maxProfiles": 10,
  "followBioLinks": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call nexgendata/tiktok-creator-email-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Creator Email Finder",
        "description": "Scrape public TikTok creator profiles for business contact emails (bio + link-in-bio) for influencer/creator outreach.",
        "version": "0.0",
        "x-build-id": "mPc84P8aTROFwErS2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~tiktok-creator-email-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-tiktok-creator-email-finder",
                "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/nexgendata~tiktok-creator-email-finder/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-tiktok-creator-email-finder",
                "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/nexgendata~tiktok-creator-email-finder/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-tiktok-creator-email-finder",
                "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",
                "properties": {
                    "handles": {
                        "title": "TikTok handles or profile URLs",
                        "type": "array",
                        "description": "A list of TikTok creators to enrich. Accepts @usernames, bare usernames, or full profile URLs (https://www.tiktok.com/@handle). The actor scrapes each public profile for a business contact email (bio + link-in-bio).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProfiles": {
                        "title": "Maximum profiles to scan (hard cap)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard limit on how many profiles are fetched. The actor stops the moment this is hit so compute stays predictable. Server-clamped to 500.",
                        "default": 50
                    },
                    "followBioLinks": {
                        "title": "Resolve link-in-bio for emails",
                        "type": "boolean",
                        "description": "When a profile has no inline bio email but does have a link-in-bio (Linktree, Beacons, personal site), resolve that page and extract emails from it. This materially raises yield. Leave on unless you only want bio emails.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies are REQUIRED for the browser fallback tier (any challenged profile). The default Apify residential proxy works. The cheap HTTP profile tier additionally uses datacenter proxy automatically.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "notionConnector": {
                        "title": "Deliver to Notion (optional)",
                        "type": "string",
                        "description": "Optional. Connect your Notion workspace and the creators + emails are also written as a Notion page in the same run — the Actor never sees your Notion credentials. Authorize a Notion MCP connector in Apify Console → Settings → API & Integrations, then select it here."
                    },
                    "notionParentId": {
                        "title": "Notion parent page ID (optional)",
                        "type": "string",
                        "description": "Optional. The Notion page ID to create the page under. If blank, Notion creates a private page at workspace root."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
