# YouTube Transcript Scraper (`akash9078/youtube-transcript-scraper`) Actor

YouTube Transcript Scraper  & Extractor API — Extract transcripts, captions & subtitles from YouTube videos, Shorts & VODs without an API key. Supports auto-generated and manual captions in 100+ languages with translation, batch extraction & clean JSON for AI agents, RAG, SEO & automation.

- **URL**: https://apify.com/akash9078/youtube-transcript-scraper.md
- **Developed by:** [Akash Kumar Naik](https://apify.com/akash9078) (community)
- **Categories:** Automation, Developer tools, Videos
- **Stats:** 869 total users, 190 monthly users, 100.0% runs succeeded, 27 bookmarks
- **User rating**: 4.81 out of 5 stars

## Pricing

from $0.00005 / actor start

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 Scraper — Extract Captions & Subtitles from Any YouTube Video

YouTube Transcript Scraper is an Apify Actor that extracts transcripts, captions, and subtitles from YouTube videos in seconds — no YouTube Data API key, OAuth setup, or quota management required.

Simply provide a YouTube URL and receive clean, structured JSON output ready for AI applications, RAG systems, analytics, SEO research, content repurposing, and workflow automation.

🚀 Try it now on the Apify Store.

### Key Features

- 📄 Extract full transcripts and captions from YouTube videos with available subtitles
- 🤖 Supports both auto-generated and manually created captions
- 🌍 Extract transcripts in 100+ languages
- 🌐 Translate transcripts into 14 supported languages
- ⚡ Typical extraction time: 3–5 seconds
- 📦 Structured JSON output ready for APIs, databases, and vector stores
- 🔁 Batch processing support through Apify API
- 🔒 Automatic proxy rotation for reliable extraction
- 🚫 No YouTube Data API key required
- 🚫 No OAuth configuration required
- ♾️ No quota limitations

### Supported Content Types

- Standard YouTube videos
- YouTube Shorts
- Premieres
- Completed live streams (VODs)
- Embedded videos
- Public videos
- Unlisted videos (when URL is available)

---

## Pricing

You only pay for successful extractions.

| Event | Price |
|---------|---------|
| Transcript Extraction | $0.01 |

#### Estimated Cost

| Volume | Cost |
|----------|----------|
| 10 Videos | ~$0.10 |
| 100 Videos | ~$1.00 |
| 1,000 Videos | ~$10.00 |
| 10,000 Videos | ~$100.00 |

---

## What Is YouTube Transcript Scraper?

YouTube Transcript Scraper is a cloud-based transcript extraction API that converts YouTube captions into structured JSON.

The Actor accepts all major YouTube URL formats and retrieves transcript data without using the official YouTube Data API.

Whether you're:

- Building AI datasets
- Creating RAG pipelines
- Running SEO analysis
- Generating summaries
- Monitoring competitors
- Repurposing video content

this Actor provides a simple URL-in, JSON-out workflow.

---

## Why Use This Instead of the YouTube Data API?

| Capability | YouTube Transcript Scraper | YouTube Data API v3 |
|------------|---------------------------|---------------------|
| API Key Required | ❌ No | ✅ Yes |
| OAuth Required | ❌ No | ✅ Yes |
| Daily Quota Limits | ❌ No | ✅ Yes |
| Auto-Generated Captions | ✅ Yes | ❌ No |
| Manual Captions | ✅ Yes | ⚠️ Limited |
| Batch Processing | ✅ Yes | ⚠️ Quota Limited |
| Setup Complexity | Low | Medium |
| Proxy Handling | ✅ Built-in | ❌ No |

The YouTube Data API does not expose auto-generated captions and requires API key management, OAuth setup, and quota monitoring.

YouTube Transcript Scraper eliminates those limitations and provides a straightforward transcript extraction workflow.

---

## Use Cases

### AI & Machine Learning

#### LLM Training

Create high-quality text datasets from YouTube content.

#### RAG Systems

Extract transcripts and store them in:

- Pinecone
- Weaviate
- Chroma
- Qdrant
- Milvus

#### Semantic Search

Index video content for retrieval and question-answering systems.

#### Content Summarization

Generate summaries using:

- OpenAI
- Claude
- Gemini
- Mistral

---

### Content Marketing

#### Blog Generation

Convert YouTube videos into blog posts.

#### Newsletter Creation

Turn videos into newsletter content.

#### Social Media Repurposing

Extract clips, quotes, and content ideas.

#### Podcast Show Notes

Generate structured show notes automatically.

---

### SEO & Research

#### Competitor Analysis

Analyze competitor video content.

#### Keyword Discovery

Extract keywords from transcript content.

#### Content Gap Analysis

Identify frequently discussed topics.

---

### Accessibility

#### Transcript Generation

Provide accessible text versions of video content.

#### Internal Documentation

Convert webinars and training videos into searchable documentation.

---

### Automation

Integrate with:

- n8n
- Make
- Zapier
- Activepieces
- Custom APIs

---

## Supported Languages

The Actor can extract any caption language available on the target video.

Examples include:

- English (en)
- Hindi (hi)
- Spanish (es)
- French (fr)
- German (de)
- Portuguese (pt)
- Japanese (ja)
- Korean (ko)
- Chinese (zh)
- Arabic (ar)

and many more.

### Language Selection

If `language` is omitted, the Actor automatically returns the video's default caption track.

To request a specific language, provide a BCP-47 language code.

Example:

```json
{
  "videoUrl": "https://youtu.be/dQw4w9WgXcQ",
  "language": "hi"
}
````

***

## Translation Support

The Actor supports transcript translation into:

- English
- Spanish
- French
- German
- Italian
- Portuguese
- Russian
- Japanese
- Korean
- Chinese
- Arabic
- Hindi
- Dutch
- Polish

Translation uses Mistral AI.

When translation is enabled:

- Original transcript is always returned
- Translation is attempted only when source and target languages differ
- `transcript_translated` is returned upon success

If translation fails, the original transcript is still returned.

***

## Input Parameters

| Parameter | Type | Required | Default | Description |
|------------|------|----------|---------|-------------|
| videoUrl | string | Yes | - | YouTube URL or video ID |
| language | string | No | Auto-detect | Caption language |
| translate | boolean | No | false | Enable translation |

***

## Supported URL Formats

```text
https://www.youtube.com/watch?v=VIDEO_ID

https://youtu.be/VIDEO_ID

https://youtube.com/shorts/VIDEO_ID

https://youtube.com/live/VIDEO_ID

https://youtube.com/embed/VIDEO_ID

VIDEO_ID
```

***

## Example Input

```json
{
  "videoUrl": "https://youtu.be/dQw4w9WgXcQ",
  "language": "en",
  "translate": false
}
```

***

## Output Schema

| Field | Type | Description |
|---------|---------|-------------|
| success | boolean | Extraction status |
| video\_id | string | YouTube video ID |
| video\_url | string | Canonical URL |
| video\_title | string | Video title |
| published\_at | string | Publish date |
| thumbnail\_max\_hd\_url | string | Thumbnail URL |
| transcript | string | Extracted transcript |
| transcript\_translated | string | Translated transcript |
| translated\_language | string | Translation language |
| language | string | Caption language |
| extraction\_time | number | Processing time |
| proxy\_type | string | Proxy type used |
| proxy\_stats | object | Proxy statistics |
| timestamp | string | Extraction timestamp |
| error | string | Error message |

***

## Example Output

```json
{
  "success": true,
  "video_id": "dQw4w9WgXcQ",
  "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "video_title": "Example Video",
  "published_at": "Jan 15, 2026",
  "thumbnail_max_hd_url": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg",
  "transcript": "Full transcript text...",
  "language": "en",
  "extraction_time": 3.42,
  "proxy_type": "apify",
  "timestamp": "2026-05-18T12:00:00.000Z"
}
```

***

## Example Output With Translation

```json
{
  "success": true,
  "video_id": "qMquIcJWZag",
  "video_title": "Example Video",
  "language": "en",
  "translated_language": "es",
  "transcript": "Original transcript...",
  "transcript_translated": "Transcripción traducida..."
}
```

***

## Error Responses

### No Captions Available

```json
{
  "success": false,
  "video_id": "xxxxxxxxxxx",
  "error": "No captions available for this video"
}
```

### Private Video

```json
{
  "success": false,
  "video_id": "xxxxxxxxxxx",
  "error": "Video is private or unavailable"
}
```

### Extraction Failure

```json
{
  "success": false,
  "video_id": "xxxxxxxxxxx",
  "error": "Unable to extract transcript"
}
```

***

## API Usage

### cURL

```bash
curl -X POST \
"https://api.apify.com/v2/acts/akash9078/youtube-transcript-scraper/runs" \
-H "Authorization: Bearer YOUR_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
  "videoUrl":"https://youtu.be/dQw4w9WgXcQ",
  "language":"es",
  "translate":true
}'
```

***

### Python

```python
import requests

