# YouTube Transcript Scraper – JSON, SRT, VTT, Plain Text (`scraperhive/youtube-transcript-scraper`) Actor

Extract YouTube video transcripts, subtitles, and captions in multiple formats with precise timestamps.
Plain Text · JSON · SRT · WebVTT · 20+ Languages · Batch Processing · Auto + Manual Captions

- **URL**: https://apify.com/scraperhive/youtube-transcript-scraper.md
- **Developed by:** [Mubeen Ali](https://apify.com/scraperhive) (community)
- **Categories:** Automation, Developer tools, Social media
- **Stats:** 67 total users, 16 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $10.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.

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 Extractor — Subtitles, Captions, SRT, VTT, JSON

Scrap YouTube video transcripts, subtitles, and captions in multiple formats with precise timestamps. Perfect for content creators, researchers, developers, and accessibility professionals who need reliable transcript data from YouTube videos.

### 📋 Overview
Extract YouTube video transcripts, subtitles, and captions in multiple formats with precise timestamps.
Plain Text · JSON · SRT · WebVTT · 20+ Languages · Batch Processing · Auto + Manual Captions. 

### 📋 What Is This Actor?

**YouTube Transcript Extractor** is an Apify Actor that scrapes YouTube video transcripts, subtitles, and captions directly — no YouTube API key required. It supports every major output format (Plain Text, JSON, SRT, WebVTT), 20+ languages, and batch processing of multiple videos in a single run.

Whether you need transcripts for AI training data, content repurposing, accessibility compliance, SEO optimization, research, or video editing — this is the fastest and most flexible YouTube caption scraper on Apify.

### ✨ Key Features

| Feature | Details |
|---|---|
| **Output Formats** | Plain Text, JSON, SRT (SubRip), WebVTT |
| **Language Support** | 20+ languages: English, Hindi, Spanish, Chinese, French, German, Arabic, Portuguese, and more |
| **Timestamp Precision** | Start time, end time, and duration per segment |
| **Batch Processing** | Process multiple YouTube videos in a single run |
| **Caption Priority** | Fetches manually created transcripts first; falls back to auto-generated captions |
| **Flexible Input** | Accepts YouTube video URLs (all formats) or raw video IDs |
| **Clean Output** | Strips HTML tags and formatting artifacts automatically |
| **Segment Indexing** | Every segment is numbered for easy navigation and reference |

### 🎯 Who Is This For?

- **Content Creators** — Repurpose video scripts into blog posts, newsletters, or social media threads
- **AI & ML Engineers** — Build training datasets from YouTube video transcripts at scale
- **Researchers & Academics** — Analyze video content, run NLP, sentiment analysis, or topic modeling
- **SEO Professionals** — Extract transcripts to add keyword-rich text to video landing pages
- **Accessibility Professionals** — Generate captions and subtitles compliant with WCAG/ADA standards
- **Journalists & Fact-Checkers** — Quickly search and quote spoken content from YouTube videos
- **Developers** — Integrate YouTube transcript data into apps, bots, and pipelines via the Apify API


### 📥 Input Configuration

Configure the actor using the following input parameters:

#### Required Parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `videoUrls` | Array | **Required.** List of YouTube video URLs or video IDs to process |

#### Optional Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `languages` | Array | `["en"]` | Preferred language codes for transcripts (e.g., `["en", "hi", "es"]`) |
| `outputFormat` | String | `"text"` | Output format: `"text"`, `"json"`, `"webvtt"`, or `"srt"` |
| `preserveFormatting` | Boolean | `false` | Preserve HTML formatting tags in transcript (only for WebVTT/JSON formats) |

#### Supported URL Formats

The actor accepts YouTube videos in multiple URL formats:

- Standard: `https://www.youtube.com/watch?v=VIDEO_ID`
- Short: `https://youtu.be/VIDEO_ID`
- Direct ID: `VIDEO_ID` (11-character alphanumeric code)

### 🌐 Supported Languages

English · Hindi · Spanish · Chinese (Simplified) · French · German · Arabic · Portuguese · Russian · Japanese · Korean · Italian · Dutch · Turkish · Polish · Swedish · Danish · Norwegian · Finnish · Indonesian · and more.

Pass a standard BCP-47 language code (e.g., `en`, `hi`, `es`, `zh`, `fr`, `de`, `ar`) in the `language` input field.

### 🚀 How to Use

#### Option 1: Run on Apify Console (No Code)

1. Go to [YouTube Transcript Extractor on Apify](https://apify.com/scraperhive/youtube-transcript-extractor)
2. Click **Try for free**
3. Paste your YouTube URLs into the input
4. Select your language and output format
5. Click **Start** and download your transcript

#### Option 2: Run via Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/scraperhive~youtube-transcript-extractor/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "language": "en",
    "outputFormat": "json"
  }'
````

#### Option 3: Run via Apify Python Client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "language": "en",
    "outputFormat": "json",
}

