# YouTube Transcript Scraper & Bulk Downloader (`devilscrapes/youtube-transcript-scraper`) Actor

Bulk YouTube transcript downloader and extractor — pull captions (manual or auto-generated) from one video or a whole channel, in any language. Returns plain-text transcript plus timed segments, export to JSON or CSV. We retry and rotate so the captions land.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## YouTube Transcript Scraper

▶️ **[Watch the 45-second demo on YouTube](https://youtube.com/shorts/xCFshXEj0GE)**

**💰 $4.00 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

Bulk-extract YouTube video transcripts — manual or auto-generated captions, in any language. Returns a plain-text transcript plus optional timed segments per cue. Works on regular videos, Shorts, and `youtu.be` links. No API key required.

</div>

---

### 🎯 What this scrapes

YouTube ships closed captions for most videos. This Actor takes a list of video URLs or bare IDs, picks the best available caption track in the language you specify, downloads every cue, and writes one clean row per video. You get the full joined transcript text plus — if you want them — the per-cue segments with start time and duration. Channel name, video title, duration, and the full list of available languages all land in the same row.

We handle the parts that make bulk transcript extraction fragile at scale: rate-limit pushback, endpoint parameter drift, and residential proxy rotation so YouTube sees a real browser session rather than a Python script hitting its timedtext endpoint in a tight loop.

Captions are public metadata published by YouTube. This Actor fetches only what YouTube's own player loads for any viewer. It does not download video files, bypass region locks, or access private or unlisted content.

### 🔥 What we handle for you

- 🛡️ **Browser fingerprint rotation** — `curl-cffi` impersonates real Chrome / Firefox / Safari TLS handshakes so the target sees a browser, not a Python script.
- 🌐 **Residential proxy rotation** via Apify Proxy — fresh session ID and exit IP on every block or rate-limit response.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` — up to 5 attempts per video, `Retry-After` header honoured.
- 🧱 **Rate-limit-aware pacing** — when YouTube pushes back we slow down rather than accumulate bans across the run.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated output, ISO-8601 timestamps, stable IDs. Export as JSON, CSV, or Excel straight from Apify Console.
- 💰 **Pay-Per-Event pricing** — you pay only for rows that land in your dataset. No data, no charge beyond the small run warm-up fee.

### 💡 Use cases

- **RAG corpus seeding** — bulk-download transcripts for a playlist of conference talks, lectures, or podcast episodes and feed them straight into a vector store or LLM context window.
- **YouTube transcript bulk download for NLP** — export hundreds of transcripts at once for sentiment analysis, topic modelling, or fine-tuning data prep.
- **Podcast show-notes automation** — feed each new YouTube-hosted episode through this Actor and into an LLM to generate Markdown show notes automatically.
- **Download YouTube subtitles for language learning** — pull caption tracks in the target language across a playlist for comprehension practice or graded reading corpora.
- **YouTube subtitles dataset construction** — build a reproducible, version-controlled transcript dataset for ML benchmarking, search indexing, or attribution research.
- **YouTube transcript for RAG pipelines** — drop transcripts directly into LangChain, LlamaIndex, or any retrieval-augmented generation stack without preprocessing.

### ⚙️ How to use it

1. Click **Try for free** at the top of the Store listing.
2. Paste YouTube video URLs or bare video IDs into `videoUrls` — one per line, or as a JSON array. Shorts and `youtu.be` links both work.
3. Set `language` to the ISO-639-1 code you want (default `en`). The Actor falls back gracefully through manual tracks, auto-generated tracks, and any available language.
4. Click **Start**. Results stream into the run's dataset in real time.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or pull via the Apify API.

For large lists (hundreds of videos) leave `proxyConfiguration` on its default of `useApifyProxy: true`. On the Apify FREE plan this uses datacenter proxies; upgrading to a paid plan routes through residential IPs, which handle aggressive rate-limiting with a higher success rate.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `videoUrls` | `array` | **yes** | `["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]` | YouTube video URLs or bare video IDs. Shorts and youtu.be links are accepted. |
| `language` | `string` | no | `"en"` | ISO-639-1 language code. Track selection order: manual in requested language → auto in requested language → manual any → auto any. |
| `includeSegments` | `boolean` | no | `true` | When `true`, the `segments` array includes one entry per cue (text + start time + duration). The joined `transcript_text` field is always present regardless. |
| `concurrency` | `integer` | no | `4` | Number of videos processed in parallel. Lower this if you see elevated 429s on a shared datacenter proxy. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | Proxy settings. YouTube rate-limits aggressive runs — residential routing is recommended for lists of 100+ videos. |

#### Example input

```json
{
  "videoUrls": [
    "dQw4w9WgXcQ",
    "https://www.youtube.com/watch?v=9bZkp7q19f0"
  ],
  "language": "en",
  "includeSegments": false,
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### 📤 Output

One dataset row per input video.

| Field | Type | Notes |
|---|---|---|
| `video_id` | `string` | YouTube video ID (11 characters). |
| `video_url` | `string` | Canonical `youtube.com/watch?v=` URL. |
| `title` | `string \| null` | Video title parsed from the watch page. |
| `channel_name` | `string \| null` | Channel display name. |
| `channel_id` | `string \| null` | Channel ID. |
| `duration_seconds` | `integer \| null` | Video duration in seconds. |
| `language` | `string` | Caption track language code actually used. |
| `is_auto_generated` | `boolean` | `true` for YouTube-auto-generated tracks; `false` for manually uploaded captions. |
| `transcript_text` | `string` | Full transcript joined with newlines — ready to paste into an LLM prompt or search index. |
| `segments` | `array \| null` | Per-cue entries with `text`, `start`, and `duration` when `includeSegments` is `true`. |
| `available_languages` | `array` | All caption track language codes available on the video. |
| `scraped_at` | `string` | ISO-8601 timestamp of when this row was written. |

#### Example output

```json
{
  "video_id": "dQw4w9WgXcQ",
  "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up (Official Music Video)",
  "channel_name": "Rick Astley",
  "channel_id": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "duration_seconds": 213,
  "language": "en",
  "is_auto_generated": false,
  "transcript_text": "We're no strangers to love\nYou know the rules and so do I\n...",
  "segments": null,
  "available_languages": ["en", "es", "fr", "de"],
  "scraped_at": "2026-06-01T10:32:14Z"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result` | $0.004 | Per dataset row written |

Example: 1 000 transcripts at these rates ≈ **$4.05**. No subscription, no monthly minimum, no credit card required to start — Apify gives every new account $5 of free credit.

For very large bulk runs (10 000+ transcripts/month) the per-result charge scales linearly: 10k ≈ $40, 100k ≈ $400. If your volume is that high, open an issue on the Actor's Issues tab — we can discuss a volume arrangement.

### 🚧 Limitations

- **Captions disabled by uploader** — some creators turn off captions entirely. Those videos return no transcript row; the Actor logs the skip and moves on.
- **Rate-limiting on large batches** — YouTube pushes back on high-concurrency runs from shared datacenter IPs. Use `proxyConfiguration` with residential routing and keep `concurrency` at 3–5 for lists of 500+ videos.
- **Live streams** — live captions are usually unavailable until the broadcast ends and the VOD is processed. Re-run after the stream concludes.
- **Age-gated / sign-in-required videos** — this Actor does not accept YouTube credentials and cannot retrieve captions from age-restricted content.
- **Parameter drift** — YouTube occasionally rotates its internal timedtext endpoint parameters. When this happens existing runs may return empty transcripts for affected videos. We monitor for this and ship a fix within 48 hours. Check the Actor's CHANGELOG for the latest version.

### ❓ FAQ

**What's the difference between this and the `youtube-transcript-api` Python library?**

The OSS library is great for one-off scripts. This Actor wraps equivalent logic inside Apify's cloud infrastructure, adding proxy rotation, retries, concurrency control, structured output, and the ability to schedule recurring runs — no server required. Use the library for local experiments; use this Actor when you need `youtube transcript bulk download` at scale without managing infrastructure.

**Does it work for `youtube transcript api` access programmatically?**

Yes. Every run's dataset is accessible via the Apify REST API. You can trigger runs, poll for completion, and pull results as JSON in one API call. See [Apify's documentation](https://docs.apify.com/api/v2) for the full reference.

**Can I download YouTube subtitles in languages other than English?**

Yes. Set `language` to any ISO-639-1 code (e.g. `"es"` for Spanish, `"ja"` for Japanese, `"de"` for German). The Actor will select the best matching track and fall back gracefully if the exact language is unavailable. The `available_languages` field in every output row lists what was actually on the video.

**What about `youtube closed captions extract` for auto-generated tracks?**

Auto-generated tracks are fully supported and labelled clearly via the `is_auto_generated` field. Auto tracks are used as a fallback when no manual caption upload exists. Quality varies by video; auto-generated tracks on professionally produced content tend to be accurate.

**What if no captions exist at all?**

The Actor logs the video ID and skips it. We do not synthesise or transcribe audio — that's a different (much more expensive) problem.

**Can I use this for a `youtube transcript for rag` pipeline?**

Exactly the use case we built for. The `transcript_text` field is clean joined text ready for chunking. The `segments` array gives you cue-level timestamps if you want to preserve position information for citation or retrieval. Both fields export as-is into JSON; just point your LangChain `Document` or LlamaIndex `Node` constructor at the dataset.

**Why is `title` or `channel_name` empty?**

If YouTube returns a consent interstitial or a 429 on the watch page during metadata fetch, we still deliver the transcript but leave page-scraped fields null. The transcript itself is retrieved from a separate endpoint and succeeds independently.

### 💬 Your feedback

Spotted a bug, hit a rate-limit pattern we aren't handling, or need a field added? Open an issue on the Actor's **Issues** tab in Apify Console — we read every report and ship fixes on a weekly cadence. For parameter-drift breakages, check the CHANGELOG first; a fix is usually already in `latest`.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `videoUrls` (type: `array`):

List of YouTube video URLs or bare video IDs. Shorts and youtu.be links are accepted.

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

ISO-639-1 language code. Tracks are picked in this order: manual <code>language</code> → auto <code>language</code> → manual any → auto any.

## `includeSegments` (type: `boolean`):

When true, the `segments` array includes one entry per cue (text + start + duration). Always emits the joined `transcript_text`.

## `concurrency` (type: `integer`):

Parallel videos to process.

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

YouTube can throttle aggressive scrapers — sticky residential sessions work best on paid plans; datacenter is fine for small runs.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "language": "en",
  "includeSegments": true,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/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 = {
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Transcript Scraper & Bulk Downloader",
        "description": "Bulk YouTube transcript downloader and extractor — pull captions (manual or auto-generated) from one video or a whole channel, in any language. Returns plain-text transcript plus timed segments, export to JSON or CSV. We retry and rotate so the captions land.",
        "version": "0.4",
        "x-build-id": "8HRqVwax0D5pGAsyA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-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/devilscrapes~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-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/devilscrapes~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-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": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "YouTube videos",
                        "type": "array",
                        "description": "List of YouTube video URLs or bare video IDs. Shorts and youtu.be links are accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Preferred language",
                        "type": "string",
                        "description": "ISO-639-1 language code. Tracks are picked in this order: manual <code>language</code> → auto <code>language</code> → manual any → auto any.",
                        "default": "en"
                    },
                    "includeSegments": {
                        "title": "Include per-cue segments",
                        "type": "boolean",
                        "description": "When true, the `segments` array includes one entry per cue (text + start + duration). Always emits the joined `transcript_text`.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrent fetches",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Parallel videos to process.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "YouTube can throttle aggressive scrapers — sticky residential sessions work best on paid plans; datacenter is fine for small runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
