# YouTube Comments Scraper (`calm_builder/youtube-comments-scraper`) Actor

Collect comments and optional nested replies from public YouTube videos and Shorts links. Export clean, structured JSON with optional video and channel details for moderation, sentiment analysis, reporting, and research workflows.

- **URL**: https://apify.com/calm\_builder/youtube-comments-scraper.md
- **Developed by:** [Coder](https://apify.com/calm_builder) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 7 total users, 7 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 comments and level 1 replies

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## YouTube Comments Scraper

Collect comments from public YouTube videos and Shorts links, with optional channel details, video details, and nested replies.

This Actor is designed for comment-focused workflows. Provide one or more direct links, choose how much detail you want, and get one structured result record per input URL.

### What You Get

- Top-level comments from public YouTube videos and Shorts
- Optional replies up to level 1, 2, or 3
- Optional video details
- Optional channel details
- One clean dataset item per input link

### Good Fit For

- Audience feedback analysis
- Moderation and review workflows
- Campaign reporting
- Creator benchmarking
- Training datasets and internal analytics

### Supported Links

- Standard watch links
- Shorts links
- `youtu.be` short links

Example:

```text
https://www.youtube.com/watch?v=DXVHmGoCTco
https://www.youtube.com/shorts/oiZvK6MY7tI
https://youtu.be/p9jZXhYF6Zk
````

### Main Input Options

- `directUrls`
  One or more public YouTube video or Shorts links.
- `includeVideoDetails`
  Adds video-level metadata such as title, publish date, duration, counts, thumbnails, and availability flags.
- `includeChannelInfo`
  Adds channel-level metadata such as name, handle, URL, country, subscriber count, and avatar.
- `maxComments`
  Maximum number of top-level comments per link.
- `includeReplies`
  Enables reply collection.
- `replyLevel`
  Controls reply depth:
  - `1` = first-level replies only
  - `2` = first-level replies and replies to replies
  - `3` = up to three reply levels
- `maxRepliesPerLevel`
  Maximum number of replies collected at each level.
- `commentsSortBy`
  `top` or `newest`
- `commentsDateRangeDate`
  Optional date filter such as `7 days`, `30 days`, or `2026-01-01`

If a date range is provided, sorting is automatically handled in a way that best supports recent-comment filtering.

### Free Plan Limits

Free runs will be reduced automatically. Typical adjustments may include:

- fewer links per run
- lower comment limits
- lower reply limits
- first-level replies only

### Output Structure

Each dataset item represents one requested link.

Top-level fields:

- `inputUrl`
- `normalizedUrl`
- `videoId`
- `contentType`
- `status`
- `video`
- `channel`
- `comments`
- `summary`
- `error`
- `collectedAt`

#### `status` values

- `ok`
  Data was collected successfully.
- `no_comments`
  The item was available, but no public comments were returned.
- `invalid_input`
  The provided link was not a supported public YouTube video or Shorts URL.
- `failed`
  The item could not be completed during this run.

#### `comments` object

The `comments` object includes:

- `enabled`
- `sortBy`
- `dateRange`
- `maxReplyLevel`
- `topLevelCount`
- `replyCount`
- `level1ReplyCount`
- `level2ReplyCount`
- `level3ReplyCount`
- `threads`

Each comment or reply node may include:

- `id`
- `authorName`
- `authorChannelId`
- `authorUrl`
- `authorAvatarUrl`
- `text`
- `likeCount`
- `publishedAt`
- `publishedTimeText`
- `updatedAt`
- `updatedTimeText`
- `replyCount`
- `replyLevel`
- `replies`

### Detailed Example Output

```json
{
  "inputUrl": "https://www.youtube.com/watch?v=DXVHmGoCTco",
  "normalizedUrl": "https://www.youtube.com/watch?v=DXVHmGoCTco",
  "videoId": "DXVHmGoCTco",
  "contentType": "video",
  "status": "ok",
  "video": {
    "id": "DXVHmGoCTco",
    "title": "50 Streamers Fight for $1,000,000",
    "description": "i can't believe we got all these streamers together in one place lol",
    "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "channelTitle": "MrBeast",
    "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
    "publishDate": "2026-04-04T16:00:01Z",
    "durationSeconds": 2541,
    "viewCount": 59275120,
    "likeCount": 1855099,
    "commentCount": 125523,
    "thumbnailUrl": "https://i.ytimg.com/vi/DXVHmGoCTco/maxresdefault.jpg",
    "captionsAvailable": true,
    "embedUrl": "https://www.youtube.com/embed/DXVHmGoCTco",
    "privacyStatus": "public",
    "license": "youtube",
    "isEmbeddable": true,
    "isMadeForKids": false,
    "isLive": false,
    "isUpcoming": false
  },
  "channel": {
    "id": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "name": "MrBeast",
    "handle": "@mrbeast",
    "url": "https://www.youtube.com/@mrbeast",
    "country": "US",
    "subscriberCount": 475000000,
    "videoCountText": "963",
    "totalViewsText": "117006098406",
    "isVerified": true
  },
  "comments": {
    "enabled": true,
    "sortBy": "top",
    "dateRange": "",
    "maxReplyLevel": 3,
    "topLevelCount": 10,
    "replyCount": 120,
    "level1ReplyCount": 37,
    "level2ReplyCount": 28,
    "level3ReplyCount": 55,
    "threads": [
      {
        "id": "UgyCejUOAhJb3S9P5-Z4AaABAg",
        "authorName": "@ukitsethn",
        "authorChannelId": "UCd-2DgZGEwN9KxJOzj5F8wQ",
        "authorUrl": "http://www.youtube.com/@ukitsethn",
        "authorAvatarUrl": "https://yt3.ggpht.com/example-top-level-avatar=s48-c-k-c0x00ffffff-no-rj",
        "text": "i love how all of the comments hate on rakai lol",
        "likeCount": 2674,
        "publishedAt": "2026-04-07T07:10:55Z",
        "publishedTimeText": "9 hours ago",
        "updatedAt": "2026-04-07T07:10:55Z",
        "updatedTimeText": "9 hours ago",
        "replyCount": 6,
        "replyLevel": 0,
        "replies": [
          {
            "id": "UgyCejUOAhJb3S9P5-Z4AaABAg.AVI53eCZuvwAVICG6GRWWC",
            "authorName": "@Asdfasdf-k8v",
            "authorChannelId": "UCAwfNMtxlRgpRydAdrSbPPQ",
            "authorUrl": "https://www.youtube.com/@Asdfasdf-k8v",
            "authorAvatarUrl": "https://yt3.ggpht.com/example-reply-avatar=s88-c-k-c0x00ffffff-no-rj",
            "text": "In any good movie someone had to be the bad guy, and he played the role very well 😂",
            "likeCount": 10,
            "publishedAt": "2026-04-07T08:50:53.651383+00:00",
            "publishedTimeText": "8 hours ago",
            "updatedAt": null,
            "updatedTimeText": null,
            "replyCount": 2,
            "replyLevel": 1,
            "replies": [
              {
                "id": "UgyCejUOAhJb3S9P5-Z4AaABAg.AVI53eCZuvwAVIHZpahV0b",
                "authorName": "@TeslimFadimu",
                "authorChannelId": "UCCFc7zsbB1-qWHr2d3YjVvg",
                "authorUrl": "https://www.youtube.com/@TeslimFadimu",
                "authorAvatarUrl": "https://yt3.ggpht.com/example-level-2-avatar=s88-c-k-c0x00ffffff-no-rj",
                "text": "@Asdfasdf-k8v exactly I love him though",
                "likeCount": 6,
                "publishedAt": "2026-04-07T09:50:53.651420+00:00",
                "publishedTimeText": "7 hours ago",
                "updatedAt": null,
                "updatedTimeText": null,
                "replyCount": 1,
                "replyLevel": 2,
                "replies": [
                  {
                    "id": "UgyCejUOAhJb3S9P5-Z4AaABAg.AVI53eCZuvwAVJ4PWkNXdz",
                    "authorName": "@ErickZAZ",
                    "authorChannelId": "UC2Lpcda5fKyRBPksIBApViw",
                    "authorUrl": "https://www.youtube.com/@ErickZAZ",
                    "authorAvatarUrl": "https://yt3.ggpht.com/example-level-3-avatar=s88-c-k-c0x00ffffff-no-rj",
                    "text": "@TeslimFadimu naah",
                    "likeCount": 1,
                    "publishedAt": "2026-04-07T16:24:55.271708+00:00",
                    "publishedTimeText": "37 minutes ago",
                    "updatedAt": null,
                    "updatedTimeText": null,
                    "replyLevel": 3,
                    "replies": []
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  },
  "summary": {
    "commentsCollected": 10,
    "level1RepliesCollected": 37,
    "level2RepliesCollected": 28,
    "level3RepliesCollected": 55,
    "videoDetailsIncluded": true,
    "channelInfoIncluded": true
  },
  "error": null,
  "collectedAt": "2026-04-07T16:51:01.013189+00:00"
}
```

### Notes

- The Actor works with public YouTube videos and public Shorts links.
- Comment availability depends on the item itself. Some links may have no public comments.
- Some items may return partial metadata depending on public availability.
- The Actor continues processing valid links even if one item fails or is unsupported.

### How To Use

1. Add one or more YouTube video or Shorts links.
2. Choose whether you want video details and channel details.
3. Set your comment limit, reply depth, and reply limit.
4. Run the Actor.
5. Export the dataset in JSON, CSV, Excel, or use it directly through the Apify API.

# Actor input Schema

## `directUrls` (type: `array`):

Add one public YouTube video or Shorts link per row. Watch links, Shorts links, and `youtu.be` links are supported.

## `includeVideoDetails` (type: `boolean`):

Include public item details such as title, description, publish date, duration, thumbnails, statistics, and availability fields.

## `includeChannelInfo` (type: `boolean`):

Include public uploader channel information where available. Channel info is collected once per unique channel and reused across matching items.

## `maxComments` (type: `integer`):

Maximum number of top-level comments to collect for each provided link.

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

Collect replies for each top-level comment. Turn this off to return top-level comments only.

## `replyLevel` (type: `string`):

Choose how many reply levels to include for each comment thread. Level 1 is the fastest option. Higher levels may take longer on large threads.

## `maxRepliesPerLevel` (type: `integer`):

Maximum number of direct replies to collect at each reply level for every comment thread.

## `commentsSortBy` (type: `string`):

Choose how comments should be ordered. If a comments date range is set, sorting is automatically changed to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run.

## `commentsDateRangeDate` (type: `string`):

Optional publish-time filter for comments and replies. Use either an absolute date (`YYYY-MM-DD`) or a relative value such as `1 day`, `2 weeks`, `3 months`, or `1 year`. If set, comment sorting is automatically changed to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run. Leave empty to skip this filter.

## Actor input object example

```json
{
  "directUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/shorts/oiZvK6MY7tI"
  ],
  "includeVideoDetails": false,
  "includeChannelInfo": false,
  "maxComments": 10,
  "includeReplies": false,
  "replyLevel": "1",
  "maxRepliesPerLevel": 2,
  "commentsSortBy": "top",
  "commentsDateRangeDate": ""
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset items in full JSON format, ready for exports, API integrations, and automation workflows.

# 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 = {
    "directUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/shorts/oiZvK6MY7tI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("calm_builder/youtube-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 = { "directUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/shorts/oiZvK6MY7tI",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("calm_builder/youtube-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 '{
  "directUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/shorts/oiZvK6MY7tI"
  ]
}' |
apify call calm_builder/youtube-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Comments Scraper",
        "description": "Collect comments and optional nested replies from public YouTube videos and Shorts links. Export clean, structured JSON with optional video and channel details for moderation, sentiment analysis, reporting, and research workflows.",
        "version": "0.0",
        "x-build-id": "sOMTvbrcBarPxHT5C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/calm_builder~youtube-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-calm_builder-youtube-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/calm_builder~youtube-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-calm_builder-youtube-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/calm_builder~youtube-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-calm_builder-youtube-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": [
                    "directUrls",
                    "maxComments",
                    "includeReplies",
                    "replyLevel",
                    "maxRepliesPerLevel"
                ],
                "properties": {
                    "directUrls": {
                        "title": "YouTube video or Shorts links",
                        "type": "array",
                        "description": "Add one public YouTube video or Shorts link per row. Watch links, Shorts links, and `youtu.be` links are supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeVideoDetails": {
                        "title": "Add video or Shorts details",
                        "type": "boolean",
                        "description": "Include public item details such as title, description, publish date, duration, thumbnails, statistics, and availability fields.",
                        "default": false
                    },
                    "includeChannelInfo": {
                        "title": "Add channel info",
                        "type": "boolean",
                        "description": "Include public uploader channel information where available. Channel info is collected once per unique channel and reused across matching items.",
                        "default": false
                    },
                    "maxComments": {
                        "title": "Maximum comments per link",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to collect for each provided link.",
                        "default": 10
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Collect replies for each top-level comment. Turn this off to return top-level comments only.",
                        "default": false
                    },
                    "replyLevel": {
                        "title": "Maximum reply depth",
                        "enum": [
                            "1",
                            "2",
                            "3"
                        ],
                        "type": "string",
                        "description": "Choose how many reply levels to include for each comment thread. Level 1 is the fastest option. Higher levels may take longer on large threads.",
                        "default": "1"
                    },
                    "maxRepliesPerLevel": {
                        "title": "Maximum replies per level",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of direct replies to collect at each reply level for every comment thread.",
                        "default": 2
                    },
                    "commentsSortBy": {
                        "title": "Comments sort",
                        "enum": [
                            "top",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Choose how comments should be ordered. If a comments date range is set, sorting is automatically changed to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run.",
                        "default": "top"
                    },
                    "commentsDateRangeDate": {
                        "title": "Comments date range",
                        "pattern": "^$|^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional publish-time filter for comments and replies. Use either an absolute date (`YYYY-MM-DD`) or a relative value such as `1 day`, `2 weeks`, `3 months`, or `1 year`. If set, comment sorting is automatically changed to Newest. Very recent comments can take a short time to appear, so comments posted within roughly the last minute may occasionally be missed in the same run. Leave empty to skip this filter.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
