# TikTok Comments Scraper (`scrapebridge/tiktok-comments-scraper`) Actor

TikTok Comments Scraper extracts public comments, usernames, timestamps, likes, and engagement data from TikTok videos. Ideal for sentiment analysis, trend tracking, audience research, brand monitoring, and social media marketing insights to improve content and strategy.

- **URL**: https://apify.com/scrapebridge/tiktok-comments-scraper.md
- **Developed by:** [Scrape Bridge](https://apify.com/scrapebridge) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### TikTok Comments Scraper ⚡

Scraping TikTok video comments one by one is slow, inconsistent, and painful when you need a usable dataset fast. **TikTok Comments Scraper** collects comment data from TikTok videos in bulk and appends each result directly into your Apify dataset. If you’re building a TikTok comment downloader workflow, a TikTok comments extraction tool, or a dataset for TikTok comment analysis software, this is built for you. Marketers, data analysts, and researchers use it to collect TikTok comments at scale—turning minutes of manual work into results that start flowing within seconds of launch.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "videoWebUrl": "https://www.tiktok.com/@example_creator/video/7576465859598634258",
  "submittedVideoUrl": "https://www.tiktok.com/@example_creator/video/7576465859598634258",
  "input": "https://www.tiktok.com/@example_creator/video/7576465859598634258",
  "cid": "1234567890123456789",
  "createTime": 1717324800,
  "createTimeISO": "2024-06-02T12:00:00.000Z",
  "text": "Really enjoying this—what camera did you use? 😊",
  "diggCount": 248,
  "likedByAuthor": false,
  "pinnedByAuthor": false,
  "repliesToId": null,
  "replyCommentTotal": 7,
  "uid": "9876543210",
  "uniqueId": "example_fan",
  "avatarThumbnail": "https://example.com/avatar.jpg",
  "mentions": [],
  "detailedMentions": [],
  "status": "success"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `videoWebUrl` | string | The resolved canonical URL for the video the comment belongs to. |
| `submittedVideoUrl` | string | The exact TikTok URL you submitted for the run (handy for traceability). |
| `input` | string | The original input value used for processing this record. |
| `cid` | string | The comment identifier, useful for de-duplicating and updates. |
| `createTime` | number | Comment timestamp as a UNIX-style integer for analysis and sorting. |
| `createTimeISO` | string | Comment timestamp in ISO format for easy readability in BI tools. |
| `text` | string | The actual comment text you can use for moderation, coding, or sentiment analysis. |
| `diggCount` | number | Like count for prioritizing high-signal comments. |
| `likedByAuthor` | boolean | Whether the author (creator) has liked the comment. |
| `pinnedByAuthor` | boolean | Whether the comment is pinned by the creator. |
| `repliesToId` | string | null | If applicable, the ID of the comment being replied to. |
| `replyCommentTotal` | number | Total number of replies associated with the comment. |
| `uid` | string | User ID for the commenter (useful for joining with other datasets). |
| `uniqueId` | string | The commenter username. |
| `avatarThumbnail` | string | URL to the commenter’s avatar thumbnail. |
| `mentions` | array | Extracted mention texts found inside the comment. |
| `detailedMentions` | array | Structured mention data including IDs and character spans within the comment text. |
| `status` | string | Indicates the record outcome for easier QA during exports. |

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
{
  "postURLs": [
    "https://www.tiktok.com/@example_creator/video/7576465859598634258",
    "https://www.tiktok.com/@example_creator/video/7570000000000000000"
  ],
  "commentsPerPost": 100,
  "topLevelCommentsPerPost": 5,
  "maxRepliesPerComment": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `postURLs` | ✅ | A list of TikTok video URLs to scrape. You can provide single video links or user video URLs. |
| `commentsPerPost` | ⬜ | Sets the maximum number of comments to scrape per video. |
| `topLevelCommentsPerPost` | ⬜ | Sets the maximum number of top-level comments to scrape per video. |
| `maxRepliesPerComment` | ⬜ | Sets the maximum number of replies to scrape per comment. |

***

### What It Does

TikTok Comments Scraper scrapes comment data from the TikTok videos you provide and streams each result into your Apify dataset.

#### Scrape TikTok comments in bulk

You can pass multiple TikTok video URLs in `postURLs` and cap how much you want per video using `commentsPerPost`. This makes it practical to collect TikTok comments for a campaign, a research study, or a long-running analysis job.

#### Control comment and reply depth

Tune how many comments you collect per post and how deep you want to go with `topLevelCommentsPerPost` and `maxRepliesPerComment`. This is useful when you want a quick signal dataset first, then later run a deeper pass.

#### Clean, analysis-ready output for TikTok comment analysis software

Each scraped comment is output with consistent fields like `text`, `createTimeISO`, `diggCount`, `uniqueId`, and identifiers such as `cid`. Mentions are returned both as `mentions` (text) and `detailedMentions` (structured details), so downstream parsing is straightforward.

#### Live dataset appending as results arrive

Results are pushed one record at a time to the Apify dataset while processing videos. That means you can start exporting and validating without waiting for the entire batch to finish.

#### Built-in proxy support for reliable scraping

The actor includes proxy support to help with reliability when collecting public web data at scale. For larger batches or tighter schedules, this helps keep collection stable.

#### Handles errors gracefully during extraction

The run includes resilience behaviors when requests fail or time out, and it stops once it reaches your `commentsPerPost` cap. If a video finishes early (e.g., fewer comments returned), it logs progress and continues.

Overall, TikTok Comments Scraper turns comment extraction into a repeatable dataset pipeline—ideal for export TikTok comments workflows and bulk TikTok comments scraper use cases.

***

### Why TikTok Comments Scraper?

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

#### Dataset-first output that’s easy to validate

Instead of dumping everything at the end, TikTok Comments Scraper appends records into your Apify dataset as it works. That makes it easier to sanity-check fields like `text`, `createTimeISO`, and reply counts early.

#### Clear controls for comment volume

You can cap `commentsPerPost`, limit `topLevelCommentsPerPost`, and restrict `maxRepliesPerComment` to match your project scope. That keeps TikTok comments extraction tool runs fast and prevents unnecessary over-collection.

#### Built for dependable bulk runs

With built-in proxy support and request resilience, the actor is geared for repeated scraping runs. It’s a solid option for a TikTok comments API-style workflow—without you building scraping plumbing from scratch.

***

### Real-World Use Cases

Here's how different teams put TikTok Comments Scraper to work:

**Growth & Marketing Analysts**\
A team launches a new product and wants to monitor real audience reactions. They scrape TikTok comments from multiple relevant videos, export the dataset, and quickly identify recurring themes and high-engagement questions using `diggCount` and timestamped `text`.

**Influencer Campaign Managers**\
Campaign managers need to evaluate brand fit and audience quality across creator content. They run a bulk TikTok comments scraper on shortlisted videos, then filter for pinned or author-liked discussions using `pinnedByAuthor` and `likedByAuthor`.

**Customer Research Teams**\
Researchers want to turn raw audience conversation into actionable insights. They scrape TikTok user comments into a clean dataset, then analyze how often specific topics (including mentions) appear using `mentions` and `detailedMentions`.

**Data Engineers & Automation Specialists**\
A data engineer integrates comment collection into an internal pipeline. They schedule runs, pull results from the Apify dataset, and join `uniqueId`/`uid` fields with other sources for longitudinal analysis—using the same schema every time.

**Creators & Community Moderation**\
Moderation workflows benefit from structured review queues. They scrape comments from specific posts, export results, and prioritize review based on like counts and reply activity (`replyCommentTotal`).

***

### 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 Apify marketplace page (visit [console.apify.com](https://console.apify.com) and search for the actor).
2. **Enter your inputs** — add your TikTok video URLs in `postURLs`, then optionally set `commentsPerPost`, `topLevelCommentsPerPost`, and `maxRepliesPerComment`.
3. **Configure proxy settings (recommended)** — if you expect higher volume, enable proxy support in `proxyConfiguration` so your TikTok comments extraction tool runs stay reliable.
4. **Start the run** — launch and monitor the live logs to see progress per video.
5. **Open the Dataset tab** — results are appended as they’re scraped, so you can preview comment fields right away.
6. **Export your data** — download as JSON, CSV, or Excel from the dataset view.
7. **Iterate with updated caps** — adjust the comment/reply limits and rerun to refine your TikTok comment downloader dataset.

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

***

### Export & Integration Options

Once your data is collected, TikTok Comments Scraper fits directly into your existing workflow.

You can export your Apify dataset in the format you need (JSON, CSV, or Excel) from the dataset tab. For teams using spreadsheets or analysis tooling, this makes it easy to move from scrape TikTok comments to analyze results without reformatting.

If you automate reporting or data flows, you can access your collected results via Apify’s API patterns and trigger downstream steps after runs complete. No-code automations like Zapier/Make can also be used to push new datasets into other tools.

***

### Pricing

TikTok Comments Scraper runs on Apify, which includes a **free tier** — no credit card needed to start.

Free tier availability starts with **$5 platform credits on sign-up**, enough for several real test runs. For larger workloads, you’ll typically pay **pay-as-you-go** based on Apify compute usage (Actor compute units), plus whatever plan limits apply on your account. Start free at [apify.com](https://apify.com) — scale up when you need.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Request failures | Uses resilience logic and handles non-200 responses with retries. |
| Timeouts | Catches timeouts and continues with controlled delays. |
| Proxy reliability | Supports proxy configuration via `proxyConfiguration` for more stable runs. |
| Partial progress | Writes results as each comment is processed, so you don’t lose everything on interruption. |
| End-of-data behavior | Stops early when no more comments are returned. |
| User-controlled volume | You cap collection using `commentsPerPost`, `topLevelCommentsPerPost`, and `maxRepliesPerComment`. |

**Limitations:** The actor scrapes comments from publicly available sources that are accessible during the run. If a video returns fewer comments than expected, you’ll see early completion based on the returned data and your caps. For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify provides a free tier with monthly usage credits, and smaller scraping runs often fit within the free allowance.

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

No. This actor uses publicly available data from the videos you provide, so you don’t need a TikTok login for the run.

#### How accurate is the extracted data?

The output is based on what’s returned during extraction, including fields like `text`, `createTimeISO`, `diggCount`, and commenter identifiers such as `uniqueId` and `cid`. Accuracy depends on what the source content exposes publicly.

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

You control volume with `commentsPerPost` (maximum comments per post). You can also limit `topLevelCommentsPerPost` and `maxRepliesPerComment` to control how much reply content is included.

#### How fresh is the data?

The dataset is as fresh as the moment the actor processes each video. If you run again later, you’ll capture any newly available comments up to your caps.

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

The actor works with **publicly available data**, but whether your use is compliant (including GDPR/CCPA and platform terms) is your responsibility. Use the data lawfully and ethically for your specific purpose and jurisdiction.

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

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

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

Yes. In Apify, you can set scheduled runs for the actor so it executes automatically on a recurring schedule.

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

Yes. You can access collected results programmatically using Apify’s API capabilities for actors and datasets.

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

If requests fail or time out, it uses built-in resilience behaviors and continues processing with controlled delays. Results are appended during processing, so you still keep what was successfully collected.

***

### Get Help & Use Responsibly

Got a question about TikTok Comments Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to help with run setup and we actively maintain this actor based on user feedback—ideas like “export TikTok comments with additional normalization” and “better dataset QA fields” are always welcome.

**This actor collects only *publicly available data*.** It does not access private accounts, login-gated pages, or password-protected content. You’re responsible for GDPR, CCPA, and any applicable platform Terms of Service when using or storing the collected data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `postURLs` (type: `array`):

List of TikTok video URLs. Use single video URLs or user's video URLs.

## `commentsPerPost` (type: `integer`):

Maximum number of comments to scrape per video.

## `topLevelCommentsPerPost` (type: `integer`):

Maximum number of top-level comments to scrape per video.

## `maxRepliesPerComment` (type: `integer`):

Maximum number of replies to scrape per comment.

## Actor input object example

```json
{
  "postURLs": [
    {
      "url": "https://www.tiktok.com/@voicer_nayem_69/video/7576465859598634258"
    }
  ],
  "commentsPerPost": 100,
  "topLevelCommentsPerPost": 5,
  "maxRepliesPerComment": 0
}
```

# 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 = {
    "postURLs": [
        {
            "url": "https://www.tiktok.com/@voicer_nayem_69/video/7576465859598634258"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebridge/tiktok-comments-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 = { "postURLs": [{ "url": "https://www.tiktok.com/@voicer_nayem_69/video/7576465859598634258" }] }

# Run the Actor and wait for it to finish
run = client.actor("scrapebridge/tiktok-comments-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 '{
  "postURLs": [
    {
      "url": "https://www.tiktok.com/@voicer_nayem_69/video/7576465859598634258"
    }
  ]
}' |
apify call scrapebridge/tiktok-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Comments Scraper",
        "description": "TikTok Comments Scraper extracts public comments, usernames, timestamps, likes, and engagement data from TikTok videos. Ideal for sentiment analysis, trend tracking, audience research, brand monitoring, and social media marketing insights to improve content and strategy.",
        "version": "1.0",
        "x-build-id": "TrWCKATgVb0NOt7gX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebridge~tiktok-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebridge-tiktok-comments-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-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebridge-tiktok-comments-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-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebridge-tiktok-comments-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": [
                    "postURLs"
                ],
                "properties": {
                    "postURLs": {
                        "title": "TikTok video URLs",
                        "type": "array",
                        "description": "List of TikTok video URLs. Use single video URLs or user's video URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "commentsPerPost": {
                        "title": "Maximum comments per post",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of comments to scrape per video.",
                        "default": 100
                    },
                    "topLevelCommentsPerPost": {
                        "title": "Maximum top-level comments per post",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to scrape per video.",
                        "default": 5
                    },
                    "maxRepliesPerComment": {
                        "title": "Maximum replies per comment",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of replies to scrape per comment.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
