# YouTube Scraper + AI Comment Analyzer & Channel Audit (`buseta/youtube-scraper`) Actor

Scrape YouTube channels, videos, comments, transcripts, and search results. AI analyzes comments for viewer requests and sentiment, audits channel health with recommendations, and evaluates niche saturation with content gap analysis.

- **URL**: https://apify.com/buseta/youtube-scraper.md
- **Developed by:** [buseta](https://apify.com/buseta) (community)
- **Categories:** AI, Videos, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 video scrapeds

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 Scraper — Channels, Videos, Comments, Transcripts + AI Analysis

**All-in-one YouTube scraper with AI.** Built for content creators, marketers, researchers, and agencies. Scrape channels, search results, video details, comments, and transcripts — all in a single actor. Three AI features turn raw data into actionable intelligence: comment analysis, channel audit, and niche report.

Pure HTTP, no browser. 256MB memory. 4x cheaper comments than competitors.

### Why This Actor?

| Feature | This Actor |
|---------|------------|
| Price per video | **$0.004** |
| Price per comment | **$0.0005** — 4x cheaper than alternatives |
| Transcripts | **Included free** — others charge $0.005-0.01 |
| Business email | **Included free** — others charge $0.12/email |
| All-in-one | **Channels + search + comments + transcripts in one actor** |
| AI features | **Comment analysis + channel audit + niche report** |

### What You Get

#### Per Video
```json
{
    "video_id": "rWk3TjhaVHA",
    "title": "ASMR Addictive Tapping 1 Hr (No Talking)",
    "channel_title": "ASMR Bakery",
    "view_count": 12295594,
    "like_count": 159306,
    "dislike_count": 3200,
    "duration": "1:04:50",
    "duration_seconds": 3890,
    "tags": ["asmr", "asmr tapping", "tapping asmr", "no talking", ...],
    "category": "Entertainment",
    "is_short": false,
    "published_at": "2023-08-15",
    "comments": [...],
    "transcript": {"language": "en", "text": "..."}
}
````

#### Per Channel

```json
{
    "channel_id": "UC...",
    "channel_title": "ASMR Bakery",
    "subscriber_count": 4500000,
    "video_count": 850,
    "description": "...",
    "business_email": "contact@asmrbakery.com",
    "links": [{"title": "Instagram", "url": "..."}]
}
```

### 3 AI Features

#### 1. AI Comment Analyzer ($6/1,000 videos)

AI reads all comments on a video, extracts what viewers want, love, and complain about. Replaces hours of manually reading comment sections.

Pre-computes stats from ALL comments, sends top 200 by likes to AI for deep analysis.

```json
{
    "ai_sentiment": "positive",
    "ai_sentiment_score": 82,
    "ai_top_requests": [
        {"request": "Viewers want more glass tapping content with 3Dio mic", "frequency": "high"},
        {"request": "Multiple requests for a longer 3-hour version", "frequency": "medium"}
    ],
    "ai_top_complaints": [
        {"complaint": "Audio too quiet in the second half of the video", "frequency": "low"}
    ],
    "ai_highlights": ["Viewers describe this as their go-to sleep video, with many reporting falling asleep within minutes"],
    "ai_content_ideas": [
        {"idea": "Glass tapping ASMR with 3Dio mic — 3 hour version", "rationale": "Directly requested 12 times in comments, and glass tapping is trending this week"}
    ],
    "ai_audience_mood": "Loyal, engaged audience with strong emotional connection. Viewers frequently return to this video for sleep. High demand for longer versions and new trigger types."
}
```

#### 2. AI Channel Audit ($12/1,000 channels)

AI evaluates all scraped videos from a channel: what content works, what's declining, growth signals, and actionable recommendations. Like a $500 agency audit for $0.02.

```json
{
    "ai_health_score": 74,
    "ai_best_content": "Roleplay videos average 3x channel views. Tapping is the most consistent performer with steady engagement across all uploads.",
    "ai_declining_content": "Mukbang content dropped 60% in views over the last 3 months. Audience engagement on eating videos is significantly below channel average.",
    "ai_posting_consistency": "Uploads every 4-5 days on average, but gaps of 10+ days correlate with subscriber stalls.",
    "ai_growth_signal": "Subscriber growth is flat month-over-month. Shorts are underutilized — only 3 in the last 50 uploads.",
    "ai_strengths": ["Strong niche authority in roleplay ASMR", "High comment engagement — viewers feel personal connection"],
    "ai_weaknesses": ["No Shorts strategy to reach new audiences", "Declining content types not being retired"],
    "ai_recommendations": ["Double down on roleplay — highest ROI content type", "Post 1 Short per week clipped from long-form", "Drop or pivot mukbang format"]
}
```

#### 3. AI Niche Report ($2/1,000 videos in search)

AI analyzes all search results for a topic: how saturated is this niche, who dominates, where are the gaps, and is there opportunity for new creators?

```json
{
    "ai_saturation": "high",
    "ai_opportunity_score": 65,
    "ai_avg_performance": "Average video in this niche gets 125K views. Top performers break 2M regularly.",
    "ai_top_performers": [{"channel": "ASMR Bakery", "why": "Dominates with 40% of top results. Consistent quality and upload schedule."}],
    "ai_content_gaps": ["No one is combining tapping with rain sounds", "Glass tapping is underserved relative to search demand"],
    "ai_rising_topics": ["Layered tapping with multiple textures is gaining traction"],
    "ai_recommendations": ["Focus on glass or ceramic tapping — high demand, low competition", "3+ hour compilations perform well in this niche"],
    "ai_verdict": "Saturated niche overall, but clear gaps exist in sub-categories. Glass tapping and layered sounds have high search demand with few quality creators covering them."
}
```

### How to Use

#### Scrape a Channel

```json
{
    "scrape_type": "channel",
    "channel_urls": ["https://www.youtube.com/@MrBeast"],
    "max_videos": 50,
    "get_comments": true,
    "max_comments": 100,
    "get_transcript": true,
    "get_channel_about": true,
    "ai_channel_audit": true,
    "ai_comment_analysis": true
}
```

#### Search YouTube

```json
{
    "scrape_type": "search",
    "search_query": "python tutorial 2025",
    "max_videos": 30,
    "get_comments": true,
    "max_comments": 50,
    "ai_niche_report": true
}
```

#### Scrape Specific Videos

```json
{
    "scrape_type": "video_urls",
    "video_urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/watch?v=..."
    ],
    "get_comments": true,
    "max_comments": 200,
    "get_transcript": true,
    "ai_comment_analysis": true
}
```

### Pricing

| Event | Price | What You Get |
|-------|-------|-------------|
| Video scraped | **$4.00 / 1,000** | Title, views, likes, dislikes, tags, duration, description, thumbnail |
| Comment scraped | **$0.50 / 1,000** | Author, text, likes, published date, reply count |
| Channel scraped | **$5.00 / 1,000** | Name, subscribers, video count, about page, business email, links |
| AI Comment Analysis | **$6.00 / 1,000** | Sentiment, top requests, complaints, content ideas, audience mood |
| AI Channel Audit | **$12.00 / 1,000** | Health score, best/declining content, growth signals, recommendations |
| AI Niche Report | **$2.00 / 1,000** | Saturation, opportunity score, content gaps, top performers, verdict |
| Platform usage | Free | |

#### Typical Run Costs

| Use Case | Items | AI | Total |
|----------|-------|----|-------|
| Quick channel check (20 videos) | $0.08 + $0.005 | — | **$0.09** |
| Channel + comments + AI audit (50 videos, 100 comments each) | $0.20 + $2.50 + $0.005 | $0.30 + $0.012 | **$3.02** |
| Niche research (30 search results) | $0.12 | $0.06 | **$0.18** |
| Competitor analysis (3 channels, 30 videos each) | $0.36 + $0.015 | $0.036 | **$0.41** |
| Video deep-dive (5 videos, 200 comments each, transcripts) | $0.02 + $0.50 | $0.03 | **$0.55** |

### Who Is This For?

- **Content creators** — Audit your channel, understand what viewers want from comments, find content gaps in your niche
- **Marketing agencies** — Evaluate influencer channels with AI audit before signing deals
- **Brand managers** — Research niches before sponsoring creators, find channels that match your brand
- **SEO specialists** — Extract tags and titles from top-performing videos for keyword research
- **Researchers** — Collect video metadata, comments, and transcripts for analysis
- **Lead generation** — Extract business emails from channel About pages

### Output Fields

#### Video Fields

| Field | Description |
|-------|-------------|
| `video_id` | YouTube video ID |
| `title` | Video title |
| `description` | Video description (first 2000 chars) |
| `view_count` | Total views |
| `like_count` | Total likes |
| `dislike_count` | Estimated dislikes (via Return YouTube Dislike) |
| `duration` | Duration (HH:MM:SS) |
| `duration_seconds` | Duration in seconds |
| `tags` | Video tags/keywords |
| `category` | YouTube category |
| `is_short` | Whether this is a YouTube Short |
| `published_at` | Upload date |
| `channel_id` | Channel ID |
| `channel_title` | Channel name |
| `comments` | Array of comments (if enabled) |
| `transcript` | Video transcript (if enabled) |

#### Channel Fields

| Field | Description |
|-------|-------------|
| `channel_title` | Channel name |
| `subscriber_count` | Subscriber count |
| `video_count` | Total videos |
| `description` | Channel description |
| `business_email` | Business inquiry email (from About page) |
| `links` | External links (social media, website) |
| `country` | Channel country |

### Tips

- **Use residential proxy** for best results — set proxy to `RESIDENTIAL` in proxy config. Comments and full video details work best with residential proxy.
- **No proxy needed for basic scraping** — search results and channel video lists work without proxy
- **Tags are gold** — competitor video tags reveal their SEO strategy. Enable full video details to get them.
- **Comments + AI = content ideas** — enable AI Comment Analysis to turn viewer feedback into actionable content suggestions
- **Transcripts are free** — included at no extra charge, useful for content repurposing and analysis
- **Business emails** — extracted from channel About pages at no extra cost. Great for outreach.

### Keywords

YouTube scraper, YouTube channel scraper, YouTube comment scraper, YouTube video scraper, YouTube transcript scraper, YouTube tag extractor, YouTube data extractor, YouTube API, YouTube analytics, YouTube business email extractor, YouTube search scraper, YouTube competitor analysis, AI comment analysis, AI channel audit, YouTube niche research, content creator tools, influencer analytics, YouTube SEO, video metadata scraper

# Actor input Schema

## `scrape_type` (type: `string`):

What to scrape from YouTube.

## `channel_urls` (type: `array`):

YouTube channel URLs. Supports formats: youtube.com/channel/ID, youtube.com/@handle, youtube.com/c/name

## `search_query` (type: `string`):

Search YouTube for videos matching this query.

## `video_urls` (type: `array`):

Specific YouTube video URLs to scrape details for.

## `max_videos` (type: `integer`):

Maximum number of videos to scrape per channel or search.

## `get_comments` (type: `boolean`):

Scrape comments for each video.

## `max_comments` (type: `integer`):

Maximum comments to scrape per video.

## `get_transcript` (type: `boolean`):

Get video transcript/captions when available.

## `get_channel_about` (type: `boolean`):

Extract business email, links, and description from channel About page.

## `ai_comment_analysis` (type: `boolean`):

AI analyzes comments per video: top viewer requests, complaints, sentiment, content ideas. Requires 'Get comments' to be enabled. Charged at $6 per 1,000 videos analyzed.

## `ai_channel_audit` (type: `boolean`):

AI evaluates channel health: best content types, declining areas, growth signals, actionable recommendations. Charged at $12 per 1,000 channels.

## `ai_niche_report` (type: `boolean`):

AI analyzes all search results: niche saturation, content gaps, top performers, opportunity score. Only for search mode. Charged at $2 per 1,000 videos in report.

## `proxy_config` (type: `object`):

Proxy for YouTube requests. Recommended for large scrapes.

## Actor input object example

```json
{
  "scrape_type": "channel",
  "channel_urls": [
    "https://www.youtube.com/@GibiASMR"
  ],
  "search_query": "ASMR tapping",
  "max_videos": 30,
  "get_comments": false,
  "max_comments": 100,
  "get_transcript": false,
  "get_channel_about": true,
  "ai_comment_analysis": false,
  "ai_channel_audit": false,
  "ai_niche_report": false,
  "proxy_config": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

YouTube data with video metadata, comments, transcripts, and AI analysis

# 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 = {
    "channel_urls": [
        "https://www.youtube.com/@GibiASMR"
    ],
    "search_query": "ASMR tapping",
    "max_videos": 30,
    "proxy_config": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("buseta/youtube-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 = {
    "channel_urls": ["https://www.youtube.com/@GibiASMR"],
    "search_query": "ASMR tapping",
    "max_videos": 30,
    "proxy_config": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("buseta/youtube-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 '{
  "channel_urls": [
    "https://www.youtube.com/@GibiASMR"
  ],
  "search_query": "ASMR tapping",
  "max_videos": 30,
  "proxy_config": {
    "useApifyProxy": false
  }
}' |
apify call buseta/youtube-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Scraper + AI Comment Analyzer & Channel Audit",
        "description": "Scrape YouTube channels, videos, comments, transcripts, and search results. AI analyzes comments for viewer requests and sentiment, audits channel health with recommendations, and evaluates niche saturation with content gap analysis.",
        "version": "1.0",
        "x-build-id": "HipjUQRmqj659MzoI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/buseta~youtube-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-buseta-youtube-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/buseta~youtube-scraper/runs": {
            "post": {
                "operationId": "runs-sync-buseta-youtube-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/buseta~youtube-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-buseta-youtube-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": [
                    "scrape_type"
                ],
                "properties": {
                    "scrape_type": {
                        "title": "Scrape type",
                        "enum": [
                            "channel",
                            "search",
                            "video_urls"
                        ],
                        "type": "string",
                        "description": "What to scrape from YouTube.",
                        "default": "channel"
                    },
                    "channel_urls": {
                        "title": "Channel URLs",
                        "type": "array",
                        "description": "YouTube channel URLs. Supports formats: youtube.com/channel/ID, youtube.com/@handle, youtube.com/c/name",
                        "items": {
                            "type": "string"
                        }
                    },
                    "search_query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search YouTube for videos matching this query."
                    },
                    "video_urls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "Specific YouTube video URLs to scrape details for.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_videos": {
                        "title": "Max videos",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of videos to scrape per channel or search.",
                        "default": 50
                    },
                    "get_comments": {
                        "title": "Get comments",
                        "type": "boolean",
                        "description": "Scrape comments for each video.",
                        "default": false
                    },
                    "max_comments": {
                        "title": "Max comments per video",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum comments to scrape per video.",
                        "default": 100
                    },
                    "get_transcript": {
                        "title": "Get transcript",
                        "type": "boolean",
                        "description": "Get video transcript/captions when available.",
                        "default": false
                    },
                    "get_channel_about": {
                        "title": "Get channel about info",
                        "type": "boolean",
                        "description": "Extract business email, links, and description from channel About page.",
                        "default": true
                    },
                    "ai_comment_analysis": {
                        "title": "AI Comment Analyzer",
                        "type": "boolean",
                        "description": "AI analyzes comments per video: top viewer requests, complaints, sentiment, content ideas. Requires 'Get comments' to be enabled. Charged at $6 per 1,000 videos analyzed.",
                        "default": false
                    },
                    "ai_channel_audit": {
                        "title": "AI Channel Audit",
                        "type": "boolean",
                        "description": "AI evaluates channel health: best content types, declining areas, growth signals, actionable recommendations. Charged at $12 per 1,000 channels.",
                        "default": false
                    },
                    "ai_niche_report": {
                        "title": "AI Niche Report",
                        "type": "boolean",
                        "description": "AI analyzes all search results: niche saturation, content gaps, top performers, opportunity score. Only for search mode. Charged at $2 per 1,000 videos in report.",
                        "default": false
                    },
                    "proxy_config": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy for YouTube requests. Recommended for large scrapes."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
