# YouTube Comment Scraper | Extract YT Video Comments Data (`code-node-tools/youtube-comments-scraper`) Actor

Scrape YouTube comments effortlessly with our YT comments scraper. Extract comments from videos, channels & playlists with sentiment analysis, advanced filters & export options. This YouTube video comment scraper bypasses API limits. Ideal for researchers, marketers & data analysts. Start scraping!

- **URL**: https://apify.com/code-node-tools/youtube-comments-scraper.md
- **Developed by:** [CodeNodeTools](https://apify.com/code-node-tools) (community)
- **Categories:** Social media, Videos, Developer tools
- **Stats:** 44 total users, 5 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 4.23 out of 5 stars

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 - Scrape YouTube Comments Fast & Easy

**The most powerful YouTube comment scraper to scrape YouTube comments from videos, channels, and playlists.** Extract YT comments with sentiment analysis, language detection, and advanced filtering. No YouTube API key required!

### 🚀 Why Use This YouTube Video Comment Scraper?

- **No API Key Required** - Scrape YouTube comments without YouTube Data API quotas or restrictions
- **Scrape from Multiple Sources** - Extract comments from individual videos, entire channels, or playlists
- **Advanced Filtering** - Filter by keywords, likes, authors, dates, and more
- **Sentiment Analysis** - Automatically analyze comment sentiment (positive/negative/neutral)
- **Language Detection** - Identify comment languages automatically
- **Fast & Reliable** - Built on yt-dlp, the most reliable YouTube extraction tool
- **Proxy Support** - Built-in Apify proxy rotation to avoid rate limiting
- **Structured Data** - Get clean JSON or CSV output ready for analysis

### 📊 What Can You Scrape?

This YT comments scraper extracts comprehensive data from every comment:

- Comment text and ID
- Author name, ID, and profile picture
- Like count and reply count
- Timestamp and relative time
- Verified status and channel owner status
- Video metadata (title, channel, views, etc.)
- Sentiment analysis (optional)
- Language detection (optional)
- Reply threads (optional)

### 🎯 Use Cases for YouTube Comment Scraping

- **Market Research** - Analyze customer feedback and opinions
- **Sentiment Analysis** - Understand audience reactions to content
- **Competitor Analysis** - Monitor competitor video engagement
- **Content Strategy** - Identify trending topics and audience interests
- **Academic Research** - Collect data for social media studies
- **Brand Monitoring** - Track brand mentions and sentiment
- **Influencer Analysis** - Evaluate influencer engagement quality

### 🔧 How to Scrape YouTube Comments

#### Input Options

**1. Scrape Comments from Videos**

```json
{
  "inputType": "video",
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/watch?v=jNQXAC9IVRw"
  ],
  "maxCommentsPerVideo": 1000
}
````

**2. Scrape Comments from Channels**

```json
{
  "inputType": "channel",
  "channelUrls": ["https://www.youtube.com/@MrBeast", "@TechReviewer"],
  "videoLimit": 10
}
```

**3. Scrape Comments from Playlists**

```json
{
  "inputType": "playlist",
  "playlistUrls": [
    "https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf"
  ]
}
```

#### Advanced Filtering

**Filter by Keywords**

```json
{
  "searchKeywords": ["amazing", "love this", "tutorial"],
  "excludeKeywords": ["spam", "bot", "scam"]
}
```

**Filter by Engagement**

```json
{
  "minCommentLikes": 10,
  "minVideoViews": 10000
}
```

**Comment Sorting**

```json
{
  "commentSortBy": "top",
  "includeReplies": true,
  "maxRepliesPerComment": 50
}
```

#### Enable Analysis Features

```json
{
  "extractSentiment": true,
  "detectLanguage": true
}
```

### 📤 Output Format

#### Individual Comment Example

```json
{
  "comment_id": "UgzX1234567890",
  "video_id": "dQw4w9WgXcQ",
  "video_title": "Rick Astley - Never Gonna Give You Up",
  "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "video_channel": "Official Rick Astley",
  "video_channel_id": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "text": "This is the best song ever! Never gets old 🎵",
  "author": "JohnDoe123",
  "author_id": "UCabcdefghijklmnop",
  "author_thumbnail": "https://yt3.ggpht.com/...",
  "author_is_verified": false,
  "author_is_uploader": false,
  "like_count": 1247,
  "reply_count": 23,
  "timestamp": "2025-01-15T10:30:00Z",
  "time_text": "2 weeks ago",
  "is_reply": false,
  "parent_comment_id": null,
  "sentiment": {
    "label": "positive",
    "score": 0.92
  },
  "language": "en",
  "scraped_at": "2025-01-15T12:00:00Z"
}
```

### ⚙️ Configuration Options

| Parameter              | Type    | Description                                    |
| ---------------------- | ------- | ---------------------------------------------- |
| `inputType`            | string  | Source type: "video", "channel", or "playlist" |
| `videoUrls`            | array   | YouTube video URLs or IDs                      |
| `channelUrls`          | array   | YouTube channel URLs or handles                |
| `playlistUrls`         | array   | YouTube playlist URLs or IDs                   |
| `videoLimit`           | integer | Max videos to process from channel/playlist    |
| `maxCommentsPerVideo`  | integer | Max comments per video                         |
| `commentSortBy`        | string  | "top" or "new"                                 |
| `includeReplies`       | boolean | Extract comment replies                        |
| `maxRepliesPerComment` | integer | Max replies per comment                        |
| `minCommentLikes`      | integer | Minimum likes filter                           |
| `searchKeywords`       | array   | Include only comments with these keywords      |
| `excludeKeywords`      | array   | Exclude comments with these keywords           |
| `minVideoViews`        | integer | Minimum video views filter                     |
| `extractSentiment`     | boolean | Enable sentiment analysis                      |
| `detectLanguage`       | boolean | Enable language detection                      |
| `useProxy`             | boolean | Use Apify proxies (recommended)                |
| `maxConcurrency`       | integer | Parallel processing (1-5)                      |

### 🎓 Tips for Best Results

1. **Use Proxies** - Enable proxy support to avoid rate limiting
2. **Start Small** - Test with a few videos before scaling up
3. **Filter Strategically** - Use keyword filters to get relevant comments
4. **Sort by Top** - Get the most engaging comments first
5. **Include Replies** - Capture full conversation threads
6. **Enable Sentiment** - Understand comment tone automatically
7. **Limit Concurrency** - Use 2-3 concurrent requests to avoid blocks

### 🔍 SEO Keywords

This actor helps you:

- Scrape YouTube comments efficiently
- Extract YT comments without API limits
- YouTube video comment scraper for data analysis
- Bulk YouTube comment extraction
- YouTube comments data mining
- Social media sentiment analysis
- YouTube engagement metrics

### 🛠️ Technical Details

- **Built with**: Python, yt-dlp, Apify SDK
- **No API Key**: Works without YouTube Data API
- **Proxy Support**: Built-in residential proxy rotation
- **Rate Limiting**: Automatic request throttling
- **Error Handling**: Robust retry logic
- **Output Formats**: JSON, CSV

### 📝 Common Questions

**Q: Do I need a YouTube API key?**
A: No! This scraper works without any API keys or quotas.

**Q: Can I scrape comments from private videos?**
A: No, only public videos are supported.

**Q: How many comments can I scrape?**
A: There's no hard limit, but use reasonable limits to avoid rate limiting.

**Q: Does it work with age-restricted videos?**
A: Some age-restricted videos may not be accessible.

**Q: Can I scrape comment replies?**
A: Yes! Enable `includeReplies: true` to get full conversation threads.

**Q: How accurate is sentiment analysis?**
A: The sentiment analysis uses VADER, which is ~80% accurate for social media text.

### 🚀 Getting Started

1. Click "Try for free" or "Buy" to add this actor to your account
2. Configure your input (video URLs, channels, or playlists)
3. Set your filters and options
4. Click "Start" and wait for results
5. Download your data as JSON or CSV

### 💡 Example Use Cases

#### Market Research

Scrape comments from competitor videos to understand customer pain points and desires.

#### Content Strategy

Analyze top comments on viral videos to identify trending topics and audience interests.

#### Brand Monitoring

Track mentions of your brand across YouTube and analyze sentiment.

#### Academic Research

Collect large-scale comment data for social media and communication studies.

#### Influencer Vetting

Evaluate comment quality and engagement on influencer videos before partnerships.

### 📊 Performance

- **Speed**: ~100-500 comments per minute (depending on video)
- **Reliability**: 99%+ success rate on public videos
- **Scalability**: Process thousands of videos in a single run

### 🔗 Related Actors

- YouTube Video Scraper
- YouTube Channel Scraper
- Instagram Comments Scraper
- TikTok Comments Scraper

### 📞 Support

Need help? Contact us through:

- Apify Console support chat
- GitHub issues
- Email support

### 📄 License

This actor is provided as-is for data extraction purposes. Please respect YouTube's Terms of Service and robots.txt. Use responsibly and ethically.

***

**Start scraping YouTube comments today!** No API key required, no quotas, no limits. Get the data you need for analysis, research, and insights.

**Keywords**: youtube comment scraper, scrape youtube comments, yt comments scraper, youtube video comment scraper, extract youtube comments, youtube comments data, youtube sentiment analysis, youtube engagement metrics

# Actor input Schema

## `inputType` (type: `string`):

What to scrape comments from

## `videoUrls` (type: `array`):

YouTube video URLs or IDs to scrape comments from

## `channelUrls` (type: `array`):

YouTube channel URLs or IDs (e.g., @MrBeast or channel ID)

## `playlistUrls` (type: `array`):

YouTube playlist URLs or IDs

## `videoLimit` (type: `integer`):

Maximum videos to process from channel/playlist (leave empty for all)

## `maxCommentsPerVideo` (type: `integer`):

Maximum comments to extract per video (leave empty for all)

## `commentSortBy` (type: `string`):

How to sort comments

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

Extract replies to comments

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

Maximum replies per comment (leave empty for all)

## `minCommentLikes` (type: `integer`):

Only extract comments with at least this many likes

## `searchKeywords` (type: `array`):

Only extract comments containing these keywords

## `excludeKeywords` (type: `array`):

Exclude comments containing these keywords

## `minVideoViews` (type: `integer`):

Only scrape comments from videos with at least this many views

## `useProxy` (type: `boolean`):

Use Apify residential proxies (recommended to avoid rate limiting)

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

Proxy settings

## `maxConcurrency` (type: `integer`):

Number of videos to process in parallel

## `extractSentiment` (type: `boolean`):

Perform sentiment analysis (positive/negative/neutral)

## `detectLanguage` (type: `boolean`):

Auto-detect comment language

## `includeVideoMetadata` (type: `boolean`):

Include video title, channel, views, etc.

## Actor input object example

```json
{
  "inputType": "video",
  "videoUrls": [
    "https://www.youtube.com/watch?v=jNQXAC9IVRw"
  ],
  "commentSortBy": "top",
  "includeReplies": true,
  "minCommentLikes": 0,
  "minVideoViews": 0,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 2,
  "extractSentiment": false,
  "detectLanguage": false,
  "includeVideoMetadata": true
}
```

# Actor output Schema

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

All scraped YouTube comments

## `summary` (type: `string`):

Scraping summary and statistics

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("code-node-tools/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 = {
    "videoUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("code-node-tools/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 '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=jNQXAC9IVRw"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call code-node-tools/youtube-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Comment Scraper | Extract YT Video Comments Data",
        "description": "Scrape YouTube comments effortlessly with our YT comments scraper. Extract comments from videos, channels & playlists with sentiment analysis, advanced filters & export options. This YouTube video comment scraper bypasses API limits. Ideal for researchers, marketers & data analysts. Start scraping!",
        "version": "0.0",
        "x-build-id": "RYgTqoWFuTyQIVesY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/code-node-tools~youtube-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-code-node-tools-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/code-node-tools~youtube-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-code-node-tools-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/code-node-tools~youtube-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-code-node-tools-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": [
                    "inputType"
                ],
                "properties": {
                    "inputType": {
                        "title": "Input Type",
                        "enum": [
                            "video",
                            "channel",
                            "playlist"
                        ],
                        "type": "string",
                        "description": "What to scrape comments from",
                        "default": "video"
                    },
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "YouTube video URLs or IDs to scrape comments from",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelUrls": {
                        "title": "Channel URLs",
                        "type": "array",
                        "description": "YouTube channel URLs or IDs (e.g., @MrBeast or channel ID)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "playlistUrls": {
                        "title": "Playlist URLs",
                        "type": "array",
                        "description": "YouTube playlist URLs or IDs",
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoLimit": {
                        "title": "Video Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum videos to process from channel/playlist (leave empty for all)"
                    },
                    "maxCommentsPerVideo": {
                        "title": "Max Comments Per Video",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum comments to extract per video (leave empty for all)"
                    },
                    "commentSortBy": {
                        "title": "Comment Sort Order",
                        "enum": [
                            "top",
                            "new"
                        ],
                        "type": "string",
                        "description": "How to sort comments",
                        "default": "top"
                    },
                    "includeReplies": {
                        "title": "Include Replies",
                        "type": "boolean",
                        "description": "Extract replies to comments",
                        "default": true
                    },
                    "maxRepliesPerComment": {
                        "title": "Max Replies Per Comment",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum replies per comment (leave empty for all)"
                    },
                    "minCommentLikes": {
                        "title": "Minimum Comment Likes",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only extract comments with at least this many likes",
                        "default": 0
                    },
                    "searchKeywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Only extract comments containing these keywords",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude Keywords",
                        "type": "array",
                        "description": "Exclude comments containing these keywords",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minVideoViews": {
                        "title": "Minimum Video Views",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only scrape comments from videos with at least this many views",
                        "default": 0
                    },
                    "useProxy": {
                        "title": "Use Proxy",
                        "type": "boolean",
                        "description": "Use Apify residential proxies (recommended to avoid rate limiting)",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings"
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of videos to process in parallel",
                        "default": 2
                    },
                    "extractSentiment": {
                        "title": "Extract Sentiment",
                        "type": "boolean",
                        "description": "Perform sentiment analysis (positive/negative/neutral)",
                        "default": false
                    },
                    "detectLanguage": {
                        "title": "Detect Language",
                        "type": "boolean",
                        "description": "Auto-detect comment language",
                        "default": false
                    },
                    "includeVideoMetadata": {
                        "title": "Include Video Metadata",
                        "type": "boolean",
                        "description": "Include video title, channel, views, etc.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```