# Youtube Transcript Scraper (`scrapepilotapi/youtube-transcript-scraper`) Actor

Extract YouTube video transcripts in seconds 🎥📝 Scrape captions, subtitles, timestamps, and spoken text from videos with ease. Perfect for SEO research, content repurposing, sentiment analysis, and audience insights. Turn video speech into useful data fast 🚀

- **URL**: https://apify.com/scrapepilotapi/youtube-transcript-scraper.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (community)
- **Categories:** AI, SEO tools, Videos
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

The Youtube Transcript Scraper is a fast, reliable YouTube transcript extractor that turns video speech into structured text in seconds. It solves the pain of manual transcription by letting you paste video URLs and instantly get captions as plain text or timestamped segments. Built for marketers, developers, data analysts, and researchers, this YouTube transcript downloader scales to multiple videos with language filters and robust proxy support to keep runs stable.

### What data / output can you get?

Below are the exact fields this actor outputs to the Apify dataset for each processed URL. The transcripts can be returned as plain text or detailed timestamped segments depending on your settings. You can download the dataset in multiple formats from Apify for easy analysis and sharing.

| Data type | Description | Example value |
| --- | --- | --- |
| id | YouTube video ID extracted from the input URL | dQw4w9WgXcQ |
| url | Canonical YouTube watch URL built from the video ID | https://www.youtube.com/watch?v=dQw4w9WgXcQ |
| input | The original input URL you provided | https://youtu.be/dQw4w9WgXcQ |
| transcripts | Array of transcript objects, one per available/allowed language | [ { language, content } ] |
| transcripts[].language | Human-readable transcript language label from YouTube Transcript API | English |
| transcripts[].content (text mode) | Full transcript concatenated into a single string | "Intro text … full transcript here" |
| transcripts[].content (timestamp mode) | Array of timed caption parts | [ { startMs, endMs, startTime, text } ] |
| transcripts[].content[].startMs | Start time of the segment in milliseconds | 5000 |
| transcripts[].content[].endMs | End time of the segment in milliseconds | 7320 |
| transcripts[].content[].startTime | Human-readable start time in m:ss format | 0:05 |
| transcripts[].content[].text | Caption text for the segment | "We're no strangers to love" |

Note: If a video has no available transcripts (e.g., no captions), the transcripts array will be empty. You can export results from the Apify dataset in formats like JSON, CSV, or Excel.

### Key features

- 🚀 Bold speed, simple results – Paste YouTube URLs and get transcripts fast, either as plain text or timestamped segments to extract YouTube captions with precision.
- 🌍 Multilingual filtering – Choose whether to include English auto-generated captions and/or non-English transcripts for cleaner datasets tailored to your needs.
- 📦 Batch processing at scale – Provide multiple URLs and process them in one run. Each completed video is pushed to the dataset immediately.
- 🧭 Two output modes – Switch between "timestamp" for detailed caption segments or "text" for a single consolidated transcript. Perfect to export YouTube transcripts in the format you need.
- 🛡️ Proxy-first reliability – Uses Apify RESIDENTIAL proxy by default to reduce YouTube IP blocks and improve stability over large jobs.
- 🧪 Developer-friendly – Built on the youtube-transcript-api and Apify SDK (Python), with clear JSON outputs for easy integration into pipelines or a YouTube transcript API workflow.
- 🔌 No browser, no login – Works without headless browsers or account auth. A lightweight, robust way to download YouTube transcripts and subtitles at scale.
- ⏱️ Streamed dataset writes – Results are saved as each URL finishes, making it easy to monitor progress and consume partial results early.

### How to use Youtube Transcript Scraper - step by step

1. Sign in to Apify – Create an account or log in to your Apify workspace.
2. Open the actor – Find “Youtube Transcript Scraper” in the Apify Store and click Try for free.
3. Add input URLs – Paste one or more YouTube video links into the urls array.
4. Choose output mode – Set outputFormat to "text" for a single consolidated transcript or "timestamp" for detailed segments.
5. Configure languages – Use includeEnglishAG and includeNonEnglish to control which captions are included (e.g., auto-generated English vs. non-English).
6. Set proxy options (optional) – Leave the default to use Apify RESIDENTIAL proxies, or customize proxyConfiguration if needed.
7. Run the actor – Click Start. Each URL’s result is pushed to the dataset as soon as it finishes.
8. Download results – Open the run’s dataset and export your results in your preferred format (e.g., JSON, CSV, Excel).

