# YouTube Transcript Scraper - Captions, Subtitles & RAG API (`meilimiao/yt-transcript-captions-api`) Actor

Extract YouTube transcripts, captions, subtitles, timestamps, metadata, SRT, WebVTT, Markdown, and RAG-ready chunks from videos, Shorts, channels, and playlists. Works with bulk URLs and residential proxy support.

- **URL**: https://apify.com/meilimiao/yt-transcript-captions-api.md
- **Developed by:** [Glamour Meow](https://apify.com/meilimiao) (community)
- **Categories:** Videos, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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 Transcript Scraper - Captions, Subtitles & RAG API — $1/1K

Extract YouTube transcripts, captions, subtitles, timestamps, metadata, SRT, WebVTT, Markdown, and RAG-ready chunks from videos, Shorts, channels, and playlists.

Built for AI agents, RAG pipelines, video summarization, subtitle export, research, SEO, content repurposing, and bulk YouTube video-to-text workflows.

### Why use this YouTube Transcript Scraper?

- **$1 per 1,000 results** — far cheaper than many transcript actors priced around $10/1K.
- **Works in 2026** — uses PoToken/BotGuard support plus residential proxy compatibility for reliable caption extraction.
- **No YouTube Data API key** — works from public YouTube URLs and video IDs when captions are available.
- **Videos, Shorts, playlists, channels** — process one video or resolve bulk URLs from playlists/channels.
- **Manual + auto-generated captions** — tries manually uploaded subtitles first, then auto-generated captions.
- **Language fallback** — pass `languages: ["en", "es", "ko"]`; the Actor tries each language in order.
- **Optional translation** — pass `translateTo` when YouTube built-in translation is available.
- **5 output formats** — JSON, plain text, SRT, WebVTT, and Markdown.
- **RAG-ready chunks** — split transcripts into chunks for vector databases, LLM apps, and AI datasets.
- **Metadata included** — title, channel, duration, views, publish date, thumbnail, description, and tags.
- **Graceful failures** — no-caption/private/blocked videos return a clear `error` item instead of crashing the whole batch.

### Common use cases

- YouTube transcript API for AI apps
- Bulk YouTube captions downloader
- Video-to-text datasets for LLMs
- RAG ingestion from YouTube channels
- YouTube subtitle export to SRT or WebVTT
- Summaries, keyword extraction, and content repurposing
- Market research and competitor video analysis
- Academic/research transcript collection
- Channel and playlist transcript scraping

### Recommended input

Use residential proxies for the highest success rate. The default sample is a known public video with captions.

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "outputFormat": "json",
  "languages": ["en", "es", "ko"],
  "includeMetadata": true,
  "includeTimestamps": true,
  "includeAvailableLanguages": true,
  "includeRagChunks": false,
  "chunkSize": 1000,
  "maxVideos": 100,
  "maxConcurrency": 2,
  "fallbackToAnyLanguage": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

### Input fields

| Field | Type | Default | Description |
|---|---|---:|---|
| `urls` | array | required | YouTube video URLs, Shorts URLs, playlist URLs, channel URLs, or raw video IDs. |
| `outputFormat` | string | `json` | `json`, `text`, `srt`, `vtt`, or `markdown`. |
| `languages` | array | `["en"]` | Language priority list. The Actor tries each language in order. |
| `translateTo` | string/null | `null` | Optional target language code for YouTube auto-translation. |
| `includeMetadata` | boolean | `true` | Include title, channel, duration, views, publish date, thumbnail, description, and tags. |
| `includeTimestamps` | boolean | `true` | Include timestamped transcript segments. |
| `includeAvailableLanguages` | boolean | `true` | Include all available caption languages. |
| `includeRagChunks` | boolean | `false` | Return chunked text for vector databases and RAG. |
| `chunkSize` | integer | `1000` | Approximate max characters per RAG chunk. |
| `maxVideos` | integer | `100` | Max videos to process after resolving channels/playlists. |
| `maxConcurrency` | integer | `2` | Videos processed in parallel. Increase carefully. |
| `fallbackToAnyLanguage` | boolean | `true` | Use any available transcript if requested languages are not found. |
| `proxyConfiguration` | object | residential proxy | Recommended for YouTube reliability. |

### Proxy recommendation

YouTube aggressively blocks datacenter IPs and may return `LOGIN_REQUIRED`, HTTP 429, or empty caption responses.

For best results, use:

```json
"proxyConfiguration": {
  "useApifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"],
  "apifyProxyCountry": "US"
}
```

Direct/no-proxy runs may work for some public videos, but residential proxies are strongly recommended for production and bulk extraction.

### Output example

```json
{
  "videoId": "dQw4w9WgXcQ",
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "sourceUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "sourceType": "video",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "channelName": "Rick Astley",
  "channelId": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channelUrl": "http://www.youtube.com/@RickAstleyYT",
  "duration": 213,
  "viewCount": 1780000000,
  "publishDate": "2009-10-24T23:57:33-07:00",
  "thumbnail": "https://i.ytimg.com/vi_webp/dQw4w9WgXcQ/maxresdefault.webp",
  "language": "English",
  "languageCode": "en",
  "isAutoGenerated": false,
  "hasTranscript": true,
  "transcriptText": "Full transcript text...",
  "formattedTranscript": null,
  "outputFormat": "json",
  "segments": [
    {
      "start": 18.64,
      "duration": 3.24,
      "text": "We're no strangers to love"
    }
  ],
  "ragChunks": [],
  "wordCount": 285,
  "characterCount": 1580,
  "availableLanguages": [
    {
      "language": "English",
      "languageCode": "en",
      "isGenerated": false,
      "isTranslatable": true
    }
  ],
  "error": null,
  "scrapedAt": "2026-06-27T06:00:00Z"
}
```

### Output formats

#### JSON

Structured transcript segments, full text, metadata, language info, available languages, and optional RAG chunks.

#### Plain text

A clean full transcript string for LLM prompts and automation.

#### SRT

Subtitle format for video editors.

```srt
1
00:00:18,640 --> 00:00:21,880
We're no strangers to love
```

#### WebVTT

Subtitle format for web players.

```vtt
WEBVTT

00:00:18.640 --> 00:00:21.880
We're no strangers to love
```

#### Markdown

Readable transcript document with title, metadata, and timestamped text.

```md
## Video title

**Channel:** Channel name | **Duration:** 3:33 | **Views:** 123456

---

### Transcript

[0:18] We're no strangers to love
```

### RAG chunks

Set `includeRagChunks: true` to return chunks like:

```json
{
  "index": 0,
  "start": 18.64,
  "end": 63.2,
  "text": "Chunk text suitable for embeddings...",
  "characterCount": 998
}
```

Use this for vector databases, semantic search, AI agents, and long-video summarization.

### Pricing

This Actor is configured at **$1 per 1,000 results** plus Apify platform usage costs.

Example:

| Results | Actor price |
|---:|---:|
| 1,000 transcripts | $1 |
| 10,000 transcripts | $10 |
| 100,000 transcripts | $100 |

Residential proxy traffic is charged by Apify as platform usage. It is recommended because it significantly improves YouTube success rate.

### FAQ

#### Do I need a YouTube Data API key?

No. The Actor does not require a YouTube Data API key.

#### Does it support auto-generated captions?

Yes. It tries manual captions first, then auto-generated captions.

#### Does it support playlists and channels?

Yes. The Actor resolves video URLs, Shorts URLs, playlist URLs, and channel/handle URLs up to `maxVideos`.

#### Does it support private or members-only videos?

No. Private, members-only, age-restricted, or login-only videos may fail because they require authenticated YouTube access.

#### Why did a video return `hasTranscript: false`?

Common reasons:

- The video has no captions.
- The video is private, deleted, age-restricted, or region-blocked.
- YouTube returned bot detection (`LOGIN_REQUIRED`).
- The run did not use residential proxy.

The Actor returns a dataset item with metadata when available and a clear `error` reason.

#### Why use residential proxies?

YouTube often blocks datacenter IPs. In cloud testing, residential proxy mode had a much higher success rate for public videos with captions.

#### Can I use this for AI/RAG?

Yes. Use `includeRagChunks: true` and `outputFormat: "json"` for structured chunks that can be embedded into vector databases.

### SEO keywords

YouTube transcript scraper, YouTube transcript API, YouTube captions extractor, YouTube subtitles scraper, YouTube transcript downloader, YouTube video to text, YouTube captions API, YouTube transcript bulk download, YouTube playlist transcript scraper, YouTube channel transcript scraper, YouTube transcript for AI, YouTube transcript for RAG, YouTube SRT subtitles, YouTube WebVTT captions.

# Actor input Schema

## `urls` (type: `array`):

YouTube video URLs, Shorts URLs, playlist URLs, channel URLs, or raw 11-character video IDs. Start with a single video to test, then scale to bulk URLs.

## `outputFormat` (type: `string`):

Choose how transcript text is formatted in formattedTranscript. JSON keeps structured fields only.

## `languages` (type: `array`):

Language codes in priority order. The Actor tries manual captions first, then auto-generated captions.

## `translateTo` (type: `string`):

Optional target language code, e.g. es, fr, de, zh. Uses YouTube built-in translation when available.

## `includeMetadata` (type: `boolean`):

Include title, channel, duration, views, publish date, thumbnail, description, and tags when available.

## `includeTimestamps` (type: `boolean`):

Include per-caption segments with start time, duration, and text.

## `includeAvailableLanguages` (type: `boolean`):

Return all transcript languages available on the video.

## `includeRagChunks` (type: `boolean`):

Split transcript into chunks suitable for vector databases and RAG pipelines.

## `chunkSize` (type: `integer`):

Approximate max characters per RAG chunk.

## `maxVideos` (type: `integer`):

Limit total videos processed, useful for channels and playlists.

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

How many videos to process in parallel. Default 2 is recommended for YouTube reliability; increase carefully for large proxy-backed runs.

## `fallbackToAnyLanguage` (type: `boolean`):

If requested languages are unavailable, use any available transcript instead of failing.

## `preserveFormatting` (type: `boolean`):

Keep supported HTML formatting tags from YouTube captions.

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

Recommended: Apify Proxy with RESIDENTIAL group and US country. YouTube often blocks datacenter IPs, especially for bulk transcript extraction.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "outputFormat": "json",
  "languages": [
    "en",
    "es",
    "ko"
  ],
  "includeMetadata": true,
  "includeTimestamps": true,
  "includeAvailableLanguages": true,
  "includeRagChunks": false,
  "chunkSize": 1000,
  "maxVideos": 100,
  "maxConcurrency": 2,
  "fallbackToAnyLanguage": true,
  "preserveFormatting": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "languages": [
        "en",
        "es",
        "ko"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("meilimiao/yt-transcript-captions-api").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 = {
    "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "languages": [
        "en",
        "es",
        "ko",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("meilimiao/yt-transcript-captions-api").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 '{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "languages": [
    "en",
    "es",
    "ko"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call meilimiao/yt-transcript-captions-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Transcript Scraper - Captions, Subtitles & RAG API",
        "description": "Extract YouTube transcripts, captions, subtitles, timestamps, metadata, SRT, WebVTT, Markdown, and RAG-ready chunks from videos, Shorts, channels, and playlists. Works with bulk URLs and residential proxy support.",
        "version": "0.1",
        "x-build-id": "OstFbPovspWr6B7ZJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/meilimiao~yt-transcript-captions-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-meilimiao-yt-transcript-captions-api",
                "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/meilimiao~yt-transcript-captions-api/runs": {
            "post": {
                "operationId": "runs-sync-meilimiao-yt-transcript-captions-api",
                "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/meilimiao~yt-transcript-captions-api/run-sync": {
            "post": {
                "operationId": "run-sync-meilimiao-yt-transcript-captions-api",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "YouTube URLs or video IDs",
                        "type": "array",
                        "description": "YouTube video URLs, Shorts URLs, playlist URLs, channel URLs, or raw 11-character video IDs. Start with a single video to test, then scale to bulk URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "json",
                            "text",
                            "srt",
                            "vtt",
                            "markdown"
                        ],
                        "type": "string",
                        "description": "Choose how transcript text is formatted in formattedTranscript. JSON keeps structured fields only.",
                        "default": "json"
                    },
                    "languages": {
                        "title": "Language priority",
                        "type": "array",
                        "description": "Language codes in priority order. The Actor tries manual captions first, then auto-generated captions.",
                        "default": [
                            "en",
                            "es",
                            "ko"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "translateTo": {
                        "title": "Translate to language",
                        "type": "string",
                        "description": "Optional target language code, e.g. es, fr, de, zh. Uses YouTube built-in translation when available."
                    },
                    "includeMetadata": {
                        "title": "Include video metadata",
                        "type": "boolean",
                        "description": "Include title, channel, duration, views, publish date, thumbnail, description, and tags when available.",
                        "default": true
                    },
                    "includeTimestamps": {
                        "title": "Include timestamped segments",
                        "type": "boolean",
                        "description": "Include per-caption segments with start time, duration, and text.",
                        "default": true
                    },
                    "includeAvailableLanguages": {
                        "title": "Include available languages",
                        "type": "boolean",
                        "description": "Return all transcript languages available on the video.",
                        "default": true
                    },
                    "includeRagChunks": {
                        "title": "Include RAG chunks",
                        "type": "boolean",
                        "description": "Split transcript into chunks suitable for vector databases and RAG pipelines.",
                        "default": false
                    },
                    "chunkSize": {
                        "title": "RAG chunk size",
                        "minimum": 200,
                        "maximum": 8000,
                        "type": "integer",
                        "description": "Approximate max characters per RAG chunk.",
                        "default": 1000
                    },
                    "maxVideos": {
                        "title": "Maximum videos",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Limit total videos processed, useful for channels and playlists.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many videos to process in parallel. Default 2 is recommended for YouTube reliability; increase carefully for large proxy-backed runs.",
                        "default": 2
                    },
                    "fallbackToAnyLanguage": {
                        "title": "Fallback to any language",
                        "type": "boolean",
                        "description": "If requested languages are unavailable, use any available transcript instead of failing.",
                        "default": true
                    },
                    "preserveFormatting": {
                        "title": "Preserve caption formatting",
                        "type": "boolean",
                        "description": "Keep supported HTML formatting tags from YouTube captions.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Recommended: Apify Proxy with RESIDENTIAL group and US country. YouTube often blocks datacenter IPs, especially for bulk transcript extraction.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