response = requests.post(
    "https://api.apify.com/v2/acts/akash9078/youtube-transcript-scraper/runs",
    headers={
        "Authorization": "Bearer YOUR_API_TOKEN"
    },
    json={
        "videoUrl": "https://youtu.be/dQw4w9WgXcQ",
        "language": "es",
        "translate": True
    }
)

print(response.json())
```

***

### Node.js

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN
});

const run = await client.actor(
    'akash9078/youtube-transcript-scraper'
).call({
    videoUrl: 'https://youtu.be/dQw4w9WgXcQ',
    language: 'es',
    translate: true
});

console.log(run.defaultDatasetId);
```

***

## Retrieving Results

Each run stores output in an Apify Dataset.

### Get Dataset Items

```bash
GET https://api.apify.com/v2/datasets/{DATASET_ID}/items
```

### Node.js Example

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

console.log(items);
```

***

## Integrations

### AI Platforms

- OpenAI
- Anthropic Claude
- Gemini
- LangChain
- LlamaIndex

### Vector Databases

- Pinecone
- Chroma
- Weaviate
- Qdrant

### Automation Tools

- n8n
- Make
- Zapier
- Activepieces

### Data Platforms

- Google Sheets
- Airtable
- Notion
- BigQuery

***

## Alternative Use Cases

YouTube Transcript Scraper can be used as:

- YouTube Transcript API
- YouTube Caption API
- YouTube Subtitle API
- YouTube Transcript Downloader
- YouTube Subtitle Extractor
- YouTube Caption Scraper
- YouTube Subtitle Scraper
- YouTube Transcript Scraper

***

## Limitations

- Videos must have available captions
- Live streams currently in progress are not supported
- Private videos are not supported
- Age-restricted videos are not supported
- Transcript extraction depends on caption availability

***

## FAQ

### Does the Actor support auto-generated captions?

Yes. Both manual and auto-generated captions are supported.

***

### Can I extract transcripts in bulk?

Yes. You can process thousands of videos using the Apify API.

***

### Does it work with YouTube Shorts?

Yes. Shorts are fully supported.

***

### Is a YouTube API key required?

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

***

### Does the Actor return timestamped captions?

No. The current output contains complete transcript text only.

***

### Can I translate transcripts?

Yes. Translation into 14 supported languages is available.

***

### Is there a daily limit?

No. There are no YouTube API quota restrictions.

***

### How fast is transcript extraction?

Most videos are processed within 3–5 seconds.

***

## Support

- Apify Store Actor Page
- Apify Discord Community
- GitHub Issues (if applicable)

Built and maintained by **akash9078** on the Apify platform.

# Actor input Schema

## `videoUrl` (type: `string`):

YouTube video URL or 11-character video ID. Supports all URL formats: youtube.com/watch?v=, youtu.be/, youtube.com/shorts/, youtube.com/live/, embed/.

## `translate` (type: `boolean`):

If enabled, the transcript will be translated to the Preferred Language when it differs from the original language. Uses Mistral AI for translation. Disabled by default to save processing time.

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

Preferred language for transcript extraction. Select from the dropdown or type a custom BCP-47 code (e.g., 'en-GB', 'zh-Hans'). Choose 'auto' to let the system detect the best available track.

## Actor input object example

```json
{
  "videoUrl": "https://youtu.be/qMquIcJWZag",
  "translate": false,
  "language": "hi"
}
```

# Actor output Schema

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

Extracted transcripts with video metadata, including original and translated text when requested

# 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 = {
    "videoUrl": "https://youtu.be/qMquIcJWZag",
    "translate": false,
    "language": "hi"
};

// Run the Actor and wait for it to finish
const run = await client.actor("akash9078/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 = {
    "videoUrl": "https://youtu.be/qMquIcJWZag",
    "translate": False,
    "language": "hi",
}

# Run the Actor and wait for it to finish
run = client.actor("akash9078/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 '{
  "videoUrl": "https://youtu.be/qMquIcJWZag",
  "translate": false,
  "language": "hi"
}' |
apify call akash9078/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Transcript Scraper",
        "description": "YouTube Transcript Scraper  & Extractor API — Extract transcripts, captions & subtitles from YouTube videos, Shorts & VODs without an API key. Supports auto-generated and manual captions in 100+ languages with translation, batch extraction & clean JSON for AI agents, RAG, SEO & automation.",
        "version": "2.3",
        "x-build-id": "n9iIQDct8CZexE9I7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/akash9078~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-akash9078-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/akash9078~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-akash9078-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/akash9078~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-akash9078-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": [
                    "videoUrl"
                ],
                "properties": {
                    "videoUrl": {
                        "title": "Video URL",
                        "pattern": "^(https?://)?(www\\.)?(youtube\\.com/(watch\\?v=|embed/|v/|shorts/|live/)|youtu\\.be/|m\\.youtube\\.com/watch\\?v=)?[a-zA-Z0-9_-]{11}.*$|^[a-zA-Z0-9_-]{11}$",
                        "type": "string",
                        "description": "YouTube video URL or 11-character video ID. Supports all URL formats: youtube.com/watch?v=, youtu.be/, youtube.com/shorts/, youtube.com/live/, embed/.",
                        "default": "https://youtu.be/qMquIcJWZag"
                    },
                    "translate": {
                        "title": "Translate Transcript",
                        "type": "boolean",
                        "description": "If enabled, the transcript will be translated to the Preferred Language when it differs from the original language. Uses Mistral AI for translation. Disabled by default to save processing time.",
                        "default": false
                    },
                    "language": {
                        "title": "Preferred Language",
                        "type": "string",
                        "description": "Preferred language for transcript extraction. Select from the dropdown or type a custom BCP-47 code (e.g., 'en-GB', 'zh-Hans'). Choose 'auto' to let the system detect the best available track.",
                        "default": "hi"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```