Pro tip: Automate your pipeline by triggering this run via the Apify API and feeding results into your analytics stack to convert YouTube captions to text at scale.

### Use cases

| Use case name | Description |
| --- | --- |
| SEO research + content repurposing | Extract transcripts to create articles, briefs, and summaries from YouTube videos and export YouTube transcripts for fast content production. |
| Marketing snippets + social copy | Pull quotable lines and highlights from timestamped captions for campaigns and posts using a YouTube caption scraper. |
| Academic research + text mining | Collect large volumes of lecture/interview transcripts for topic modeling and qualitative analysis with a YouTube transcript tool. |
| Product + UX research | Analyze spoken feedback and demos from video reviews by downloading YouTube transcripts as structured text. |
| Accessibility workflows | Generate text alternatives for videos by using timestamp mode to create detailed caption segments. |
| Developer pipelines (API) | Use the JSON outputs in data pipelines, chatbots, or retrieval systems as a YouTube transcript API alternative. |
| Localization audits | Filter for English auto-generated or non-English tracks to assess caption coverage across markets. |

### Why choose Youtube Transcript Scraper?

A precise, production-ready YouTube subtitle extractor built for automation and reliability.

- 🎯 Accurate transcript capture – Uses the trusted youtube-transcript-api for consistent results to get transcripts from YouTube videos.
- 🌐 Language controls – Include or exclude English auto-generated and non-English transcripts for clean, purposeful datasets.
- ⚡ Scales with your list – Process multiple video URLs in one run with streamed dataset writes for immediate access.
- 🧑‍💻 Developer-ready JSON – Clean, documented fields that slot into scripts and workflows without extra parsing.
- 🧰 Fewer moving parts – No browsers, cookies, or login required — more stable than extension-based alternatives.
- 🧩 Dataset exports – Pull down structured results from the Apify dataset in the formats your team needs.
- 🛡️ Built-in resilience – Defaults to Apify RESIDENTIAL proxies to reduce blocks and keep throughput high.

In short: a dependable YouTube transcript downloader vs. browser extensions or unstable tools, purpose-built for teams that need structured, automatable outputs.

### Is it legal / ethical to use Youtube Transcript Scraper?

Yes, when used responsibly. This tool retrieves transcript data exposed by YouTube for public videos and does not access private or authenticated content.

Guidelines for responsible use:
- Only process videos that are publicly accessible.
- Review and comply with YouTube’s Terms of Service for your specific use case.
- Use the data ethically and respect creator rights; obtain permission if republishing transcripts.
- Consider applicable data protection regulations in your jurisdiction.
- Consult your legal team for edge cases or commercial redistribution.

### Input parameters & output format

