# YouTube (`lofomachines/youtube`) Actor

Fast, affordable YouTube data scraper. Find videos by keyword, scrape channels and playlists, collect metadata, comments, replies and transcripts without a YouTube API key.

- **URL**: https://apify.com/lofomachines/youtube.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** Videos, Social media, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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 Scraper – Videos, Channels, Comments & Transcripts

Turn YouTube searches, videos, Shorts, channels and playlists into clean, ready-to-use data. **YouTube Scraper** collects video metadata, channel profiles, comments, replies and full timestamped transcripts—without a YouTube API key and without browser-level costs.

Use it for market research, creator discovery, content intelligence, audience analysis, lead generation, AI datasets, brand monitoring and competitive research. Paste URLs, enter keywords, choose your limits, and click **Start**.

### What can this YouTube scraper collect?

- **Keyword search:** videos, Shorts, channels, playlists and movies
- **Search filters:** upload date, duration, relevance, popularity, HD, 4K, subtitles, live, Creative Commons, HDR, 360° and more
- **Single videos, Shorts and live videos:** title, full description, views, likes, duration, category, keywords, thumbnails, channel details and status flags
- **Channels:** profile, description, handle, avatar, subscribers, video count, keywords and available countries
- **Channel listings:** videos, Shorts, live streams and playlists with pagination
- **Playlists:** playlist details and every available video
- **Comments:** top or newest comments, likes, authors, badges, pinned status and creator hearts
- **Replies:** reply threads with configurable limits
- **Transcripts:** complete text plus timestamped segments and language information
- **Related videos:** YouTube recommendations for each video
- **Video downloads:** optionally save selected videos as MP4 files in 360p, 480p, 720p, 1080p or the best available quality

### Why choose this Actor?

- **Fast and affordable:** lightweight HTTP requests instead of a full browser
- **Reliable cloud runs:** connection handling is fully automatic
- **Fast at scale:** optimized parallel processing is included automatically
- **No-code friendly:** one form handles every supported YouTube URL
- **No YouTube Data API key:** start immediately without quotas or Google Cloud setup
- **Flexible at any size:** scrape one video or paginate through large channels and playlists
- **Automation ready:** export JSON, CSV, Excel, XML or connect with Make, Zapier, Google Sheets and your own API
- **AI ready:** structured metadata and transcripts are ideal for RAG, LLM analysis, summaries and content research

### Quick start

1. Add YouTube URLs and/or search keywords.
2. Choose search filters and channel content types.
3. Turn on transcripts, comments, replies or related videos only when needed.
   To save video files too, enable **Download YouTube videos**, choose a quality, and set a maximum download count.
4. Set a clear maximum for videos and comments.
5. Click **Start** and export the dataset in your preferred format.

#### Example input: search videos with transcripts

