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

Extract clean transcript text, timestamps, captions, and public video metadata from YouTube URLs or video IDs for AI, SEO, and research workflows.

- **URL**: https://apify.com/fetch\_cat/youtube-transcript-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, AI
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

Extract clean transcripts, captions, timestamps, and basic metadata from public YouTube videos.

### What does YouTube Transcript Scraper do?

YouTube Transcript Scraper turns public YouTube captions into structured data.

It accepts YouTube watch URLs, Shorts URLs, youtu.be links, embed URLs, live URLs, or raw video IDs.

For every video, it returns a dataset row with the video ID, URL, title, channel name, caption language, transcript text, and optional timestamped segments.

Videos without public captions are handled gracefully with a clear error message instead of failing the whole run.

### Who is it for?

#### SEO and content teams

Use transcripts to repurpose videos into briefs, blog drafts, quote libraries, keyword research, and content audits.

#### Researchers and analysts

Collect spoken content from public videos for media monitoring, qualitative research, public-interest analysis, or education datasets.

#### LLM and RAG builders

Create clean text chunks from public video captions for search, summarization, classification, embeddings, and retrieval workflows.

#### Sales and marketing teams

Extract talks, interviews, demos, webinars, and competitor videos into searchable text for faster review.

#### Journalists and fact checkers

Create searchable transcript records for public videos, speeches, interviews, and announcements.

### Why use this actor?

- ✅ Structured output with one row per video
- ✅ Transcript text plus timestamped segments
- ✅ Public caption language selection
- ✅ Graceful handling for videos with no captions
- ✅ Works with video URLs and video IDs
- ✅ Low-cost runs for captioned public videos
- ✅ Output ready for spreadsheets, APIs, and AI workflows

### What data can I extract?

| Field | Description |
| --- | --- |
| `videoId` | YouTube video ID |
| `videoUrl` | Canonical watch URL |
| `title` | Public video title when available |
| `channelName` | Public channel name when available |
| `language` | Caption language used |
| `isAutoGenerated` | Whether the selected captions appear auto-generated |
| `transcriptText` | Full transcript as one clean text string |
| `segments` | Timestamped transcript segments |
| `duration` | Video duration in seconds when available |
| `thumbnailUrl` | Public thumbnail URL when available |
| `captionsAvailable` | Whether public caption tracks were found |
| `error` | Explanation for unavailable captions or failed videos |

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

The actor uses pay-per-event pricing.

There is a small start event for each run and a per-transcript event for every successful transcript extracted.

A first test with one or two videos is inexpensive.

For high-volume work, run batches of known captioned public videos to keep cost predictable.

Final tiered pricing is set on Apify before publication and is visible on the actor page.

### How to use YouTube Transcript Scraper

1. Open the actor on Apify.
2. Paste one or more public YouTube video URLs.
3. Optionally set a preferred caption language such as `en`, `es`, or `de`.
4. Choose whether to include timestamped segments.
5. Click **Start**.
6. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input example

```json
{
  "videoUrls": [
    { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }
  ],
  "language": "en",
  "includeTimestamps": true,
  "includeMetadata": true,
  "maxVideos": 5
}
````

### Output example

```json
{
  "videoId": "dQw4w9WgXcQ",
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "Example video title",
  "channelName": "Example channel",
  "language": "en",
  "isAutoGenerated": false,
  "transcriptText": "We're no strangers to love...",
  "segments": [
    { "start": 0.0, "duration": 2.1, "text": "We're no strangers to love" }
  ],
  "duration": 213,
  "thumbnailUrl": "https://i.ytimg.com/...",
  "captionsAvailable": true
}
```

### Supported YouTube URL formats

- `https://www.youtube.com/watch?v=VIDEO_ID`
- `https://youtu.be/VIDEO_ID`
- `https://www.youtube.com/shorts/VIDEO_ID`
- `https://www.youtube.com/embed/VIDEO_ID`
- `https://www.youtube.com/live/VIDEO_ID`
- Raw `VIDEO_ID` values

### Caption language selection

Set `language` to your preferred caption language code.

If that exact language is not available, the actor falls back to a related language variant or the first public caption track.

For example, `en` may match English captions when present.

The selected language is returned in the `language` field.

### Timestamped transcript segments

Enable `includeTimestamps` to receive segment-level timing.

Each segment can include:

- `start` — segment start in seconds
- `duration` — segment length in seconds
- `text` — spoken caption text

Disable timestamps when you only need the combined transcript text.

### Metadata fields

Enable `includeMetadata` to include public video details when available.

Metadata can include title, channel name, duration, and thumbnail URL.

Some unavailable or restricted videos may return less metadata.

### Handling videos with no captions

Not every public YouTube video has public captions.

When captions are unavailable, the actor still saves a row with:

- `captionsAvailable: false`
- the video ID and URL
- an `error` message explaining what happened

This makes batch runs easier to audit because one bad video does not stop the rest of the run.

### Tips for best results

- ✅ Use public videos with captions enabled.
- ✅ Start with a small batch to confirm your input format.
- ✅ Use `language` when you need a specific caption language.
- ✅ Keep `maxVideos` low for testing and increase it after validation.
- ✅ Check `captionsAvailable` before using transcript text in automated workflows.

### Integrations

You can connect the dataset to:

