# Youtube Text Scraper (`ilborso/youtube-text-scraper`) Actor

Extract YouTube transcripts, subtitles, video metadata, hashtags, thumbnails, views, duration, and release dates from YouTube videos using either a search query or a list of direct YouTube URLs. It helps you turn YouTube search results and specific video links into structured JSON data

- **URL**: https://apify.com/ilborso/youtube-text-scraper.md
- **Developed by:** [Fabio Borsotti](https://apify.com/ilborso) (community)
- **Categories:** AI, Lead generation, Developer tools
- **Stats:** 4 total users, 2 monthly users, 62.5% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Actor

Extract YouTube transcripts, subtitles, video metadata, hashtags, thumbnails, views, duration, and release dates from YouTube videos using either a search query or a list of direct YouTube URLs. This YouTube transcript scraper helps you turn YouTube search results and specific video links into structured JSON data for research, SEO, lead generation, monitoring, and content analysis.

### What does YouTube Transcript Scraper do?

YouTube Transcript Scraper is an APIFY Actor that can search YouTube videos by keyword, apply a time filter, collect video metadata, and retrieve the first available transcript based on your preferred language order. It can also process direct YouTube video URLs and include those videos in the final output.

This Actor is ideal if you want to:
- train RAG algorithms for AI
- scrape YouTube transcripts
- extract YouTube subtitles
- collect YouTube video metadata
- monitor YouTube search results
- build datasets from YouTube videos
- automate YouTube content research
- extract transcripts from specific YouTube videos

The Actor uses:
- `pytubefix` for YouTube search and metadata extraction
- `youtube-transcript-api` for transcript and subtitle retrieval
- Scrape.do as a proxy layer

### Why use this YouTube scraper?

If you work with YouTube data, transcripts are one of the most valuable sources of structured content. Video transcripts help you analyze what creators actually say, not just what appears in titles and descriptions.

This Actor is useful because it supports two collection modes in the same run:
- search by keyword using `query`
- direct processing of specific YouTube videos using `direct_url`

This makes it practical both for broad monitoring and for targeted transcript extraction from known videos.

#### Common use cases

- SEO research for YouTube videos and keywords
- competitor monitoring on YouTube
- AI training and text dataset preparation
- content repurposing from video to text
- lead generation from niche YouTube channels
- trend monitoring by date range
- transcript-based topic clustering
- YouTube video catalog enrichment
- transcript extraction from manually selected videos

### What data does the Actor extract?

For each processed YouTube video, the Actor can return:

- YouTube video ID
- video title
- video URL
- channel name
- channel URL
- transcript text with timestamps
- available subtitles metadata
- video view count
- video duration in seconds
- release date
- thumbnail URL
- keywords / hashtags

### Why this Actor is useful

This YouTube Transcript Scraper is useful when you need structured YouTube data without building and maintaining your own scraping workflow. It is designed for users who want fast access to transcript-rich video data in a reusable JSON format.

Compared with a basic YouTube metadata scraper, this Actor focuses on transcript extraction and subtitle discovery, which makes it especially helpful for:
- content intelligence
- SEO workflows
- machine learning pipelines
- research automation
- enrichment of video datasets

### Input

#### Supported input fields

- `direct_url` (array of strings, optional): list of direct YouTube video URLs to process. Supported formats include `youtube.com/watch?v=...`, `youtu.be/...`, and `youtube.com/shorts/...`
- `query` (string, optional): YouTube search query. Optional if `direct_url` is provided
- `range` (array of strings): time filter for YouTube search, one of `hour`, `today`, `this_week`, `this_month`, `this_year`
- `limit` (integer): maximum number of videos to process from search results
- `langs` (array of strings): preferred language order used when selecting transcripts
- `file_output` (string): name of the JSON file saved in the key-value store

At least one between `query` and `direct_url` must be provided.

#### Example input with direct URLs only

```json
{
  "direct_url": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://youtu.be/9bZkp7q19f0"
  ],
  "langs": ["it", "en"],
  "file_output": "output.json"
}
````

#### Example input with query and direct URLs

```json
{
  "direct_url": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "query": "apify tutorial",
  "range": ["this_week"],
  "limit": 5,
  "langs": ["it", "en"],
  "file_output": "output.json"
}
```

When both `direct_url` and `query` are provided, all videos listed in `direct_url` are processed and added to the output together with the search results.

### Output

Each dataset item contains structured YouTube transcript and metadata fields like these:

```json
{
  "id": "video_id",
  "title": "Video title",
  "url": "https://www.youtube.com/watch?v=video_id",
  "autor": "Channel name",
  "text": "[00:00] transcript text...",
  "channel_name": "Channel name",
  "channel_url": "https://www.youtube.com/@channel",
  "video_title": "Detailed video title",
  "video_url": "https://www.youtube.com/watch?v=video_id",
  "views_count": 123456,
  "duration_seconds": 542,
  "release_date": "2026-04-13T00:00:00",
  "thumbnail_url": "https://i.ytimg.com/vi/video_id/maxresdefault.jpg",
  "hashtags": ["apify", "youtube", "scraping"],
  "subtitles": [
    {
      "language_code": "en",
      "language": "English",
      "is_generated": true,
      "is_translatable": true
    }
  ]
}
```

The Actor also saves the complete output array into the APIFY key-value store using the file name specified in `file_output`.

### How the YouTube transcript extraction works

The Actor follows this strategy:

1. If `direct_url` is provided, process each direct YouTube URL and extract transcript and metadata.
2. If `query` is provided, search YouTube videos using the selected time filter.
3. For each video, try to find a manually created transcript in the languages you requested.
4. If no manual transcript is available, try an auto-generated transcript.
5. If no requested language is available, fall back to the first available transcript.
6. Save transcript text and structured metadata in the output dataset.

This makes the Actor practical for multilingual transcript scraping, targeted video extraction, and broad topic monitoring.

### Who is this Actor for?

This Actor is a good fit for:

- SEO specialists
- marketers
- data engineers
- content analysts
- AI data learning teams
- researchers
- agencies monitoring YouTube niches
- users who need transcripts from specific YouTube links

### Limitations

The actor works only with public YouTube videos that have transcripts enabled.
Private or restricted videos are not supported.

### Summary

If you need a YouTube transcript scraper for APIFY that extracts subtitles, transcript text, hashtags, thumbnails, views, duration, and release date from either search results or direct video URLs, this Actor gives you a clean starting point with structured JSON output and proxy support.

# Actor input Schema

## `direct_url` (type: `array`):

Lista di URL YouTube diretti da cui scaricare la trascrizione. Ogni URL può essere in formato youtube.com/watch?v=..., youtu.be/... o youtube.com/shorts/.... I video specificati vengono sempre aggiunti all'output, indipendentemente dalla query.

## `query` (type: `string`):

Query di ricerca YouTube. Opzionale se vengono specificati direct\_url.

## `range` (type: `array`):

Filtro temporale da applicare alla ricerca YouTube. Se vengono passati più valori, verrà usato il primo.

## `limit` (type: `integer`):

Numero massimo di video da analizzare tramite ricerca query.

## `langs` (type: `array`):

Lingue preferite per recuperare la prima trascrizione disponibile.

## `file_output` (type: `string`):

Nome del file JSON da salvare nel key-value store.

## Actor input object example

```json
{
  "direct_url": [
    "https://www.youtube.com/watch?v=XqsDoIjXDPk"
  ],
  "limit": 10,
  "langs": [
    "it",
    "en"
  ],
  "file_output": "output.json"
}
```

# Actor output Schema

## `results` (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 = {
    "direct_url": [
        "https://www.youtube.com/watch?v=XqsDoIjXDPk"
    ],
    "langs": [
        "it",
        "en"
    ],
    "file_output": "output.json"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ilborso/youtube-text-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 = {
    "direct_url": ["https://www.youtube.com/watch?v=XqsDoIjXDPk"],
    "langs": [
        "it",
        "en",
    ],
    "file_output": "output.json",
}

# Run the Actor and wait for it to finish
run = client.actor("ilborso/youtube-text-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 '{
  "direct_url": [
    "https://www.youtube.com/watch?v=XqsDoIjXDPk"
  ],
  "langs": [
    "it",
    "en"
  ],
  "file_output": "output.json"
}' |
apify call ilborso/youtube-text-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Text Scraper",
        "description": "Extract YouTube transcripts, subtitles, video metadata, hashtags, thumbnails, views, duration, and release dates from YouTube videos using either a search query or a list of direct YouTube URLs. It helps you turn YouTube search results and specific video links into structured JSON data",
        "version": "0.0",
        "x-build-id": "wdJLayLlXtmgL7OHT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ilborso~youtube-text-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ilborso-youtube-text-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/ilborso~youtube-text-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ilborso-youtube-text-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/ilborso~youtube-text-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ilborso-youtube-text-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": [
                    "langs",
                    "file_output"
                ],
                "properties": {
                    "direct_url": {
                        "title": "Direct URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Lista di URL YouTube diretti da cui scaricare la trascrizione. Ogni URL può essere in formato youtube.com/watch?v=..., youtu.be/... o youtube.com/shorts/.... I video specificati vengono sempre aggiunti all'output, indipendentemente dalla query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "Query di ricerca YouTube. Opzionale se vengono specificati direct_url."
                    },
                    "range": {
                        "title": "Range",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filtro temporale da applicare alla ricerca YouTube. Se vengono passati più valori, verrà usato il primo.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hour",
                                "today",
                                "this_week",
                                "this_month",
                                "this_year"
                            ],
                            "enumTitles": [
                                "Last hour",
                                "Today",
                                "This week",
                                "This month",
                                "This year"
                            ]
                        }
                    },
                    "limit": {
                        "title": "Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Numero massimo di video da analizzare tramite ricerca query.",
                        "default": 10
                    },
                    "langs": {
                        "title": "Languages",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Lingue preferite per recuperare la prima trascrizione disponibile.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "aa",
                                "ab",
                                "ae",
                                "af",
                                "ak",
                                "am",
                                "ar",
                                "as",
                                "av",
                                "ay",
                                "az",
                                "ba",
                                "be",
                                "bg",
                                "bi",
                                "bm",
                                "bn",
                                "bo",
                                "br",
                                "bs",
                                "ca",
                                "ce",
                                "ch",
                                "co",
                                "cr",
                                "cs",
                                "cu",
                                "cv",
                                "cy",
                                "da",
                                "de",
                                "dv",
                                "dz",
                                "ee",
                                "el",
                                "en",
                                "eo",
                                "es",
                                "et",
                                "eu",
                                "fa",
                                "ff",
                                "fi",
                                "fj",
                                "fo",
                                "fr",
                                "fy",
                                "ga",
                                "gd",
                                "gl",
                                "gn",
                                "gu",
                                "gv",
                                "ha",
                                "he",
                                "hi",
                                "ho",
                                "hr",
                                "ht",
                                "hu",
                                "hy",
                                "hz",
                                "ia",
                                "id",
                                "ie",
                                "ig",
                                "ii",
                                "ik",
                                "io",
                                "is",
                                "it",
                                "iu",
                                "ja",
                                "jv",
                                "ka",
                                "kg",
                                "ki",
                                "kj",
                                "kk",
                                "kl",
                                "km",
                                "kn",
                                "ko",
                                "kr",
                                "ks",
                                "ku",
                                "kv",
                                "kw",
                                "ky",
                                "la",
                                "lb",
                                "lg",
                                "li",
                                "ln",
                                "lo",
                                "lt",
                                "lu",
                                "lv",
                                "mg",
                                "mh",
                                "mi",
                                "mk",
                                "ml",
                                "mn",
                                "mr",
                                "ms",
                                "mt",
                                "my",
                                "na",
                                "nb",
                                "nd",
                                "ne",
                                "ng",
                                "nl",
                                "nn",
                                "no",
                                "nr",
                                "nv",
                                "ny",
                                "oc",
                                "oj",
                                "om",
                                "or",
                                "os",
                                "pa",
                                "pi",
                                "pl",
                                "ps",
                                "pt",
                                "qu",
                                "rm",
                                "rn",
                                "ro",
                                "ru",
                                "rw",
                                "sa",
                                "sc",
                                "sd",
                                "se",
                                "sg",
                                "sh",
                                "si",
                                "sk",
                                "sl",
                                "sm",
                                "sn",
                                "so",
                                "sq",
                                "sr",
                                "ss",
                                "st",
                                "su",
                                "sv",
                                "sw",
                                "ta",
                                "te",
                                "tg",
                                "th",
                                "ti",
                                "tk",
                                "tl",
                                "tn",
                                "to",
                                "tr",
                                "ts",
                                "tt",
                                "tw",
                                "ty",
                                "ug",
                                "uk",
                                "ur",
                                "uz",
                                "ve",
                                "vi",
                                "vo",
                                "wa",
                                "wo",
                                "xh",
                                "yi",
                                "yo",
                                "za",
                                "zh",
                                "zu"
                            ]
                        },
                        "default": [
                            "it",
                            "en"
                        ]
                    },
                    "file_output": {
                        "title": "Output file name",
                        "type": "string",
                        "description": "Nome del file JSON da salvare nel key-value store.",
                        "default": "output.json"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
