# Youtube Channel Scraper (`scrapemesh/youtube-channel-scraper`) Actor

- **URL**: https://apify.com/scrapemesh/youtube-channel-scraper.md
- **Developed by:** [ScrapeMesh](https://apify.com/scrapemesh) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## YouTube Channel Scraper - Extract Complete Channel Data with Advanced Sorting

**Extract comprehensive YouTube channel data including videos, shorts, live streams, community posts, and channel analytics with independent sorting options for each content type. Built on Apify platform with intelligent proxy fallback and async processing.**

### 🎯 Overview

The **YouTube Channel Scraper** is a powerful Apify Actor designed to extract complete channel information from YouTube. Whether you need competitor analysis, content research, influencer marketing data, or channel analytics, this scraper provides structured data extraction with flexible sorting options for videos, shorts, posts, and live streams.

This actor scrapes publicly available YouTube channel data including channel metadata, subscriber counts, video statistics, shorts content, live streaming information, and community posts. All data is extracted in real-time with automatic proxy management to ensure reliable data collection.

### ✨ Key Features

#### Comprehensive Data Extraction
- **Channel Information**: Description, subscriber count, join date, location, verification status, avatar, banner
- **Videos**: Title, duration, view count, publish date, thumbnail, video URL with customizable sorting
- **Shorts**: Complete shorts data with engagement metrics, comments, likes, view counts
- **Live Streams**: Current and past live streams with viewer counts, chat IDs, scheduled times
- **Community Posts**: Text posts, images, polls with likes and comments count

#### Advanced Sorting Capabilities
- **Independent Sort Orders**: Configure separate sorting for videos, shorts, posts, and live streams
- **Video Sorting**: Sort by date, rating, relevance, title, or view count
- **Shorts Sorting**: Sort by date, rating, relevance, or view count
- **Posts Sorting**: Sort by date or relevance
- **Live Streams Sorting**: Sort by date, relevance, or view count

#### Intelligent Proxy Management
- **Automatic Fallback**: Starts without proxy, automatically switches to datacenter proxy if blocked
- **Residential Proxy Support**: Falls back to residential proxies with 3 retries if datacenter fails
- **Smart Logging**: Detailed proxy status logs for monitoring and debugging
- **Persistent Configuration**: Once residential proxy is activated, it remains for the entire run

#### Performance & Reliability
- **Async Processing**: Concurrent requests for faster data extraction
- **Automatic Retries**: Exponential backoff retry mechanism for failed requests
- **Live Data Saving**: Results saved to dataset in real-time as scraping progresses
- **Error Handling**: Graceful error handling with detailed logging

### 📋 Input Configuration

#### Required Fields

**startUrls** (array, required)
- List of YouTube channel URLs, usernames, or keywords
- Supports multiple formats: Full URL (`https://www.youtube.com/@MrBeast`), Username (`@MrBeast` or `MrBeast`), Channel ID
- Example: `["https://www.youtube.com/@MrBeast", "@PewDiePie"]`

#### Optional Fields

**maxResults** (integer, default: 10)
- Maximum number of results per category (videos, shorts, live streams, posts)
- Range: 1-1000

**sortOrderVideos** (string, default: "date")
- Options: `date`, `rating`, `relevance`, `title`, `viewCount`

**sortOrderShorts** (string, default: "date")
- Options: `date`, `rating`, `relevance`, `viewCount`

**sortOrderPosts** (string, default: "date")
- Options: `date`, `relevance`

**sortOrderLiveStreams** (string, default: "date")
- Options: `date`, `relevance`, `viewCount`

**maxComments** (integer, default: 0)
- Maximum comments per video/post (0-10000)
- Reserved for future comment scraping functionality

**proxyConfiguration** (object)
- Apify proxy configuration
- Default: `{"useApifyProxy": false}` (starts without proxy)
- Actor automatically handles proxy fallback if requests are blocked

#### Input Example

```json
{
  "startUrls": [
    "https://www.youtube.com/@MrBeast",
    "https://www.youtube.com/@PewDiePie"
  ],
  "maxResults": 50,
  "sortOrderVideos": "viewCount",
  "sortOrderShorts": "date",
  "sortOrderPosts": "date",
  "sortOrderLiveStreams": "viewCount",
  "maxComments": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📊 Output Structure

Results are automatically saved to the Apify dataset and organized by channel username as top-level keys. Each channel includes:

#### Channel Data Structure

```json
{
  "scrapedAt": "2025-12-08T17:04:54.964324",
  "totalChannels": 2,
  "maxResultsPerCategory": 50,
  "MrBeast": {
    "about": {
      "channelName": "MrBeast",
      "channelUsername": "MrBeast",
      "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
      "numberOfSubscribers": "453M",
      "channelTotalVideos": 929,
      "channelTotalViews": 102823749612,
      "isChannelVerified": true
    },
    "videos": [
      {
        "id": "8bMh8azh3CY",
        "title": "100 Pilots Fight For A Private Jet",
        "duration": "28:46",
        "viewCount": 50075792,
        "date": "1 day ago",
        "url": "https://www.youtube.com/watch?v=8bMh8azh3CY"
      }
    ],
    "shorts": [...],
    "live": [...],
    "posts": [...],
    "stats": {
      "totalVideos": 50,
      "totalShorts": 50,
      "totalLiveStreams": 38,
      "totalPosts": 50
    }
  },
  "summary": {
    "totalVideos": 100,
    "totalShorts": 50,
    "totalLiveStreams": 38,
    "totalPosts": 96
  }
}
```

#### Key Output Fields

**Channel Data**: `channelName`, `channelUsername`, `channelId`, `numberOfSubscribers`, `channelTotalVideos`, `channelTotalViews`, `channelJoinedDate`, `channelLocation`, `isChannelVerified`, `channelDescription`, `channelDescriptionLinks`

**Video Data**: `id`, `title`, `duration`, `viewCount`, `date`, `url`, `thumbnailUrl`, `order`

**Shorts Data**: `videoId`, `title`, `videoUrl`, `viewsText`, `likesCount`, `commentsCount`, `publishDate`

**Live Streams Data**: `videoId`, `title`, `isLive`, `isUpcoming`, `concurrentViewers`, `liveChatId`, `scheduledStartTime`

**Community Posts Data**: `postId`, `type`, `textContent`, `imageUrls`, `pollOptions`, `likesCount`, `commentsCount`, `publishedAt`

### 🚀 How to Use

#### Running on Apify Platform

1. Navigate to [console.apify.com](https://console.apify.com)
2. Create new actor or upload this repository
3. Configure input with channel URLs and sorting preferences
4. Click "Start" and monitor real-time logs
5. Access results in OUTPUT tab
6. Export data as JSON, CSV, or Excel

#### Running Locally

```bash
cd YouTube-Channel-Scraper
pip install -r requirements.txt
python -m src
```

**Note**: Local testing requires Apify SDK credentials or code modifications.

### 💡 Use Cases

**Content Research & Analysis**: Analyze competitor channels, track video performance, research trending topics, monitor channel growth

**Influencer Marketing**: Build influencer databases, analyze content engagement, track posting schedules, evaluate collaboration partners

**Market Research**: Study industry channels, analyze content trends, track market leaders, research audience preferences

**Data Analytics**: Aggregate channel statistics, build analytics dashboards, track performance metrics, generate competitive reports

**Content Aggregation**: Collect content for curation platforms, build recommendation systems, create discovery tools, aggregate multi-channel feeds

### 🔧 Technical Details

**Architecture**: Python 3, Apify SDK, aiohttp (async), JSON format, Apify Dataset storage

**Proxy Strategy**:

1. Initial request without proxy
2. Fallback to datacenter proxy if blocked (403, 429, 503)
3. Fallback to residential proxy if datacenter fails
4. 3 retries with exponential backoff on residential proxy
5. Persistent residential proxy usage once activated

**Performance**: Up to 10 concurrent requests, automatic pagination, incremental data saving, graceful error recovery

### 📝 Best Practices

1. Start with `maxResults: 10` to test configuration
2. Monitor proxy fallback events in real-time logs
3. Choose sort orders based on analysis needs
4. Process multiple channels in single run for efficiency
5. Export results periodically for backup

### ⚠️ Important Notes

- **Public Data Only**: Only accesses publicly available YouTube data
- **Rate Limiting**: Automatic retry logic included
- **Proxy Usage**: Automatic fallback; manual configuration optional
- **Data Accuracy**: Real-time extraction; metrics may vary slightly
- **Legal Compliance**: Ensure compliance with YouTube Terms of Service

### 🆘 Support & Custom Solutions

For custom solutions, feature requests, or technical support:

**Email**: dev.scraperengine@gmail.com

We provide custom scraper development, feature enhancements, technical support, integration assistance, and bulk data extraction services.

### 📄 License & Terms

This actor is provided as-is for data extraction purposes. Users are responsible for ensuring compliance with YouTube Terms of Service, data protection regulations (GDPR, CCPA), local laws, and intellectual property rights.

### 🔄 Updates & Changelog

**Version 0.1**

- Initial release with comprehensive channel scraping
- Independent sort orders for all content types
- Intelligent proxy fallback system
- Async processing with retry logic
- Real-time data saving to dataset

***

**Ready to extract YouTube channel data?** Deploy this actor on Apify and start scraping comprehensive channel information with advanced sorting options today!

# Actor input Schema

## `startUrls` (type: `array`):

📋 Drop in full channel URLs, snappy @usernames (e.g. @CreatorName), or keywords to discover channels. One entry per line — mix and match is fine! ✨ Tip: full links often give the fastest, most precise match.

## `maxResults` (type: `integer`):

🎚️ Set the ceiling for each enabled category (videos, Shorts, lives, posts). Keep runs quick with small numbers, or go big for deep archives — you stay in control.

## `sortOrderVideos` (type: `string`):

🧭 Choose how videos are ordered before trimming to your max: newest, most viewed, top rated, title A→Z, or closest match to relevance.

## `sortOrderShorts` (type: `string`):

🧭 Same idea for vertical Shorts — pick the order that fits your story (date, views, rating, or relevance).

## `sortOrderPosts` (type: `string`):

🧭 Order community tab posts by freshness or by what YouTube considers most relevant.

## `sortOrderLiveStreams` (type: `string`):

🧭 Prioritize live and past broadcasts by date, relevance, or view count — whatever matches your report best.

## `scrapeChannelInfo` (type: `boolean`):

📣 When ON, you'll get the big-picture channel story — name, identity, audience signals, and other public "About" style details that help you understand who you're looking at at a glance.

## `scrapeVideos` (type: `boolean`):

✅ Include classic uploads from the Videos tab — great for catalogs, content audits, and competitor playlists.

## `scrapeShorts` (type: `boolean`):

✅ Pull the bite-sized vertical hits creators post as Shorts — ideal for trend spotting and mobile-first campaigns.

## `scrapePosts` (type: `boolean`):

✅ Capture updates, polls, and announcements creators share with their community — perfect for social listening.

## `scrapeLiveStreams` (type: `boolean`):

✅ Include scheduled, live, and replay-style stream listings so you never miss how a channel shows up for broadcast fans.

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

🌍 When YouTube is picky about region or traffic, optional Apify proxies can help keep runs steady. Leave it off for the simplest setup — turn it on when you need extra reliability.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "maxResults": 10,
  "sortOrderVideos": "date",
  "sortOrderShorts": "date",
  "sortOrderPosts": "date",
  "sortOrderLiveStreams": "date",
  "scrapeChannelInfo": true,
  "scrapeVideos": true,
  "scrapeShorts": true,
  "scrapePosts": true,
  "scrapeLiveStreams": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.youtube.com/@MrBeast"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemesh/youtube-channel-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 = {
    "startUrls": ["https://www.youtube.com/@MrBeast"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemesh/youtube-channel-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 '{
  "startUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapemesh/youtube-channel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Channel Scraper",
        "version": "0.1",
        "x-build-id": "Wl2RAYQzhi8g5RGRo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemesh~youtube-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemesh-youtube-channel-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/scrapemesh~youtube-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemesh-youtube-channel-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/scrapemesh~youtube-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemesh-youtube-channel-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗🎯 Where to start — URLs, @handles, or keywords",
                        "type": "array",
                        "description": "📋 Drop in full channel URLs, snappy @usernames (e.g. @CreatorName), or keywords to discover channels. One entry per line — mix and match is fine! ✨ Tip: full links often give the fastest, most precise match.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🔢📊 How many items per section?",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "🎚️ Set the ceiling for each enabled category (videos, Shorts, lives, posts). Keep runs quick with small numbers, or go big for deep archives — you stay in control.",
                        "default": 10
                    },
                    "sortOrderVideos": {
                        "title": "🎥📅 Sort order — long-form videos",
                        "enum": [
                            "date",
                            "rating",
                            "relevance",
                            "title",
                            "viewCount"
                        ],
                        "type": "string",
                        "description": "🧭 Choose how videos are ordered before trimming to your max: newest, most viewed, top rated, title A→Z, or closest match to relevance.",
                        "default": "date"
                    },
                    "sortOrderShorts": {
                        "title": "📱⚡ Sort order — Shorts",
                        "enum": [
                            "date",
                            "rating",
                            "relevance",
                            "viewCount"
                        ],
                        "type": "string",
                        "description": "🧭 Same idea for vertical Shorts — pick the order that fits your story (date, views, rating, or relevance).",
                        "default": "date"
                    },
                    "sortOrderPosts": {
                        "title": "💬🗨️ Sort order — community posts",
                        "enum": [
                            "date",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "🧭 Order community tab posts by freshness or by what YouTube considers most relevant.",
                        "default": "date"
                    },
                    "sortOrderLiveStreams": {
                        "title": "🔴📡 Sort order — live streams",
                        "enum": [
                            "date",
                            "relevance",
                            "viewCount"
                        ],
                        "type": "string",
                        "description": "🧭 Prioritize live and past broadcasts by date, relevance, or view count — whatever matches your report best.",
                        "default": "date"
                    },
                    "scrapeChannelInfo": {
                        "title": "🏠✨ Channel profile & \"About\" highlights",
                        "type": "boolean",
                        "description": "📣 When ON, you'll get the big-picture channel story — name, identity, audience signals, and other public \"About\" style details that help you understand who you're looking at at a glance.",
                        "default": true
                    },
                    "scrapeVideos": {
                        "title": "🎬🍿 Long-form videos tab",
                        "type": "boolean",
                        "description": "✅ Include classic uploads from the Videos tab — great for catalogs, content audits, and competitor playlists.",
                        "default": true
                    },
                    "scrapeShorts": {
                        "title": "📲🌟 Shorts tab",
                        "type": "boolean",
                        "description": "✅ Pull the bite-sized vertical hits creators post as Shorts — ideal for trend spotting and mobile-first campaigns.",
                        "default": true
                    },
                    "scrapePosts": {
                        "title": "📝💭 Community posts tab",
                        "type": "boolean",
                        "description": "✅ Capture updates, polls, and announcements creators share with their community — perfect for social listening.",
                        "default": true
                    },
                    "scrapeLiveStreams": {
                        "title": "🔴🎙️ Live & past streams",
                        "type": "boolean",
                        "description": "✅ Include scheduled, live, and replay-style stream listings so you never miss how a channel shows up for broadcast fans.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🌐🛡️ Optional proxy (smoother runs)",
                        "type": "object",
                        "description": "🌍 When YouTube is picky about region or traffic, optional Apify proxies can help keep runs steady. Leave it off for the simplest setup — turn it on when you need extra reliability."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```