# TikTok Comments Scraper - Replies & Authors (`khadinakbar/tiktok-comments-scraper`) Actor

Scrape public TikTok video comments with replies, authors, likes, timestamps, pinned status, language, and source video URL. Provider-backed, no login or cookies required. MCP-ready and priced at $0.003 per top-level comment.

- **URL**: https://apify.com/khadinakbar/tiktok-comments-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, MCP servers, Videos
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 tiktok comments

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

Scrape public TikTok video comments with nested replies, author metadata, likes, language, pinned status, timestamps, and source video links. The actor is provider-backed with ScrapeCreators first and SociaVault fallback, so it does not need TikTok login cookies, browser sessions, or user-managed proxies.

### What It Extracts

One dataset row is one top-level TikTok comment. Replies are nested under that parent row so sentiment tools, spreadsheets, and AI agents keep the full conversation together.

| Field | Description |
| --- | --- |
| `comment_id` | Unique TikTok comment ID |
| `video_id` | TikTok video or aweme ID |
| `video_url` | Public TikTok video URL |
| `text` | Comment text |
| `author_username` | Commenter username |
| `author_nickname` | Commenter display name |
| `author_id` | Commenter numeric TikTok user ID |
| `author_sec_uid` | Commenter secUid when returned |
| `author_avatar_url` | Commenter avatar URL |
| `like_count` | Likes on the comment |
| `reply_count` | Total replies reported for the comment |
| `is_pinned` | Whether the video author pinned the comment |
| `language` | Detected comment language code |
| `created_at` | Comment creation timestamp |
| `replies` | Nested reply objects with text, author, likes, and timestamps |
| `provider` | Provider used for the row |
| `scraped_at` | Time the actor saved the row |

### When To Use

Use this actor for:

- TikTok sentiment analysis by video URL
- Brand monitoring and creator campaign analysis
- Influencer vetting from real audience replies
- Voice-of-customer research from public comment sections
- AI and BI pipelines that need one clean comment dataset
- Collecting reply threads without building a TikTok session stack

Do not use this actor for profile scraping, hashtag search, TikTok Shop reviews, transcripts, follower lists, private videos, or login-gated data. Use the matching TikTok actors in this portfolio for those workflows.

### Input