```json
{
  "searchQueries": ["AI automation tutorial", "Apify web scraping"],
  "searchType": "video",
  "uploadDate": "month",
  "duration": "three_to_twenty_mins",
  "sortBy": "relevance",
  "maxResults": 50,
  "scrapeVideoDetails": true,
  "includeTranscripts": true,
  "transcriptLanguage": "en",
  "maxCommentsPerVideo": 0,
  "language": "en",
  "location": "US"
}
````

#### Example input: channel videos, Shorts and comments

```json
{
  "startUrls": [{ "url": "https://www.youtube.com/@ApifyTech" }],
  "channelContentTypes": ["videos", "shorts"],
  "maxVideosPerChannel": 200,
  "scrapeVideoDetails": true,
  "maxCommentsPerVideo": 100,
  "commentSort": "newest",
  "includeReplies": true,
  "maxRepliesPerComment": 20
}
```

### Example video output

```json
{
  "recordType": "video",
  "videoId": "dQw4w9WgXcQ",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "Video title",
  "description": "Full video description...",
  "channelId": "UC...",
  "channelName": "Channel name",
  "durationSeconds": 213,
  "viewCount": 1600000000,
  "likeCount": 18000000,
  "category": "Music",
  "keywords": ["music", "official video"],
  "thumbnailUrl": "https://i.ytimg.com/vi/.../maxresdefault.jpg",
  "captionLanguages": [{ "code": "en", "name": "English", "autoGenerated": false }],
  "transcript": {
    "languageCode": "en",
    "text": "Complete transcript text...",
    "segments": [{ "startSeconds": 0, "durationSeconds": 2.4, "text": "First caption" }]
  }
}
```

### Example comment output

```json
{
  "recordType": "comment",
  "videoId": "dQw4w9WgXcQ",
  "commentId": "Ugx...",
  "parentCommentId": null,
  "text": "Comment text",
  "authorName": "Viewer name",
  "authorChannelId": "UC...",
  "likeCount": 125,
  "replyCount": 8,
  "publishedText": "2 days ago",
  "isPinned": false,
  "isHearted": true
}
```

### Popular use cases

#### YouTube market and competitor research

Find the most visible videos for a topic, compare channel output, track engagement signals and uncover content gaps competitors have missed.

#### Creator and influencer discovery

Search by niche, collect channel and video performance signals, and build targeted creator lists for partnerships or outreach.

#### Comments and audience sentiment analysis

Collect top or recent comments and replies for sentiment analysis, recurring questions, product feedback, pain points and customer language.

#### YouTube transcript scraping for AI

Build searchable knowledge bases, summarize videos, extract quotes and topics, create embeddings, or supply timestamped source material to an AI workflow.

#### Content ideation and SEO research

Discover titles, keywords, descriptions, popular formats and recent trends around a search phrase. Export the data and turn evidence into a stronger editorial calendar.

#### Brand monitoring

Search brand and product keywords, monitor relevant uploads, analyze descriptions and comments, and route findings into dashboards or alerts.

### Understanding limits and cost

The defaults favor predictable, economical runs. A listing-only run is fastest. Full metadata adds a lightweight request for each video; transcripts, related videos and comments add more requests. Start with a small limit, verify the output, then scale up.

Video downloading is disabled by default because MP4 files can significantly increase memory, run time and storage usage. The default download limit is one video at 360p. Downloaded files appear in the run's key-value store and each matching video record includes its file name, size, delivered quality and download URL. When YouTube does not offer the requested quality as a combined audio-and-video MP4, the Actor safely falls back to 360p. Only download content you have the right to save.

Set **Maximum comments per video** to `0` when comments are not needed. YouTube may disable comments or captions on individual videos, and private, removed, age-restricted or region-restricted content may return limited data.

### Output and integrations

Every item includes a `recordType` such as `video`, `channel`, `playlist` or `comment`. This makes mixed runs easy to filter. Download results as JSON, CSV, Excel, XML or RSS, access them through the Apify API, or send them to your favorite automation and analytics tools.

### Responsible use

Use this Actor only for lawful purposes and follow YouTube’s terms, privacy rules and applicable data-protection laws. Avoid collecting or using personal data in ways people would not reasonably expect. The Actor is not affiliated with or endorsed by YouTube or Google.

### More data tools by Lofomachines

Need another fast, affordable scraper? **[Discover all Lofomachines Actors on Apify](https://apify.com/lofomachines)** and build your next dataset without code.

# Actor input Schema

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

Add one or more YouTube URLs. The Actor recognizes the content type automatically.

## `searchQueries` (type: `array`):

Find YouTube videos, Shorts, channels or playlists for each keyword.

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

Stops each keyword search or playlist after this many videos.

## `searchType` (type: `string`):

Choose the kind of YouTube result returned for keyword searches.

## `uploadDate` (type: `string`):

Limit search results to videos uploaded during this period.

## `duration` (type: `string`):

Limit keyword results by the length of each video.

## `sortBy` (type: `string`):

Order keyword results by relevance or popularity.

## `features` (type: `array`):

Optional. Return only videos matching every selected feature.

## `channelContentTypes` (type: `array`):

Choose the channel tabs to collect from every channel URL.

## `maxVideosPerChannel` (type: `integer`):

Stops each selected channel tab after this many videos.

## `scrapeVideoDetails` (type: `boolean`):

Adds full description, exact duration, views, likes, category, keywords, flags and available caption languages.

## `includeTranscripts` (type: `boolean`):

Adds the complete transcript and timestamped segments when captions are available.

## `transcriptLanguage` (type: `string`):

Language code such as en, es, it or de. Falls back to an available caption track.

## `includeRelatedVideos` (type: `boolean`):

Adds the recommendations shown beside each video.

## `downloadYoutubeVideo` (type: `boolean`):

Save each selected video as an MP4 file in the run's key-value store.

## `videoDownloadQuality` (type: `string`):

Choose the preferred MP4 quality. YouTube may provide a lower available quality for some videos.

## `maxVideoDownloads` (type: `integer`):

Safety limit for downloaded video files across the entire run.

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

Collect up to this many top-level comments for each video; use 0 to skip comments.

## `commentSort` (type: `string`):

Collect the most relevant comments or newest comments first.

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

Collect replies beneath each saved top-level comment.

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

Stops each reply thread after this many replies.

## `language` (type: `string`):

Two-letter language code used to localize YouTube results, such as en, es or it.

## `location` (type: `string`):

Two-letter country code used to localize YouTube results, such as US, IT or GB.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/@ApifyTech"
    }
  ],
  "searchQueries": [
    "web scraping tutorial"
  ],
  "maxResults": 100,
  "searchType": "video",
  "uploadDate": "all",
  "duration": "all",
  "sortBy": "relevance",
  "features": [],
  "channelContentTypes": [
    "videos"
  ],
  "maxVideosPerChannel": 100,
  "scrapeVideoDetails": true,
  "includeTranscripts": false,
  "transcriptLanguage": "en",
  "includeRelatedVideos": false,
  "downloadYoutubeVideo": false,
  "videoDownloadQuality": "360p",
  "maxVideoDownloads": 1,
  "maxCommentsPerVideo": 0,
  "commentSort": "top",
  "includeReplies": true,
  "maxRepliesPerComment": 20,
  "language": "en",
  "location": "US"
}
```

