# Mass TikTok Email Scraper (`scrapebridge/tiktok-email-scraper`) Actor

TikTok Email Scraper extracts publicly available business email addresses and contact details from TikTok profiles. Ideal for lead generation, influencer outreach, B2B marketing, and market research by collecting contact info shared in bios, links, and public profile data.

- **URL**: https://apify.com/scrapebridge/tiktok-email-scraper.md
- **Developed by:** [Scrape Bridge](https://apify.com/scrapebridge) (community)
- **Categories:** Lead generation, Social media, Other
- **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 Email Scraper 🚀

Finding emails from TikTok profiles for outreach is frustrating—contact details are often hidden or inconsistent across bios and posts. **TikTok Email Scraper** fixes that by scraping email addresses from publicly available TikTok bios and posts using your chosen keywords and email-domain filters. If you’re looking for a TikTok email scraper for emails, or a TikTok email harvesting tool to build lead lists faster, this actor is designed for you. It’s built for influencer marketers, outreach teams, and researchers who need contact data without manual copy-pasting. In one run, you can collect up to `maxEmails` matching emails (with results appearing as they’re found), then export your dataset for downstream work.

---

### See the Data: Sample Output

Here’s a real record from a single run:

```json
{
  "network": "TikTok.com",
  "keyword": "founder",
  "title": "Example TikTok profile or page title",
  "description": "Example snippet text that may contain a contact email address.",
  "url": "https://example.com/page",
  "email": "hello@gmail.com",
  "proxyGroups": ["GOOGLE_SERP"]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for your lead data exports. |
| `keyword` | string | Which keyword was used when the email was found, useful for relevance tracking and reporting. |
| `title` | string | The page title associated with the extracted email, helpful for context while reviewing leads. |
| `description` | string | The text snippet where the email was detected—useful for validation and QA. |
| `url` | string | The page URL tied to the email so you can trace where each contact came from. |
| `email` | string | The extracted email address your team can use for outreach. |
| `proxyGroups` | array | The proxy configuration used during the scrape run (primarily useful for internal debugging/traceability). |
| `status` | (not present) | The actor pushes records using `Actor.push_data`; there is no `status` field in the pushed object. |

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": ["founder", "marketing"],
  "location": "",
  "platform": "TikTok",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for. The scraper uses these keywords to find relevant TikTok bios and posts tied to your terms. |
| `location` | ⬜ | An optional location filter to narrow results. Leave empty to scrape without location filtering. |
| `platform` | ⬜ | Platform selection. This actor supports `TikTok` (default is `TikTok`). |
| `customDomains` | ⬜ | Filters emails by specific email domains (for example `@gmail.com`) to reduce noise and improve targeting. |
| `maxEmails` | ⬜ | Maximum number of emails to collect. The run stops once this limit is reached (higher values may take longer and don’t guarantee reaching the cap). |
| `engine` | ⬜ | Chooses scraping engine. Only `legacy` is available in the schema shown here. |
| `proxyConfiguration` | ⬜ | Proxy settings for this Actor run (configure this if you need custom proxy behavior). |

***

### What It Does

TikTok Email Scraper scrapes emails from publicly available TikTok profile bios and posts that match your keyword and domain filters.

#### Keyword-driven email finding

You provide `keywords`, and the actor looks for matching content related to those terms. This makes it easy to run a TikTok outreach email list scraper approach without manually browsing profiles one by one.

#### Domain filtering for cleaner leads

Use `customDomains` to focus on specific email domains (such as `@gmail.com`). This helps reduce irrelevant results—useful when you need a targeted TikTok contact email extractor rather than a raw dump.

#### Clear, integration-ready dataset records

Each discovered email is pushed as a JSON record containing fields like `email`, `url`, `title`, and `description`. That makes the TikTok email finder output straightforward to validate and import into a CRM or spreadsheet.

#### Stops safely at your collection cap

The actor collects emails up to `maxEmails` and stops when the limit is reached. This keeps TikTok email lead scraper tool runs predictable for budgets and timelines.

#### Built-in resilience for longer jobs

For larger searches or higher email limits, runs may take longer; the actor supports resilience for complex runs through run options like longer timeouts. If results seem low, the actor description recommends rerunning with broader keywords and more related domains.

Overall, TikTok Email Scraper helps you extract influencer emails from TikTok at scale with structured output you can act on immediately.

***

### Why TikTok Email Scraper?

There are plenty of ways to pull contact data from TikTok—here’s why TikTok Email Scraper stands out.

#### Better targeting from day one

With `keywords` and `customDomains`, TikTok Email Scraper is built to return emails that match your outreach criteria (instead of “everything everywhere”). That’s a big win when you’re building a TikTok email harvesting tool list where relevance matters.

#### Results are written as they’re found

The actor pushes each discovered record into your dataset as it’s collected, so you can monitor progress and stop when you’ve got enough leads. This reduces wasted time compared to “wait until the end” scraping workflows.

#### Designed for batch outreach work

TikTok Email Scraper is made for bulk lead generation email scraper style workflows—run it, export the dataset, and plug it into your downstream tooling. It’s a practical TikTok email extraction service option for marketers and researchers who need volume.

***

### Real-World Use Cases

Here’s how different teams put TikTok Email Scraper to work:

**Outreach & Sales Teams**\
A sales team has a list of creator niches (e.g., “founder”, “marketing”) and wants business emails for cold outreach. They run TikTok Email Scraper with domain filters to keep results usable, then export the dataset for import into their outreach platform. The outcome is a faster path from TikTok research to first-contact.

**Influencer Marketing Managers**\
An influencer manager is building a short list for campaigns and needs verified-looking email leads alongside the source context. They use the scraped `url`, `title`, and `description` fields to quickly review each lead before adding it to the campaign CRM. This reduces time spent manually checking where the email came from.

**Marketing Analysts & Data Researchers**\
A researcher wants to quantify how often emails appear in bios/posts tied to certain themes. They run TikTok Email Scraper for multiple keyword sets and analyze the resulting dataset structure—email, keyword, and snippet context included. The outcome is a dataset they can analyze without building a custom scraping pipeline.

**Automation & Integration Specialists**\
An automation engineer wants TikTok lead generation email scraper results to flow into a data warehouse. They schedule or trigger actor runs, then ingest the exported dataset records into their pipeline for deduping and scoring. The consistent JSON output (including `email` and source `url`) makes integration simpler.

**Freelance Researchers**\
A freelancer is delivering outreach lists for clients with specific email domain preferences. They use `customDomains` to match the client’s targeting rules, cap results using `maxEmails` for predictable turnaround, and export in the format the client needs. The deliverable becomes more accurate and faster to review.

***

### How to Run It

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

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

2. **Enter your inputs**\
   Add your `keywords` (required). Optionally set `customDomains`, `location`, and `maxEmails` to control targeting and volume.

3. **Configure proxy settings (optional)**\
   If you use proxies in your workflows, set `proxyConfiguration`. This helps keep scraping reliable for larger jobs.

4. **Start the run and watch the live log**\
   Click **Run** and monitor progress in the actor logs while it collects matching emails.

5. **Open the Dataset tab**\
   As results are found, the actor pushes records into your dataset so you can verify emails using the included `url`, `title`, and `description`.

6. **Export in your preferred format**\
   Download your dataset from the Apify dashboard as JSON, CSV, or Excel and send it to your CRM or spreadsheet.

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

***

### Export & Integration Options

Once your data is collected, TikTok Email Scraper fits directly into your existing workflow. Export your dataset from the Apify dashboard as JSON, CSV, or Excel.

For systems integration, you can connect results using Apify’s native dataset access and automation options like Zapier or Make. If you build custom pipelines, you can retrieve results programmatically via the Apify API, and optionally trigger downstream tasks with webhooks when a run completes. You can also schedule runs so the TikTok email scraper runs automatically on a recurring basis.

***

### Pricing

TikTok Email Scraper runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier includes **$5 platform credits on sign-up**, which is enough for several real test runs. Runs afterwards are typically pay-as-you-go based on Apify Actor compute units (CU), with subscription plans available for heavier workloads. Start free at [apify.com](https://apify.com) — scale up when you need.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Pagination-style searching over time | Continues collecting results across pages until it hits your `maxEmails` cap or the run logic stops due to conditions like empty results. |
| Proxy configuration | You can provide `proxyConfiguration` to control how the actor runs via proxies. |
| Duplicate emails | The actor tracks already seen emails to avoid pushing duplicates. |
| Progress persistence | The actor persists progress using a key-value store while scraping proceeds. |

Limitations: TikTok Email Scraper can only extract emails from publicly available data present in TikTok bios and posts related to your keywords. It won’t access login-gated or private content, so some profiles may not yield any email addresses. For best outcomes with a TikTok email extraction service workflow, use specific keywords and appropriate `customDomains`.

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 sign-up credits, which should be enough for several test runs of TikTok Email Scraper.

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

No. This actor scrapes email addresses from publicly available TikTok content, so it doesn’t require a TikTok account login.

#### How accurate is the extracted data?

The actor extracts email addresses that appear in the publicly available content it processes and returns them as-is in the `email` field. Accuracy depends on what the profile owner has published in bios or posts.

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

You can control the maximum collected emails using the `maxEmails` input. The actor stops when the limit is reached, and it does not guarantee that the exact number will always be reached depending on available matching data.

#### How fresh is the data?

It’s as fresh as the publicly available content at the time the run executes. If profiles update their bios or posts, you’ll get different results on subsequent runs.

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

You should treat this as a tool for collecting publicly available data only. You are responsible for compliance with GDPR, CCPA, platform terms, and applicable email outreach laws in your region.

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

Yes. You can export from the Apify dashboard as JSON, CSV, or Excel, which you can then import into Google Sheets or other tools.

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

Yes. You can schedule Actor runs on Apify to automate repeated TikTok email scraper jobs using your chosen inputs.

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

Yes. Apify supports accessing actor run results programmatically via the Apify API, and dataset records pushed by TikTok Email Scraper can be retrieved from there.

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

If scraping encounters issues, it follows the actor run’s built-in behavior and continues collecting what it can while respecting the collection cap. Records that are successfully found are pushed to the dataset as the run proceeds.

***

### Get Help & Use Responsibly

Got a question about TikTok Email Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and ideas like expanding keyword targeting and improving lead-cleaning workflows.

**TikTok Email Scraper accesses publicly available data** and does not access private accounts, login-gated pages, or password-protected content. You’re responsible for complying with GDPR, CCPA, platform ToS, and any applicable outreach and privacy regulations 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`):

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "TikTok",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebridge/tiktok-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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapebridge/tiktok-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": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scrapebridge/tiktok-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass TikTok Email Scraper",
        "description": "TikTok Email Scraper extracts publicly available business email addresses and contact details from TikTok profiles. Ideal for lead generation, influencer outreach, B2B marketing, and market research by collecting contact info shared in bios, links, and public profile data.",
        "version": "0.0",
        "x-build-id": "Ap49QJxau2pSfIf5O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebridge~tiktok-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebridge-tiktok-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-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebridge-tiktok-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-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebridge-tiktok-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": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "TikTok"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "TikTok"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