Example JSON input
```json
{
  "urls": [
    "https://www.youtube.com/watch?v=4KbrxIpQgkM",
    "https://youtu.be/dQw4w9WgXcQ"
  ],
  "includeEnglishAG": true,
  "includeNonEnglish": false,
  "outputFormat": "timestamp",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

Input fields (from schema):

- urls (array, required) – One or more YouTube video URLs to process. Each completed URL is appended immediately to the dataset. Default: \[].
- includeEnglishAG (boolean) – Whether to include English auto-generated transcripts. Default: true.
- includeNonEnglish (boolean) – Whether to include non-English transcripts. Default: false.
- outputFormat (string; enum: "timestamp", "text") – Format of transcript output: "timestamp" returns detailed timestamps, "text" returns plain text. Default: "text".
- proxyConfiguration (object) – Proxy configuration. Uses Apify RESIDENTIAL proxy by default to bypass YouTube IP blocking. If not configured, will try to use Apify proxy automatically. Default: {}.

Behavior note:

- If a video has no available captions matching your filters, transcripts will be an empty array.
- Each input URL produces one dataset item as soon as it finishes.

Example JSON output (timestamp mode)

```json
{
  "id": "dQw4w9WgXcQ",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "input": "https://youtu.be/dQw4w9WgXcQ",
  "transcripts": [
    {
      "language": "English",
      "content": [
        {
          "startMs": 5000,
          "endMs": 7320,
          "startTime": "0:05",
          "text": "We're no strangers to love"
        },
        {
          "startMs": 7320,
          "endMs": 10500,
          "startTime": "0:07",
          "text": "You know the rules and so do I"
        }
      ]
    }
  ]
}
```

Example JSON output (text mode)

```json
{
  "id": "4KbrxIpQgkM",
  "url": "https://www.youtube.com/watch?v=4KbrxIpQgkM",
  "input": "https://www.youtube.com/watch?v=4KbrxIpQgkM",
  "transcripts": [
    {
      "language": "English",
      "content": "Intro text … full transcript concatenated into a single string."
    }
  ]
}
```

### FAQ

#### Can this tool get a transcript from a YouTube video?

Yes. If a video has captions/transcripts available, the actor will fetch them and output either plain text or timestamped segments based on your settings.

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

Yes. You can include English auto-generated captions by setting includeEnglishAG to true. If you prefer to exclude them, set it to false.

#### Can I download subtitles from YouTube in different languages?

Yes. Control non-English transcripts with includeNonEnglish. Set it to true to include non-English tracks or false to exclude them.

#### How do I choose between plain text and timestamps?

Use the outputFormat input. Set "text" to convert YouTube captions to a single string, or "timestamp" for detailed segments with startMs, endMs, startTime, and text.

#### How many videos can I process at once?

You can pass multiple URLs in the urls array. The actor processes them in one run and pushes each result to the dataset as soon as it’s ready.

#### Does it use a YouTube transcript API under the hood?

It relies on the youtube-transcript-api library to retrieve caption tracks exposed by YouTube, making it a dependable YouTube subtitle extractor for automation.

#### Do I need a browser, cookies, or login?

No. This tool does not use a browser or require login. It fetches public transcript data programmatically, making it more stable than a typical YouTube transcript Chrome extension.

#### Can I export results for use in other tools?

Yes. After the run, open the Apify dataset and export your results in formats suitable for analysis and reporting, making it easy to integrate with downstream workflows.

### Closing CTA / Final thoughts

The Youtube Transcript Scraper is built to extract clean, structured transcripts from YouTube videos quickly and reliably. With language filters, two output modes, batch processing, and proxy-backed stability, it’s ideal for marketers, researchers, analysts, and developers. Use the JSON outputs as a lightweight YouTube transcript API in your pipelines, or export datasets for reporting. Start extracting smarter, timestamped or plain-text captions today and turn video speech into actionable data at scale.

# Actor input Schema

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

One or more YouTube video URLs to process. Each completed URL is appended immediately to the dataset.

## `includeEnglishAG` (type: `boolean`):

Whether to include English auto-generated transcripts

## `includeNonEnglish` (type: `boolean`):

Whether to include non-English transcripts

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

Format of transcript output: 'timestamp' returns detailed timestamps, 'text' returns plain text

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

Proxy configuration. Uses Apify RESIDENTIAL proxy by default to bypass YouTube IP blocking. If not configured, will try to use Apify proxy automatically.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=4KbrxIpQgkM"
  ],
  "includeEnglishAG": true,
  "includeNonEnglish": false,
  "outputFormat": "text",
  "proxyConfiguration": {}
}
```

# 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=4KbrxIpQgkM"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilotapi/youtube-transcript-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 = { "urls": ["https://www.youtube.com/watch?v=4KbrxIpQgkM"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapepilotapi/youtube-transcript-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 '{
  "urls": [
    "https://www.youtube.com/watch?v=4KbrxIpQgkM"
  ]
}' |
apify call scrapepilotapi/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Transcript Scraper",
        "description": "Extract YouTube video transcripts in seconds 🎥📝 Scrape captions, subtitles, timestamps, and spoken text from videos with ease. Perfect for SEO research, content repurposing, sentiment analysis, and audience insights. Turn video speech into useful data fast 🚀",
        "version": "0.1",
        "x-build-id": "gI3oUQ4clYLoC0vjM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-youtube-transcript-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/scrapepilotapi~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-youtube-transcript-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/scrapepilotapi~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-youtube-transcript-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "YouTube URLs",
                        "type": "array",
                        "description": "One or more YouTube video URLs to process. Each completed URL is appended immediately to the dataset.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeEnglishAG": {
                        "title": "Include English Auto-Generated",
                        "type": "boolean",
                        "description": "Whether to include English auto-generated transcripts",
                        "default": true
                    },
                    "includeNonEnglish": {
                        "title": "Include Non-English Transcripts",
                        "type": "boolean",
                        "description": "Whether to include non-English transcripts",
                        "default": false
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "timestamp",
                            "text"
                        ],
                        "type": "string",
                        "description": "Format of transcript output: 'timestamp' returns detailed timestamps, 'text' returns plain text",
                        "default": "text"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy configuration. Uses Apify RESIDENTIAL proxy by default to bypass YouTube IP blocking. If not configured, will try to use Apify proxy automatically.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```