# YouTube Downloader - MP4, MP3, 4K, 1080p Direct URLs (`convertfleetdotonline/youtube-downloader`) Actor

Download YouTube videos and Shorts: direct MP4 URLs in 4K, 1080p, 720p, 480p plus MP3/M4A audio. Best-combined + best-audio shortcuts. Bulk URLs, no login, no API key.

- **URL**: https://apify.com/convertfleetdotonline/youtube-downloader.md
- **Developed by:** [Hasnain Nisar](https://apify.com/convertfleetdotonline) (community)
- **Categories:** Videos, Developer tools
- **Stats:** 1,171 total users, 66 monthly users, 99.7% runs succeeded, 0 bookmarks
- **User rating**: 4.50 out of 5 stars

## Pricing

$0.99 / 1,000 video resolveds

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

Download YouTube videos and extract direct MP4 and MP3 URLs at every quality — 4K, 1440p, 1080p, 720p, 480p, down to 144p — plus high-quality audio for MP3 conversion. Paste any [YouTube](https://www.youtube.com) link (regular video, YouTube Shorts, live VOD, or YouTube Music) and this YouTube Downloader returns ready-to-use CDN download URLs with no login, no API key, and no watermark. The top outputs are a **best combined video+audio MP4**, a **best video-only stream**, and a **best audio URL** — perfect for offline viewing, archival, and transcription pipelines.

### What does the YouTube Downloader do?

The YouTube Downloader is a URL-extraction tool that turns any YouTube video link into direct, downloadable CDN URLs at every available resolution and bitrate. Instead of downloading and storing the file itself, it resolves the same player URLs the YouTube web app uses and returns them as structured JSON — so you can pipe them straight into `curl`, `wget`, `ffmpeg`, S3, or your own download client. It supports bulk input (pass an array of URLs) and works on standard videos, Shorts, live VODs, and Music URLs.

- **Download YouTube videos in 4K, 1080p, 720p, and 480p** — every resolution YouTube offers
- **Convert YouTube to MP3** — get the best audio-only stream (M4A / Opus) ready for MP3 conversion
- **Get a single combined video+audio MP4** for muxed streams (typically up to 720p)
- **Download YouTube Shorts** and live-stream VODs
- **Bulk YouTube downloader** — pass many URLs, get every download link back
- **No watermark, no login, no API key** — direct CDN URLs from YouTube itself
- **Full format list** with resolution, codec, bitrate, and estimated file size

### What data can I extract?

Each dataset record contains per-video metadata plus pre-resolved best-quality URLs and a full list of every available format.

| Field | Description |
|-------|-------------|
| `title` | Human-readable video title |
| `thumbnail` | Direct thumbnail image URL |
| `duration` | Duration in seconds |
| `duration_string` | Human-readable duration (e.g. `3:33`) |
| `uploader` | Channel / uploader name |
| `platform` | Source platform (`Youtube`) |
| `audio_url` | Best audio-only direct URL (for MP3 conversion) |
| `formats` | Array of every available format |
| `formats[].format_id` | yt-dlp format identifier |
| `formats[].type` | `video` or `audio` |
| `formats[].ext` | Container extension (`mp4`, `webm`, `m4a`) |
| `formats[].height` | Vertical resolution in pixels |
| `formats[].quality` | Human-readable quality label (e.g. `2160p`) |
| `formats[].filesize` | Estimated file size in bytes |
| `formats[].has_audio` | Whether the stream already contains audio |
| `formats[].url` | Direct CDN download URL |

### How to download a YouTube video (step-by-step)

1. Open the YouTube Downloader on Apify and click **Try for free**.
2. Paste one or more YouTube URLs into the **YouTube video URLs** field (videos, Shorts, live, or Music links).
3. Leave **Proxy configuration** on the default Apify Proxy (required — YouTube rate-limits datacenter IPs).
4. (Highly recommended) Paste a Netscape-format **cookies.txt** blob from a logged-in session to unlock the full 4K/1440p/1080p ladder.
5. Click **Start** and wait 2–4 seconds per video.
6. Open the **Dataset** tab and copy the `audio_url` or any `formats[].url`, or export the whole dataset.
7. Download the file with `curl`, `wget`, or `ffmpeg` — or merge separate video+audio with ffmpeg.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `videoUrls` | array (required) | — | One or more YouTube video, Shorts, live, or Music/Mix URLs. Mix and radio params (`?list=`, `?start_radio=`, `?si=`) are stripped automatically. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Routes yt-dlp through Apify Proxy. Required for reliable extraction; failed videos auto-retry via the RESIDENTIAL group. |
| `cookies` | string | `""` | Netscape-format cookies.txt from a logged-in YouTube session. Strongly recommended to unlock 4K/1440p/1080p and high-quality audio. |

```json
{
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://youtu.be/9bZkp7q19f0",
        "https://www.youtube.com/shorts/abc123"
    ],
    "proxyConfiguration": { "useApifyProxy": true }
}
````

### Output example

```json
{
    "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
    "thumbnail": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg",
    "duration": 213,
    "duration_string": "3:33",
    "uploader": "Rick Astley",
    "platform": "Youtube",
    "audio_url": "https://… (best audio direct URL)",
    "formats": [
        {
            "format_id": "313",
            "type": "video",
            "ext": "webm",
            "height": 2160,
            "quality": "2160p",
            "filesize": 312456789,
            "has_audio": false,
            "url": "https://…"
        },
        {
            "format_id": "137",
            "type": "video",
            "ext": "mp4",
            "height": 1080,
            "quality": "1080p",
            "filesize": 31456789,
            "has_audio": false,
            "url": "https://…"
        }
    ]
}
```

### Use cases

- **Offline viewing** — download YouTube videos for travel or low-bandwidth situations
- **YouTube to MP3** — extract audio for podcasts, music, and lecture archives
- **Content archival** — back up your own uploads or favourites with full-format metadata
- **Captioning and transcription** — feed the audio URL into Whisper, AssemblyAI, or other speech-to-text services
- **Compliance and editorial** — capture public videos for editorial or legal review
- **AI/ML research** — bulk-download videos and format metadata for training datasets

### Pricing

This actor runs on [Apify's usage-based pricing](https://apify.com/pricing) — you only pay for the compute time used. Format URLs resolve in roughly 2–4 seconds per video and memory stays under 256 MB, so runs are cheap. Because the actor returns direct URLs rather than storing files, you avoid Apify storage costs entirely. Proxy usage is billed per the Apify Proxy you select.

### YouTube Downloader vs. building your own yt-dlp script

This actor wraps [yt-dlp](https://github.com/yt-dlp/yt-dlp) — the open-source standard that powers tens of thousands of production downloaders — in a hosted, no-code Apify actor. You skip server setup, proxy management, and the constant maintenance of extractor updates. You get the same direct CDN URLs YouTube serves its own web app, plus pre-resolved best-combined and best-audio shortcuts, bulk input, and CSV/JSON/Excel exports out of the box.

### FAQ

#### Is it legal to download YouTube videos?

The actor only resolves publicly available content. You are responsible for complying with YouTube's Terms of Service and your local copyright law. Downloading your own uploads, Creative Commons content, or content you have rights to (including personal-use and fair-use cases) is generally fine; re-uploading copyrighted material is not.

#### Do I need a YouTube API key or login?

No API key or login is required for public videos. Pasting a cookies.txt blob from a logged-in session is optional but strongly recommended to unlock the full 4K/1440p/1080p quality ladder.

#### How much does it cost to download YouTube videos?

It runs on Apify's usage-based pricing — typically a few seconds of compute per video and no storage cost, since only URLs are returned. See the actor's Pricing tab for current rates.

#### How fast is it and how many videos can I process?

Each video resolves in about 2–4 seconds and you can pass an array of URLs for bulk processing in a single run.

#### Can I export results to CSV, Excel, JSON, or Google Sheets?

Yes. Apify lets you export the dataset to CSV, Excel, JSON, XML, or push it to Google Sheets and other integrations.

#### Does it download the actual MP4 file?

No — it returns the direct URL. You download with `curl`, `wget`, `ffmpeg`, or any HTTP client. This keeps the actor fast and avoids storage costs.

#### Can I get a single MP4 with both video and audio?

Yes — the `formats` list includes every combined stream YouTube offers (typically up to 720p). For higher resolutions, merge the separate video and audio with ffmpeg: `ffmpeg -i video.mp4 -i audio.m4a -c copy out.mp4`.

#### Why does my download URL stop working after a few hours?

YouTube signs all CDN URLs with a time-limited token (typically ~6 hours). Re-run the actor to get fresh URLs.

#### Does it work for age-restricted videos?

Some age-gated videos require login and won't resolve; public, non-restricted videos always work.

#### Does it use proxies — will I get blocked?

Yes, requests are routed through Apify Proxy, and failed videos automatically retry through the residential group to avoid YouTube's bot challenges.

### Related actors

- [Universal Video Downloader](https://apify.com/hasnainnisar67/video-downloader) — same engine, every supported site
- [TikTok Downloader](https://apify.com/hasnainnisar67/tiktok-downloader) — TikTok videos, no watermark
- [Instagram Downloader](https://apify.com/hasnainnisar67/instagram-downloader) — Reels, posts, IGTV, Stories
- [YouTube Video Info Scraper](https://apify.com/hasnainnisar67/youtube-video-info-scraper) — metadata only, no format URLs
- [Facebook Downloader](https://apify.com/hasnainnisar67/facebook-downloader) — Facebook videos and reels

### Support

Found a bug or have a feature request? Open an issue on the actor's **Issues** tab. Custom downloader and scraper solutions are available on request.

# Actor input Schema

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

One or more YouTube video, Shorts, live, or Music/Mix URLs to resolve. Returns direct MP4 / MP3 download URLs at every available quality. Mix and radio params (?list=, ?start\_radio=, ?si=) are stripped automatically.

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

yt-dlp is routed through this proxy. Apify datacenter IPs are aggressively rate-limited by YouTube ('Sign in to confirm you're not a bot'), so a proxy is required for reliable extraction. If a video still fails the bot-challenge, the actor automatically retries it via the RESIDENTIAL proxy group.

## `cookies` (type: `string`):

Strongly recommended. YouTube serves only the low-quality 360p muxed stream to most Apify proxy IPs (a 'stripped response'). Pasting a Netscape-format cookies.txt blob from a logged-in YouTube session unlocks the full 4K/1440p/1080p ladder plus high-quality audio. Export via the 'Get cookies.txt LOCALLY' browser extension. See https://github.com/yt-dlp/yt-dlp/wiki/FAQ#how-do-i-pass-cookies-to-yt-dlp.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "cookies": ""
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("convertfleetdotonline/youtube-downloader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("convertfleetdotonline/youtube-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call convertfleetdotonline/youtube-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Downloader - MP4, MP3, 4K, 1080p Direct URLs",
        "description": "Download YouTube videos and Shorts: direct MP4 URLs in 4K, 1080p, 720p, 480p plus MP3/M4A audio. Best-combined + best-audio shortcuts. Bulk URLs, no login, no API key.",
        "version": "0.1",
        "x-build-id": "zrfA2fLgT3Ywb1mHP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/convertfleetdotonline~youtube-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-convertfleetdotonline-youtube-downloader",
                "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/convertfleetdotonline~youtube-downloader/runs": {
            "post": {
                "operationId": "runs-sync-convertfleetdotonline-youtube-downloader",
                "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/convertfleetdotonline~youtube-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-convertfleetdotonline-youtube-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "YouTube video URLs",
                        "type": "array",
                        "description": "One or more YouTube video, Shorts, live, or Music/Mix URLs to resolve. Returns direct MP4 / MP3 download URLs at every available quality. Mix and radio params (?list=, ?start_radio=, ?si=) are stripped automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "yt-dlp is routed through this proxy. Apify datacenter IPs are aggressively rate-limited by YouTube ('Sign in to confirm you're not a bot'), so a proxy is required for reliable extraction. If a video still fails the bot-challenge, the actor automatically retries it via the RESIDENTIAL proxy group.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "cookies": {
                        "title": "YouTube cookies (Netscape format) - HIGHLY RECOMMENDED",
                        "type": "string",
                        "description": "Strongly recommended. YouTube serves only the low-quality 360p muxed stream to most Apify proxy IPs (a 'stripped response'). Pasting a Netscape-format cookies.txt blob from a logged-in YouTube session unlocks the full 4K/1440p/1080p ladder plus high-quality audio. Export via the 'Get cookies.txt LOCALLY' browser extension. See https://github.com/yt-dlp/yt-dlp/wiki/FAQ#how-do-i-pass-cookies-to-yt-dlp.",
                        "default": ""
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