run = client.actor("scraperhive/youtube-transcript-extractor").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Option 4: Run via Apify JavaScript Client

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('scraperhive/youtube-transcript-extractor').call({
  videoUrls: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
  language: 'en',
  outputFormat: 'srt',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 💡 Use Case Examples

#### 1. Generate AI Training Data from YouTube

Extract thousands of transcripts at scale for LLM fine-tuning, speech recognition training, or semantic search indexing.

```json
{
  "videoUrls": ["VIDEO_URL_1", "VIDEO_URL_2", "VIDEO_URL_3"],
  "language": "en",
  "outputFormat": "json"
}
```

#### 2. Create SRT Subtitle Files for Video Editing

Download SRT caption files compatible with Premiere Pro, DaVinci Resolve, Final Cut, and any subtitle editor.

```json
{
  "videoUrls": ["https://www.youtube.com/watch?v=VIDEO_ID"],
  "language": "es",
  "outputFormat": "srt"
}
```

#### 3. Extract Transcripts in Hindi or Other Languages

Get transcripts directly in your target language without translation overhead.

```json
{
  "videoUrls": ["https://www.youtube.com/watch?v=VIDEO_ID"],
  "language": "hi",
  "outputFormat": "text"
}
```

#### 4. Batch Process a List of Videos

Provide an array of URLs to extract transcripts from multiple videos in one run.

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=ID_1",
    "https://www.youtube.com/watch?v=ID_2",
    "https://www.youtube.com/watch?v=ID_3"
  ],
  "outputFormat": "vtt"
}
```

### ⚖️ YouTube Transcript Extractor vs Competitors

| Feature | This Actor | Basic Scrapers |
|---|---|---|
| Output: Plain Text | ✅ | ✅ |
| Output: JSON with timestamps | ✅ | ⚠️ Partial |
| Output: SRT | ✅ | ❌ |
| Output: WebVTT | ✅ | ❌ |
| Segment-level timestamps | ✅ (start + end + duration) | ⚠️ Start only |
| 20+ language support | ✅ | ⚠️ English only |
| Batch multi-video processing | ✅ | ⚠️ Limited |
| Manual caption priority | ✅ | ❌ |
| Clean HTML-stripped output | ✅ | ⚠️ Raw HTML artifacts |
| Segment index numbering | ✅ | ❌ |

### 📤 Output Structure

Each successfully processed video generates a structured result containing transcript data, metadata, and segments.

#### Output Fields

| Field                      | Type         | Description                                                      |
| -------------------------- | ------------ | ---------------------------------------------------------------- |
| `format`                   | String       | The output format used (`"text"`, `"json"`, `"webvtt"`, `"srt"`) |
| `metadata`                 | Object       | Video and transcript metadata                                    |
| `metadata.videoId`         | String       | YouTube video ID                                                 |
| `metadata.videoUrl`        | String       | Full YouTube video URL                                           |
| `metadata.language`        | String       | Language code of the transcript                                  |
| `metadata.isAutoGenerated` | Boolean      | Whether the transcript is auto-generated or manual               |
| `transcript`               | String/Array | Formatted transcript (format depends on `outputFormat`)          |
| `segments`                 | Array        | Array of transcript segments with timestamps                     |
| `success`                  | Boolean      | Always `true` for successful extractions                         |

#### Segment Structure

Each segment in the `segments` array contains:

| Field      | Type   | Description                                 |
| ---------- | ------ | ------------------------------------------- |
| `index`    | Number | Sequential segment number (starting from 1) |
| `text`     | String | Transcript text for this segment            |
| `start`    | Number | Start time in seconds                       |
| `end`      | Number | End time in seconds                         |
| `duration` | Number | Duration of the segment in seconds          |

### 💰 Pricing

**Pay-per-Result Model**: **$10.00 per 1,000 successful results**

- ✅ You are charged **only for successful transcript extractions**
- ❌ Failed videos (no captions, private, unavailable, rate-limited) are **not charged**
- 📊 Each successfully processed video which have transcripts counts as **one result**

### ❓ Frequently Asked Questions (FAQ)

**Q: Which YouTube video formats are supported?**
A: Standard YouTube URLs, short `youtu.be` URLs, and direct 11-character video IDs are supported.

**Q: Can I extract transcripts from private, unlisted, or age-restricted videos?**
A: No. Only publicly available videos with enabled captions can be processed.

**Q: What happens if a video has no captions available?**
A: The extraction fails gracefully and you are **not charged** for that video.

**Q: What is the difference between manual and auto-generated transcripts?**
A: Manual transcripts are uploaded by the creator and are usually more accurate. Auto-generated transcripts are created by YouTube and may contain errors. The actor prioritizes manual transcripts.

**Q: Which output format should I use?**
A: Text for reading and SEO, JSON for APIs and AI workflows, SRT for video editing, and WebVTT for web video players.

**Q: Does this actor download or store YouTube videos?**
A: No. It only extracts publicly available transcript and caption data.

**Note**: This actor complies with YouTube's Terms of Service. Users are responsible for ensuring their usage respects copyright laws and content ownership rights.

# Actor input Schema

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

List of YouTube video URLs or video IDs. Supports formats: \[URL] \[URL] or direct video ID

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

Select desired languages. The actor will try to find transcripts in these languages.

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

Format for the transcript output

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

Preserve line breaks and formatting in the transcript (if available)

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "languages": [
    "en",
    "tr",
    "it"
  ],
  "outputFormat": "json",
  "preserveFormatting": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=qwI3ApgCQ_E"
    ],
    "languages": [
        "en"
    ],
    "outputFormat": "json",
    "preserveFormatting": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperhive/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=qwI3ApgCQ_E"],
    "languages": ["en"],
    "outputFormat": "json",
    "preserveFormatting": False,
}

# Run the Actor and wait for it to finish
run = client.actor("scraperhive/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=qwI3ApgCQ_E"
  ],
  "languages": [
    "en"
  ],
  "outputFormat": "json",
  "preserveFormatting": false
}' |
apify call scraperhive/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Transcript Scraper – JSON, SRT, VTT, Plain Text",
        "description": "Extract YouTube video transcripts, subtitles, and captions in multiple formats with precise timestamps.\nPlain Text · JSON · SRT · WebVTT · 20+ Languages · Batch Processing · Auto + Manual Captions",
        "version": "1.0",
        "x-build-id": "zFqNKzX2Um6yHX6yD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperhive~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperhive-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/scraperhive~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperhive-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/scraperhive~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperhive-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": "Video URLs or IDs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "List of YouTube video URLs or video IDs. Supports formats: [URL] [URL] or direct video ID",
                        "items": {
                            "type": "string"
                        }
                    },
                    "languages": {
                        "title": "Preferred Languages",
                        "type": "array",
                        "description": "Select desired languages. The actor will try to find transcripts in these languages.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en",
                                "en-GB",
                                "en-US",
                                "hi",
                                "es",
                                "zh-Hans",
                                "zh-Hant",
                                "fr",
                                "de",
                                "pt",
                                "pt-BR",
                                "ru",
                                "ja",
                                "ko",
                                "tr",
                                "it",
                                "ar",
                                "vi",
                                "id",
                                "th"
                            ],
                            "enumTitles": [
                                "English (en)",
                                "English (United Kingdom) (en-GB)",
                                "English (United States) (en-US)",
                                "Hindi (hi)",
                                "Spanish (es)",
                                "Chinese Simplified (zh-Hans)",
                                "Chinese Traditional (zh-Hant)",
                                "French (fr)",
                                "German (de)",
                                "Portuguese (pt)",
                                "Portuguese (Brazil) (pt-BR)",
                                "Russian (ru)",
                                "Japanese (ja)",
                                "Korean (ko)",
                                "Turkish (tr)",
                                "Italian (it)",
                                "Arabic (ar)",
                                "Vietnamese (vi)",
                                "Indonesian (id)",
                                "Thai (th)"
                            ]
                        },
                        "default": [
                            "en"
                        ]
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "text",
                            "json",
                            "webvtt",
                            "srt"
                        ],
                        "type": "string",
                        "description": "Format for the transcript output",
                        "default": "text"
                    },
                    "preserveFormatting": {
                        "title": "Preserve Formatting",
                        "type": "boolean",
                        "description": "Preserve line breaks and formatting in the transcript (if available)",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```