```json
{
  "postURLs": [
    "https://www.tiktok.com/@stoolpresidente/video/7623818255903329566"
  ],
  "maxCommentsPerPost": 10,
  "includeReplies": true,
  "maxRepliesPerComment": 5,
  "maxTotalComments": 100,
  "providerOrder": "scrapecreators-first"
}
````

#### Important Inputs

| Input | Default | Notes |
| --- | --- | --- |
| `postURLs` | example URL | Public TikTok video URLs to scrape |
| `maxCommentsPerPost` | `10` | Top-level comments per video. Set `0` for all available pages up to `maxPagesPerPost` |
| `maxTotalComments` | `100` | Run-wide spend and volume cap |
| `includeReplies` | `true` | Fetch nested replies under each comment |
| `maxRepliesPerComment` | `5` | Set `0` for all available replies up to `maxReplyPagesPerComment` |
| `maxPagesPerPost` | `5` | Comment pagination safety cap |
| `maxReplyPagesPerComment` | `3` | Reply pagination safety cap |
| `providerOrder` | `scrapecreators-first` | Provider routing for diagnostics or fallback |
| `trim` | `false` | Keep full provider fields by default so reply threads have stable parent comment IDs |
| `includeRawData` | `false` | Attach raw provider payloads for debugging |

### Output Example

```json
{
  "comment_id": "7623874021293212447",
  "video_id": "7623818255903329566",
  "video_url": "https://www.tiktok.com/@stoolpresidente/video/7623818255903329566",
  "text": "Brilliant",
  "author_username": "katylynnm",
  "author_nickname": "Katy",
  "author_id": "6813803505255154693",
  "author_sec_uid": "MS4wLjABAAAAGQCGrZCPx6snYndsBtuAIif17vTOTEfDZ9qd",
  "like_count": 3,
  "reply_count": 4,
  "is_pinned": false,
  "language": "en",
  "created_at": "2026-04-02T21:25:25.000Z",
  "replies": [
    {
      "reply_id": "7626007039458755350",
      "parent_comment_id": "7623874021293212447",
      "text": "oh, I liked it",
      "author_username": "kryptobuddy2",
      "author_nickname": "Carl Gauss",
      "like_count": 0,
      "created_at": "2026-04-09T07:35:45.000Z",
      "provider": "scrapecreators"
    }
  ],
  "provider": "scrapecreators",
  "provider_page": 1,
  "result_position": 1,
  "scraped_at": "2026-07-09T12:00:00.000Z",
  "source_url": "https://www.tiktok.com/@stoolpresidente/video/7623818255903329566"
}
```

### Pricing

This actor uses pay-per-event pricing.

| Event | Price |
| --- | ---: |
| Actor start | `$0.00005` |
| Top-level TikTok comment saved | `$0.003` |

Nested replies are included inside each top-level comment row and are not charged as separate comment events. At the start of each run, the status message shows the approximate maximum cost from your input caps.

### Reliability

The actor uses managed public-data providers:

1. ScrapeCreators for the primary TikTok comments and replies route.
2. SociaVault as fallback when the primary route errors, rate-limits, or returns no usable page.

The run writes `OUTPUT` and `RUN_SUMMARY` records with provider attempts, status codes, pages fetched, rows saved, replies saved, credits used, stop reason, and estimated PPE cost.

### API Example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/tiktok-comments-scraper').call({
  postURLs: ['https://www.tiktok.com/@stoolpresidente/video/7623818255903329566'],
  maxCommentsPerPost: 10,
  includeReplies: true,
  maxRepliesPerComment: 5
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### MCP And AI Agents

This actor is exposed through Apify MCP as `khadinakbar/tiktok-comments-scraper`. It is best for agents that need public TikTok comment rows from known video URLs. It returns compact, structured records and a machine-readable `RUN_SUMMARY` so agents can reason about empty results, provider fallback, and cost caps.

### Limits

- Public TikTok videos only.
- No private videos, login-gated content, or hidden profile data.
- Provider availability can affect very large or region-sensitive videos.
- `maxCommentsPerPost: 0` means all available pages up to `maxPagesPerPost`, not unlimited spend.
- Use `maxTotalComments` to cap total billed top-level comments across batches.

### Related Actors

- [TikTok Video Search Scraper](https://apify.com/khadinakbar/tiktok-video-search-scraper) for finding videos by keyword or hashtag.
- [TikTok Video Scraper](https://apify.com/khadinakbar/tiktok-video-scraper) for video metadata.
- [TikTok Transcript Scraper](https://apify.com/khadinakbar/tiktok-transcript-scraper) for spoken-audio transcripts.
- [TikTok Profile Videos Scraper](https://apify.com/khadinakbar/tiktok-profile-videos-scraper) for creator feeds.

### Legal

Use this actor only for public TikTok content you are allowed to access and process. You are responsible for complying with TikTok's Terms of Service, privacy laws, data protection rules, and any platform or jurisdiction-specific requirements. This actor does not access private accounts or login-gated content.

# Actor input Schema

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

Use this when you have public TikTok video links and need comment text, authors, likes, timestamps, and replies. Accepts full video URLs such as https://www.tiktok.com/@stoolpresidente/video/7623818255903329566. Add one or many URLs. Not for profile, hashtag, or shop review scraping.

## `maxCommentsPerPost` (type: `integer`):

Maximum top-level comments to save and charge for per video. Defaults to 10, ranges 0-100000. Set 0 to continue until TikTok/provider pagination ends or maxPagesPerPost is reached. Replies are nested under each charged top-level comment.

## `maxTotalComments` (type: `integer`):

Hard run-wide cap across all input videos. Defaults to 100, ranges 1-500000. Use this to control total spend when you pass many URLs or set maxCommentsPerPost to 0.

## `includeReplies` (type: `boolean`):

Fetch nested replies under each top-level comment. Defaults to true so sentiment and conversation context stay attached to the parent comment. Disable for faster, cheaper provider usage when you only need top-level comments.

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

Maximum nested replies to attach to each top-level comment. Defaults to 5, ranges 0-10000. Set 0 to collect all available replies up to maxReplyPagesPerComment. Replies are not billed as separate top-level comments.

## `maxPagesPerPost` (type: `integer`):

Safety cap for top-level comment pagination per video. Defaults to 5, ranges 1-500. Raise only when you expect large comment sections and have set a spend cap with maxTotalComments.

## `maxReplyPagesPerComment` (type: `integer`):

Safety cap for reply pagination under one comment. Defaults to 3, ranges 1-100. This prevents a single viral thread from consuming the whole run when maxRepliesPerComment is 0.

## `providerOrder` (type: `string`):

Choose the managed public-data provider order. Defaults to ScrapeCreators first, then SociaVault fallback. Use provider-only options for diagnostics. This is not a TikTok login, cookie, or proxy setting.

## `trim` (type: `boolean`):

Ask providers for a smaller response where supported. Defaults to false because full responses include stable comment IDs needed for reply threads. Set true only for top-level-only runs where you want smaller provider payloads.

## `includeRawData` (type: `boolean`):

Attach the raw provider comment and reply payloads to output rows for debugging. Defaults to false because raw TikTok payloads are large and harder for AI agents to read.

## Actor input object example

```json
{
  "postURLs": [
    "https://www.tiktok.com/@stoolpresidente/video/7623818255903329566"
  ],
  "maxCommentsPerPost": 10,
  "maxTotalComments": 100,
  "includeReplies": true,
  "maxRepliesPerComment": 5,
  "maxPagesPerPost": 5,
  "maxReplyPagesPerComment": 3,
  "providerOrder": "scrapecreators-first",
  "trim": false,
  "includeRawData": false
}
```

# Actor output Schema

## `comments` (type: `string`):

Top-level TikTok comments with author info, likes, reply counts, timestamps, provider, and nested replies when enabled.

## `runSummary` (type: `string`):

Run diagnostics, provider telemetry, counts, stop reason, and estimated PPE cost.

# 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": [
        "https://www.tiktok.com/@stoolpresidente/video/7623818255903329566"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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": ["https://www.tiktok.com/@stoolpresidente/video/7623818255903329566"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Comments Scraper - Replies & Authors",
        "description": "Scrape public TikTok video comments with replies, authors, likes, timestamps, pinned status, language, and source video URL. Provider-backed, no login or cookies required. MCP-ready and priced at $0.003 per top-level comment.",
        "version": "1.0",
        "x-build-id": "7liPj8HXtWvgBEeQ1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~tiktok-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~tiktok-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~tiktok-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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",
                "properties": {
                    "postURLs": {
                        "title": "TikTok video URLs",
                        "type": "array",
                        "description": "Use this when you have public TikTok video links and need comment text, authors, likes, timestamps, and replies. Accepts full video URLs such as https://www.tiktok.com/@stoolpresidente/video/7623818255903329566. Add one or many URLs. Not for profile, hashtag, or shop review scraping.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per video",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum top-level comments to save and charge for per video. Defaults to 10, ranges 0-100000. Set 0 to continue until TikTok/provider pagination ends or maxPagesPerPost is reached. Replies are nested under each charged top-level comment.",
                        "default": 10
                    },
                    "maxTotalComments": {
                        "title": "Max total comments",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Hard run-wide cap across all input videos. Defaults to 100, ranges 1-500000. Use this to control total spend when you pass many URLs or set maxCommentsPerPost to 0.",
                        "default": 100
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Fetch nested replies under each top-level comment. Defaults to true so sentiment and conversation context stay attached to the parent comment. Disable for faster, cheaper provider usage when you only need top-level comments.",
                        "default": true
                    },
                    "maxRepliesPerComment": {
                        "title": "Max replies per comment",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum nested replies to attach to each top-level comment. Defaults to 5, ranges 0-10000. Set 0 to collect all available replies up to maxReplyPagesPerComment. Replies are not billed as separate top-level comments.",
                        "default": 5
                    },
                    "maxPagesPerPost": {
                        "title": "Max comment pages per video",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety cap for top-level comment pagination per video. Defaults to 5, ranges 1-500. Raise only when you expect large comment sections and have set a spend cap with maxTotalComments.",
                        "default": 5
                    },
                    "maxReplyPagesPerComment": {
                        "title": "Max reply pages per comment",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for reply pagination under one comment. Defaults to 3, ranges 1-100. This prevents a single viral thread from consuming the whole run when maxRepliesPerComment is 0.",
                        "default": 3
                    },
                    "providerOrder": {
                        "title": "Data provider",
                        "enum": [
                            "scrapecreators-first",
                            "sociavault-first",
                            "scrapecreators-only",
                            "sociavault-only"
                        ],
                        "type": "string",
                        "description": "Choose the managed public-data provider order. Defaults to ScrapeCreators first, then SociaVault fallback. Use provider-only options for diagnostics. This is not a TikTok login, cookie, or proxy setting.",
                        "default": "scrapecreators-first"
                    },
                    "trim": {
                        "title": "Trim provider response",
                        "type": "boolean",
                        "description": "Ask providers for a smaller response where supported. Defaults to false because full responses include stable comment IDs needed for reply threads. Set true only for top-level-only runs where you want smaller provider payloads.",
                        "default": false
                    },
                    "includeRawData": {
                        "title": "Include raw provider data",
                        "type": "boolean",
                        "description": "Attach the raw provider comment and reply payloads to output rows for debugging. Defaults to false because raw TikTok payloads are large and harder for AI agents to read.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