# Actor output Schema

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

No description

## `videos` (type: `string`):

No description

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

No description

## `channels` (type: `string`):

No description

## `downloadedVideos` (type: `string`):

No description

# 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": [
        {
            "url": "https://www.youtube.com/@ApifyTech"
        }
    ],
    "searchQueries": [
        "web scraping tutorial"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/youtube").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": [{ "url": "https://www.youtube.com/@ApifyTech" }],
    "searchQueries": ["web scraping tutorial"],
}

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/youtube").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": [
    {
      "url": "https://www.youtube.com/@ApifyTech"
    }
  ],
  "searchQueries": [
    "web scraping tutorial"
  ]
}' |
apify call lofomachines/youtube --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube",
        "description": "Fast, affordable YouTube data scraper. Find videos by keyword, scrape channels and playlists, collect metadata, comments, replies and transcripts without a YouTube API key.",
        "version": "1.0",
        "x-build-id": "h51mCVt67yi3q92xs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~youtube/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-youtube",
                "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/lofomachines~youtube/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-youtube",
                "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/lofomachines~youtube/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-youtube",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "YouTube URLs",
                        "type": "array",
                        "description": "Add one or more YouTube URLs. The Actor recognizes the content type automatically.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "maxItems": 1000,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Find YouTube videos, Shorts, channels or playlists for each keyword.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum results per search or playlist",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stops each keyword search or playlist after this many videos.",
                        "default": 100
                    },
                    "searchType": {
                        "title": "Result type",
                        "enum": [
                            "all",
                            "video",
                            "shorts",
                            "channel",
                            "playlist",
                            "movie"
                        ],
                        "type": "string",
                        "description": "Choose the kind of YouTube result returned for keyword searches.",
                        "default": "video"
                    },
                    "uploadDate": {
                        "title": "Upload date",
                        "enum": [
                            "all",
                            "today",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Limit search results to videos uploaded during this period.",
                        "default": "all"
                    },
                    "duration": {
                        "title": "Video duration",
                        "enum": [
                            "all",
                            "under_three_mins",
                            "three_to_twenty_mins",
                            "over_twenty_mins"
                        ],
                        "type": "string",
                        "description": "Limit keyword results by the length of each video.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "Order keyword results by relevance or popularity.",
                        "default": "relevance"
                    },
                    "features": {
                        "title": "Video features",
                        "type": "array",
                        "description": "Optional. Return only videos matching every selected feature.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hd",
                                "subtitles",
                                "creative_commons",
                                "3d",
                                "live",
                                "4k",
                                "360",
                                "location",
                                "hdr",
                                "vr180"
                            ]
                        },
                        "default": []
                    },
                    "channelContentTypes": {
                        "title": "Channel content",
                        "type": "array",
                        "description": "Choose the channel tabs to collect from every channel URL.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "videos",
                                "shorts",
                                "live",
                                "playlists"
                            ]
                        },
                        "default": [
                            "videos"
                        ]
                    },
                    "maxVideosPerChannel": {
                        "title": "Maximum videos per channel tab",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stops each selected channel tab after this many videos.",
                        "default": 100
                    },
                    "scrapeVideoDetails": {
                        "title": "Collect full video metadata",
                        "type": "boolean",
                        "description": "Adds full description, exact duration, views, likes, category, keywords, flags and available caption languages.",
                        "default": true
                    },
                    "includeTranscripts": {
                        "title": "Include transcripts",
                        "type": "boolean",
                        "description": "Adds the complete transcript and timestamped segments when captions are available.",
                        "default": false
                    },
                    "transcriptLanguage": {
                        "title": "Preferred transcript language",
                        "type": "string",
                        "description": "Language code such as en, es, it or de. Falls back to an available caption track.",
                        "default": "en"
                    },
                    "includeRelatedVideos": {
                        "title": "Include related videos",
                        "type": "boolean",
                        "description": "Adds the recommendations shown beside each video.",
                        "default": false
                    },
                    "downloadYoutubeVideo": {
                        "title": "Download YouTube videos",
                        "type": "boolean",
                        "description": "Save each selected video as an MP4 file in the run's key-value store.",
                        "default": false
                    },
                    "videoDownloadQuality": {
                        "title": "Video download quality",
                        "enum": [
                            "360p",
                            "480p",
                            "720p",
                            "1080p",
                            "best",
                            "bestefficiency"
                        ],
                        "type": "string",
                        "description": "Choose the preferred MP4 quality. YouTube may provide a lower available quality for some videos.",
                        "default": "360p"
                    },
                    "maxVideoDownloads": {
                        "title": "Maximum videos to download",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety limit for downloaded video files across the entire run.",
                        "default": 1
                    },
                    "maxCommentsPerVideo": {
                        "title": "Maximum comments per video",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Collect up to this many top-level comments for each video; use 0 to skip comments.",
                        "default": 0
                    },
                    "commentSort": {
                        "title": "Comment order",
                        "enum": [
                            "top",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Collect the most relevant comments or newest comments first.",
                        "default": "top"
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Collect replies beneath each saved top-level comment.",
                        "default": true
                    },
                    "maxRepliesPerComment": {
                        "title": "Maximum replies per comment",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stops each reply thread after this many replies.",
                        "default": 20
                    },
                    "language": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Two-letter language code used to localize YouTube results, such as en, es or it.",
                        "default": "en"
                    },
                    "location": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter country code used to localize YouTube results, such as US, IT or GB.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
