# YouTube Playlist Scraper - Cheaper (`xtracto/youtube-playlist-scraper`) Actor

Enumerate every video in a YouTube playlist: title, channel, length, position. Bulk-paginated. Fast http only scraper, no cookies required

- **URL**: https://apify.com/xtracto/youtube-playlist-scraper.md
- **Developed by:** [Xtractoo](https://apify.com/xtracto) (community)
- **Categories:** Social media, Videos
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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 Playlist Scraper

Enumerate every video inside any public YouTube playlist — title, channel, position, length, and thumbnails — in a clean structured JSON output, one row per video.

### Why use this actor

- **No account / no login required** — just paste a playlist URL or ID.
- **No API key needed** — no YouTube Data API quotas, no OAuth, no key rotation; you get the same data the YouTube web app shows.
- **Flexible input** — full URLs (`https://www.youtube.com/playlist?list=...`), watch-with-list URLs (`watch?v=...&list=...`), or raw playlist IDs (`PLxxxx`, `RDxxxx`, `OLAKxxxx`) are all accepted.
- **Automatic pagination** — chains continuation tokens internally to walk playlists of any length, from a 10-video tutorial series to a 5,000-video music archive.
- **Preserves playlist order** — every record carries its `index` field, so you can reconstruct the playlist exactly as the creator ordered it.
- **Stable JSON output** suitable for pipelines, spreadsheets, and databases — every row carries the `_input`, `_playlistId`, `_source`, `_scrapedAt` envelope fields so you can join results back to your input list.

### How it works

1. You provide a list of YouTube playlist URLs or playlist IDs.
2. The actor fetches the playlist, walks through every page of videos, and emits one flat JSON record per video (with `videoId`, `title`, `channelTitle`, position, length, and thumbnails).
3. Results stream into your dataset, ready to download as JSON, CSV, or Excel.

You do not need to manage scrapers, browsers, or rotating IPs — all handled internally.

### Input

```json
{
  "playlists": [
    "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
    "PLrAXtmErZgOeiKm4sgNOknc9TTnMPEBL5"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
````

| Field | Type | Description |
|---|---|---|
| `playlists` | array | List of YouTube playlist URLs or playlist IDs to scrape. Accepts full URLs, `watch?v=...&list=...` URLs, or raw playlist IDs (`PLxxxx`, `RDxxxx`, `OLAKxxxx`). |
| `maxItems` | integer | Maximum number of videos returned per playlist. `0` means unlimited (fetch every video, paginating automatically). Default: `100`. |
| `proxyConfiguration` | object | Apify Proxy settings. Datacenter proxy works for most playlists; switch to residential if you hit rate limits on very large runs. |

### Output

Input: `https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9`

```json
{
  "videoId": "cMV4-xekoaY",
  "index": "1",
  "title": "Kay Flock - Being Honest (shot by  RingRing Visuals)",
  "lengthSeconds": "156",
  "lengthText": "2:36",
  "channelTitle": "Kay Flock",
  "channelId": "UC2HMnUWiitQph86vY2VZO5Q",
  "thumbnails": [
    {
      "url": "https://i.ytimg.com/vi/cMV4-xekoaY/hqdefault.jpg?sqp=-oaymwEbCKgBEF5IVfKriqkDDggBFQAAiEIYAXABwAEG&rs=AOn4CLB96o9AJ9v1y1K1ymRckyTpP2vyug",
      "width": 168,
      "height": 94
    },
    {
      "url": "https://i.ytimg.com/vi/cMV4-xekoaY/hqdefault.jpg?sqp=-oaymwEcCNACELwBSFXyq4qpAw4IARUAAIhCGAFwAcABBg==&rs=AOn4CLABeeJrV937NnKI3aFzBpuAsTH5RQ",
      "width": 336,
      "height": 188
    }
    // ... 2 more
  ],
  "_input": "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
  "_playlistId": "PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:43:39.481731+00:00"
}
```

```json
{
  "videoId": "KNexS61fjus",
  "index": "2",
  "title": "LE SSERAFIM (르세라핌) 'Smart' OFFICIAL MV",
  "lengthSeconds": "194",
  "lengthText": "3:14",
  "channelTitle": "HYBE LABELS and LE SSERAFIM",
  "channelId": null,
  "thumbnails": [ /* ... 4 thumbnail sizes ... */ ],
  "_input": "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
  "_playlistId": "PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:43:39.481731+00:00"
}
```

```json
{
  "videoId": "Q97pvL6GsIA",
  "index": "3",
  "title": "날 바라바라봐 LOOK AT ME",
  "lengthSeconds": "194",
  "lengthText": "3:14",
  "channelTitle": "TWICE",
  "channelId": "UCzgxx_DM2Dcb9Y1spb9mUJA",
  "thumbnails": [ /* ... 4 thumbnail sizes ... */ ],
  "_input": "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
  "_playlistId": "PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:43:39.481731+00:00"
}
```

| Field | Type | Description |
|---|---|---|
| `videoId` | string | YouTube video ID (11 chars). Build the URL with `https://www.youtube.com/watch?v={videoId}`. |
| `index` | string | 1-based position of the video inside the playlist. Use this to preserve the creator's ordering. |
| `title` | string | Video title as displayed by YouTube. |
| `lengthSeconds` | string | Total video duration in seconds. |
| `lengthText` | string | Human-readable duration (e.g. `"3:14"`, `"1:02:33"`). |
| `channelTitle` | string | Display name of the channel that uploaded the video. |
| `channelId` | string | Channel ID of the uploader. `null` for some auto-generated topic channels. |
| `thumbnails` | array | Thumbnail variants (typically 4 sizes from `168x94` up to `336x188`). Each entry has `url`, `width`, `height`. |
| `_input` | string | The playlist URL or ID exactly as you supplied it. Use this to join results back to your input list. |
| `_playlistId` | string | Normalized playlist ID extracted from the input (e.g. `PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9`). |
| `_source` | string | Internal tag for the path used to fetch the record. `S1-primary` is the fastest, richest path. |
| `_scrapedAt` | string | ISO-8601 UTC timestamp when the record was scraped. |

#### Error envelope

Inputs that fail to parse or playlists that cannot be reached return a structured error instead of crashing the run:

```json
{
  "_input": "PLthis-id-does-not-exist",
  "_playlistId": "PLthis-id-does-not-exist",
  "_error": "fetch_failed",
  "_errorDetail": "playlist not found or private",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:44:10.012345+00:00"
}
```

Filter on `_error` to triage failed rows. Common error codes:

- `invalid_input` — the string you passed isn't a recognizable playlist URL or ID.
- `fetch_failed` — the playlist is private, deleted, or the request couldn't complete after retries.

### Pricing

This actor is billed per result: **$3.50 per 1,000 videos** (Tier 3). Each video record = 1 result. Error envelopes are not billed.

### Other Sosmed Actors

| Platform | Actor | Best for |
|---|---|---|
| YouTube | [YouTube Channel Scraper](https://apify.com/xtracto/youtube-channel-scraper) | Channel-level metadata + uploads feed |
| YouTube | [YouTube Video Detail Scraper](https://apify.com/xtracto/youtube-video-detail-scraper) | Full per-video stats: views, likes, description, tags |
| Twitch | [Twitch Clips Scraper](https://apify.com/xtracto/twitch-clips) | Top clips from any Twitch channel |
| Pinterest | [Pinterest Board Scraper](https://apify.com/xtracto/pinterest-board) | All pins inside a board, with images and source links |
| Substack | [Substack Publication Posts Scraper](https://apify.com/xtracto/substack-publication-posts-scraper) | Full archive of posts from any Substack publication |
| Reddit | [Reddit Subreddit Posts Scraper](https://apify.com/xtracto/reddit-subreddit-posts-scraper) | Posts from any subreddit, with comments and metadata |
| Tumblr | [Tumblr Blog Scraper](https://apify.com/xtracto/tumblr-blog-scraper) | All posts from a Tumblr blog, in order |

Browse the full catalog at [apify.com/xtracto](https://apify.com/xtracto).

### Notes

- Playlists with more than 5,000 videos are paginated automatically — set `maxItems: 0` to fetch them all, or cap with a number to control cost.
- Unlisted playlists work — as long as you have the URL (or the `list=...` ID), the actor will fetch them just like a public playlist.
- Truly private playlists (owner-only) are not accessible and return `_error: "fetch_failed"`.
- "Mix" playlists (IDs starting with `RD`) are dynamically generated by YouTube and may return different videos on each run.
- Region-blocked or removed videos may appear with `title: null` or `lengthText: null` — filter them downstream.
- Playlist order is preserved via the `index` field; sort your dataset by `index` (as integer) to reconstruct the original order.

# Actor input Schema

## `playlists` (type: `array`):

List of YouTube playlist URLs or playlist IDs to scrape. Accepts full URLs (https://www.youtube.com/playlist?list=...), watch URLs with a list parameter (https://www.youtube.com/watch?v=...\&list=...), or raw playlist IDs (PLxxxx, RDxxxx, OLAKxxxx).

## `maxItems` (type: `integer`):

Maximum number of videos to return per playlist. Set to 0 (default) to fetch every video in the playlist; the actor will paginate automatically.

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

Apify Proxy configuration. Datacenter proxy works well for YouTube playlists; switch to residential if you hit rate limits on very large runs.

## Actor input object example

```json
{
  "playlists": [
    "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
    "PLbpi6ZahtOH6Blw3RGYpWkSByi_T7Rygb"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "playlists": [
        "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
        "PLbpi6ZahtOH6Blw3RGYpWkSByi_T7Rygb"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/youtube-playlist-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 = { "playlists": [
        "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
        "PLbpi6ZahtOH6Blw3RGYpWkSByi_T7Rygb",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("xtracto/youtube-playlist-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 '{
  "playlists": [
    "https://www.youtube.com/playlist?list=PL0xfS3j79Q27O1m6o5O92yxVTgtw1xEc9",
    "PLbpi6ZahtOH6Blw3RGYpWkSByi_T7Rygb"
  ]
}' |
apify call xtracto/youtube-playlist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Playlist Scraper - Cheaper",
        "description": "Enumerate every video in a YouTube playlist: title, channel, length, position. Bulk-paginated. Fast http only scraper, no cookies required",
        "version": "1.0",
        "x-build-id": "UYqeN7OI7KbzaBhmL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~youtube-playlist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-youtube-playlist-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/xtracto~youtube-playlist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-youtube-playlist-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/xtracto~youtube-playlist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-youtube-playlist-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": [
                    "playlists"
                ],
                "properties": {
                    "playlists": {
                        "title": "YouTube playlists",
                        "type": "array",
                        "description": "List of YouTube playlist URLs or playlist IDs to scrape. Accepts full URLs (https://www.youtube.com/playlist?list=...), watch URLs with a list parameter (https://www.youtube.com/watch?v=...&list=...), or raw playlist IDs (PLxxxx, RDxxxx, OLAKxxxx).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max videos per playlist",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of videos to return per playlist. Set to 0 (default) to fetch every video in the playlist; the actor will paginate automatically.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Datacenter proxy works well for YouTube playlists; switch to residential if you hit rate limits on very large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
