# Youtube Transcription Scraper (`hgservices/youtube-transcript-scraper`) Actor

Get the full transcript of any YouTube video in seconds.Paste a video link, a list of links, or a whole YouTube playlist, and download clean transcripts, captions, and subtitles as TXT, SRT, or JSON. No YouTube API key. No quotas. No browser extensions. Works on single videos or thousands at a time.

- **URL**: https://apify.com/hgservices/youtube-transcript-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** Automation, AI, Videos
- **Stats:** 4 total users, 2 monthly users, 60.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## YouTube Transcript Scraper — download YouTube transcripts, captions & subtitles

**Get the full transcript of any YouTube video in seconds.** Paste a video link, a list of links, or a whole **YouTube playlist** — and download clean **transcripts, captions, and subtitles** as **TXT, SRT, or JSON**. No YouTube API key. No quotas. No browser extensions. Works on single videos or thousands at a time.

Whether you need a quick **YouTube to text** conversion, **SRT subtitles** for a video editor, or structured **JSON transcripts** to feed an LLM for summarization, this Actor handles it in one click — or one API call.

> **New to Apify?** [Sign up for a free account](https://apify.com?fpr=wfhpok) and you'll get **$5 in free platform credits every month, forever** — enough to transcribe **thousands of YouTube videos** without spending a cent. No credit card required.

### Why use this YouTube Transcript Scraper?

Most YouTube transcript scrapers force you to do **one video at a time** with **no options** — you paste a URL, you get plain text, end of story. This Actor was built for people who actually have work to do.

- **Bulk downloads** — paste **hundreds of URLs in a single run**, or even mix video URLs, video IDs, and playlist links together. No queueing up runs one by one.
- **Full playlist support** — drop in any **YouTube playlist URL** and get every video transcribed in one go. No manually expanding the playlist yourself.
- **Three output formats** — **TXT** for reading, **SRT** for subtitling/video editors, **JSON** for AI pipelines and code. Pick what you need; don't post-process.
- **Multi-language with priority fallback** — list languages in order (e.g. `en`, then `es`, then `pt`) and the Actor picks the best match. Manual captions are preferred over auto-generated.
- **Built-in translation** — translate any video's transcript into any language YouTube supports without a second tool.
- **Smart segment merging** — turn YouTube's choppy 2-second caption fragments into clean, readable sentences and paragraphs — perfect for blog posts and LLM prompts.
- **Format control** — keep or strip `[MM:SS]` timestamps, preserve original `<b>`/`<i>` tags, your call.
- **No API key, no quotas** — paste, click, done. Or call it from the Apify API and integrate with **Make, Zapier, n8n, Google Sheets**, your CRM, or any LLM workflow.
- **Reliable on blocks** — handles manual *and* auto-generated captions, gracefully falls back when one is missing, and **rotates connections automatically** when YouTube blocks the cheap path — so big jobs actually finish.

#### How it compares

| Feature | Most YouTube transcript Actors | **This Actor** |
| --- | :---: | :---: |
| Multiple URLs per run | ❌ One video at a time | ✅ Unlimited |
| Playlist URL support | ❌ | ✅ Auto-expanded |
| Output formats | TXT only | ✅ **TXT, SRT, JSON** |
| Language preference list | ❌ | ✅ Priority fallback |
| Translation to other languages | ❌ | ✅ |
| Merge fragmented captions | ❌ | ✅ |
| Strip/keep timestamps | ❌ | ✅ |
| Auto proxy rotation on blocks | ❌ Run fails | ✅ Auto-escalation |
| Per-video error reporting | ❌ Whole run fails | ✅ Failed video flagged, rest succeed |
| API + integrations (Make, Zapier, n8n) | Sometimes | ✅ |

### What can I do with YouTube transcripts?

- **Summarize long videos with AI** — pipe the JSON output straight into ChatGPT, Claude, Gemini, or your own RAG pipeline.
- **Repurpose video into blog posts, newsletters, and social clips** — start from a clean text transcript instead of typing.
- **SEO and content research** — search across hundreds of competitor videos for keywords, topics, or product mentions.
- **Add subtitles to your own videos** — export SRT and drop it into Premiere, Final Cut, CapCut, or DaVinci Resolve.
- **Localize content** — translate any video's transcript to English, Spanish, French, German, Hindi, Japanese, and more.
- **Make videos accessible** — generate readable text versions for screen readers and the hearing-impaired.
- **Academic research** — build datasets from lectures, podcasts, interviews, and conference talks.

### How to use the YouTube Transcript Scraper

1. Click **Try for free** at the top of this page.
2. Paste one or more **YouTube video URLs**, video IDs, or a **playlist URL** into the **YouTube URLs** field.
3. Pick an output format — **TXT**, **SRT**, or **JSON**.
4. *(Optional)* Set a preferred language, translate to another language, or merge segments into paragraphs.
5. Click **Start**. When the run finishes, open the **Output** tab to view, download, or export results as **JSON, CSV, Excel, HTML, or RSS**.

You can also trigger runs and pull results programmatically via the [Apify API](https://docs.apify.com/api) — perfect for scheduled jobs, webhooks, and integrations.

### Input options

| Field | What it does |
| --- | --- |
| **YouTube URLs** *(required)* | Video URLs, video IDs, or playlist URLs. Mix and match. |
| **Output Format** | `TXT` (readable), `SRT` (subtitles), or `JSON` (structured). |
| **Preferred Languages** | Language codes in priority order, e.g. `en`, `es`. Empty = auto-detect, prefers human captions over auto-generated. |
| **Translate To** | Language code to translate the transcript into. |
| **Merge Segments** | Combines fragmented captions into clean sentences and paragraphs. |
| **Omit Timestamps** | Strips `[MM:SS]` markers from TXT output. |
| **Expand Playlists** | If a playlist URL is provided, fetch transcripts for every video in it. |
| **Preserve Formatting** | Keeps original `<b>`, `<i>` tags from YouTube's caption track. |

### Example output

You can download the dataset in **JSON, CSV, Excel, HTML, or RSS**.

```json
{
    "videoId": "dQw4w9WgXcQ",
    "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "format": "json",
    "segmentCount": 58,
    "transcript": [
        { "text": "We're no strangers to love", "start": 18.8, "duration": 4.16 },
        { "text": "You know the rules and so do I", "start": 23.0, "duration": 3.2 }
    ]
}
````

| Field | Description |
| --- | --- |
| `videoId` | YouTube video ID. |
| `url` | Original video URL. |
| `format` | Format used for the transcript. |
| `segmentCount` | Number of caption segments returned. |
| `transcript` | Array of `{ text, start, duration }` segments — ready for AI, search, or rendering. |
| `translatedTo` | Target language, if translation was requested. |

### How much does it cost to scrape YouTube transcripts?

Apify uses **pay-per-usage** pricing — you only pay for the compute and storage your run actually consumes. A typical short video transcript completes in seconds and costs **fractions of a cent**.

**Don't have an Apify account yet?** [Create one free here](https://apify.com?fpr=wfhpok) and get **$5 of platform credits every single month, free forever** — that's enough for **thousands of YouTube transcripts** at no cost. No credit card, no trial timer, no catch. Need to transcribe a whole channel or playlist library? Schedule a run, walk away, and pick up the dataset when it's done.

### FAQ

**Do I need a YouTube API key?**
No. The Actor pulls publicly-available caption data the same way your browser does. No Google Cloud project, no OAuth, no quota.

**Which videos can it transcribe?**
Any public YouTube video that has captions — manually-written or auto-generated. Videos with captions disabled by the uploader, private videos, or region-locked videos cannot be processed; those return an error item in the dataset so you always know which ones failed and why.

**Can it transcribe live streams or Shorts?**
Yes — as long as YouTube has generated captions for them.

**Can I translate a transcript into another language?**
Yes. Set **Translate To** to any language code YouTube supports for that video (e.g. `en`, `es`, `fr`, `de`, `hi`, `ja`, `pt`).

**Is YouTube scraping legal?**
This Actor only reads publicly-visible caption data. You remain responsible for complying with [YouTube's Terms of Service](https://www.youtube.com/t/terms) and applicable laws — don't use it for copyright violation or to scrape private content.

**Do I really get $5 free every month?**
Yes — the Apify free plan gives every account **$5 of platform credits per month, forever**, no credit card required. That covers thousands of YouTube transcripts. [Sign up here to claim it.](https://apify.com?fpr=wfhpok)

**Found a bug or have a feature request?**
Open an issue on the **Issues** tab of this Actor in Apify Console. For custom scraping projects, get in touch through [apify.com](https://apify.com?fpr=wfhpok).

# Actor input Schema

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

One or more YouTube video URLs, video IDs, or playlist URLs to fetch transcripts for. Mix and match — videos, IDs, playlists, all in the same run.

## `format` (type: `string`):

Format of the transcript output.

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

Language codes in priority order, e.g. \['en', 'es']. Leave empty to default to English (with fallback to the original language). Set this if you want a non-English transcript — e.g. \['es'] for a Spanish video.

## `translate` (type: `string`):

Translate the transcript to this language code (e.g. 'en', 'es', 'fr'). Uses the best available source transcript.

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

Keep HTML formatting tags from the original transcript (e.g. <b>, <i>).

## `merge` (type: `boolean`):

Combine YouTube's choppy 2-second caption fragments into clean sentences and paragraphs — perfect for blog posts, summaries, and LLM prompts. Turn off if you need raw segment-level timing (e.g. for SRT subtitles).

## `noTimestamps` (type: `boolean`):

Remove \[MM:SS] timestamps from TXT output.

## `includePlaylist` (type: `boolean`):

If a playlist URL is provided, expand it to fetch transcripts for all videos in the playlist.

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

Optional override. By default the actor auto-selects and escalates proxies (no proxy → datacenter → residential) on YouTube blocks, so most users can leave this alone. Setting a value here disables auto-escalation.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://www.youtube.com/watch?v=f2O6mQkFiiw"
    },
    {
      "url": "https://www.youtube.com/watch?v=R0JKCYZ8hng"
    }
  ],
  "format": "txt",
  "languages": [],
  "translate": "",
  "preserveFormatting": false,
  "merge": true,
  "noTimestamps": false,
  "includePlaylist": true,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `transcripts` (type: `string`):

Default dataset containing one item per processed YouTube video.

# 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": [
        {
            "url": "https://www.youtube.com/watch?v=f2O6mQkFiiw"
        },
        {
            "url": "https://www.youtube.com/watch?v=R0JKCYZ8hng"
        }
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Transcription Scraper",
        "description": "Get the full transcript of any YouTube video in seconds.Paste a video link, a list of links, or a whole YouTube playlist, and download clean transcripts, captions, and subtitles as TXT, SRT, or JSON. No YouTube API key. No quotas. No browser extensions. Works on single videos or thousands at a time.",
        "version": "0.1",
        "x-build-id": "Gfss9zYPtIcfN4cb1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-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/hgservices~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-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/hgservices~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-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, video IDs, or playlist URLs to fetch transcripts for. Mix and match — videos, IDs, playlists, all in the same run.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "format": {
                        "title": "Output Format",
                        "enum": [
                            "txt",
                            "srt",
                            "json"
                        ],
                        "type": "string",
                        "description": "Format of the transcript output.",
                        "default": "txt"
                    },
                    "languages": {
                        "title": "Preferred Languages",
                        "type": "array",
                        "description": "Language codes in priority order, e.g. ['en', 'es']. Leave empty to default to English (with fallback to the original language). Set this if you want a non-English transcript — e.g. ['es'] for a Spanish video.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "translate": {
                        "title": "Translate To",
                        "type": "string",
                        "description": "Translate the transcript to this language code (e.g. 'en', 'es', 'fr'). Uses the best available source transcript.",
                        "default": ""
                    },
                    "preserveFormatting": {
                        "title": "Preserve Formatting",
                        "type": "boolean",
                        "description": "Keep HTML formatting tags from the original transcript (e.g. <b>, <i>).",
                        "default": false
                    },
                    "merge": {
                        "title": "Merge Segments into Readable Paragraphs",
                        "type": "boolean",
                        "description": "Combine YouTube's choppy 2-second caption fragments into clean sentences and paragraphs — perfect for blog posts, summaries, and LLM prompts. Turn off if you need raw segment-level timing (e.g. for SRT subtitles).",
                        "default": true
                    },
                    "noTimestamps": {
                        "title": "Omit Timestamps",
                        "type": "boolean",
                        "description": "Remove [MM:SS] timestamps from TXT output.",
                        "default": false
                    },
                    "includePlaylist": {
                        "title": "Expand Playlists",
                        "type": "boolean",
                        "description": "If a playlist URL is provided, expand it to fetch transcripts for all videos in the playlist.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration (advanced)",
                        "type": "object",
                        "description": "Optional override. By default the actor auto-selects and escalates proxies (no proxy → datacenter → residential) on YouTube blocks, so most users can leave this alone. Setting a value here disables auto-escalation.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```