- Google Sheets for editorial review
- Zapier or Make for automations
- Vector databases for embeddings and retrieval
- BI tools for media analysis
- Internal dashboards for monitoring public video content
- LLM workflows for summarization, tagging, and question answering

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/youtube-transcript-scraper').call({
  videoUrls: [{ url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ' }],
  language: 'en',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].transcriptText);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/youtube-transcript-scraper').call(run_input={
    'videoUrls': [{'url': 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'}],
    'language': 'en',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0].get('transcriptText'))
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~youtube-transcript-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"videoUrls":[{"url":"https://www.youtube.com/watch?v=dQw4w9WgXcQ"}],"language":"en"}'
```

### MCP and AI agent usage

Use this actor through Apify MCP when you want an AI assistant to fetch public video transcripts.

MCP server URL pattern:

`https://mcp.apify.com/?tools=fetch_cat/youtube-transcript-scraper`

Claude Code setup:

```bash
claude mcp add apify-youtube-transcripts --transport http --url "https://mcp.apify.com/?tools=fetch_cat/youtube-transcript-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-youtube-transcripts": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/youtube-transcript-scraper"
    }
  }
}
```

Example prompts:

- "Extract the transcript from this public YouTube video and summarize the key claims."
- "Get transcripts for these five public webinar URLs and make a topic table."
- "Find quotes in this public interview transcript about pricing."

### Common use cases

- Video-to-blog repurposing
- Public webinar transcript extraction
- Research corpus creation
- Podcast-style YouTube episode analysis
- Competitive content monitoring
- Training data preparation from public captions
- Subtitle QA and language availability checks

### Limitations

This actor extracts public captions only.

It cannot access private videos, members-only videos, deleted videos, region-blocked content unavailable to the runner, or videos without public caption tracks.

Transcript quality depends on the caption track provided for the public video.

Auto-generated captions may contain recognition errors.

### Legality and responsible use

Use this actor only for content you are allowed to access and process.

YouTube videos and captions may be protected by copyright or platform terms.

You are responsible for ensuring that your use case, storage, redistribution, and analysis comply with applicable laws, platform rules, and rights-holder requirements.

### FAQ

#### Does it work without a YouTube account?

Yes, the actor is designed for public videos and public caption tracks.

#### Can it extract transcripts from private videos?

No. Private, members-only, deleted, or otherwise inaccessible videos are outside scope.

#### Why did a video return `captionsAvailable=false`?

The video may not have public captions, the video may be unavailable, or YouTube may not expose captions for that video.

#### Can I choose a language?

Yes. Use the `language` input with a language code such as `en`, `es`, `fr`, or `de`.

#### Are timestamps included?

Yes, when `includeTimestamps` is enabled.

#### Why are captions imperfect?

Some videos use auto-generated captions. These can include speech-recognition mistakes.

### Troubleshooting

#### My run succeeded but transcript text is empty

Check the `error` and `captionsAvailable` fields. The video probably has no public caption track.

#### My preferred language was not returned

The requested language may not be available. The actor falls back to another public caption track when needed.

### Related scrapers

Explore related actors from this account:

- `reddit-scraper`
- `tiktok-comments-scraper`
- `website-change-monitor`

### Changelog

#### 0.1

Initial version with public YouTube transcript extraction, timestamped segments, language selection, metadata fields, and graceful no-caption handling.

### Support

If a public captioned video fails unexpectedly, provide the video URL, input JSON, and run ID so the issue can be reproduced.

# Actor input Schema

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

Public YouTube watch, shorts, live, embed, or youtu.be URLs to extract transcripts from.

## `videoIds` (type: `array`):

Optional raw 11-character YouTube video IDs. Use this instead of URLs if you already have IDs.

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

Preferred caption language code, such as en, es, de, or fr. If unavailable, the actor uses the first public caption track.

## `includeTimestamps` (type: `boolean`):

Include start and duration values for every transcript segment.

## `includeMetadata` (type: `boolean`):

Include title, channel name, duration, and thumbnail URL when YouTube exposes them publicly.

## `maxVideos` (type: `integer`):

Maximum number of videos to process in this run. Keep this low for the first test run.

## Actor input object example

```json
{
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "videoIds": [
    "dQw4w9WgXcQ"
  ],
  "language": "en",
  "includeTimestamps": true,
  "includeMetadata": true,
  "maxVideos": 5
}
```

# Actor output Schema

## `overview` (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": [
        {
            "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
        }
    ],
    "videoIds": [
        "dQw4w9WgXcQ"
    ],
    "language": "en"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Transcript Scraper",
        "description": "Extract clean transcript text, timestamps, captions, and public video metadata from YouTube URLs or video IDs for AI, SEO, and research workflows.",
        "version": "0.1",
        "x-build-id": "OiMSkjqw7RNu9y4CY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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",
                "properties": {
                    "videoUrls": {
                        "title": "🎬 YouTube video URLs",
                        "type": "array",
                        "description": "Public YouTube watch, shorts, live, embed, or youtu.be URLs to extract transcripts from.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "videoIds": {
                        "title": "Video IDs",
                        "type": "array",
                        "description": "Optional raw 11-character YouTube video IDs. Use this instead of URLs if you already have IDs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Preferred caption language",
                        "type": "string",
                        "description": "Preferred caption language code, such as en, es, de, or fr. If unavailable, the actor uses the first public caption track.",
                        "default": "en"
                    },
                    "includeTimestamps": {
                        "title": "Include timestamps",
                        "type": "boolean",
                        "description": "Include start and duration values for every transcript segment.",
                        "default": true
                    },
                    "includeMetadata": {
                        "title": "Include video metadata",
                        "type": "boolean",
                        "description": "Include title, channel name, duration, and thumbnail URL when YouTube exposes them publicly.",
                        "default": true
                    },
                    "maxVideos": {
                        "title": "Maximum videos",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of videos to process in this run. Keep this low for the first test run.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```