# YouTube Channel Scraper (`maximedupre/youtube-channel-scraper`) Actor

Get public YouTube channel profiles and recent videos. Export handles, subscribers, views, thumbnails, and source URLs to a dataset or API.

- **URL**: https://apify.com/maximedupre/youtube-channel-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.36 / 1,000 youtube channel rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Get YouTube channel data without an API key

YouTube Channel Scraper gets public channel profiles and channel video rows from [YouTube](https://www.youtube.com/). Add channel URLs, @handles, channel IDs, or plain handles, then export clean rows with channel metadata, recent videos, views, thumbnails, source URLs, and publish data when YouTube shows it.

Use it when you need YouTube channel data for lead lists, creator research, competitor tracking, reports, or an API flow. You do not need YouTube cookies, a login, or a YouTube API key.

For a small first run, keep the prefilled channels: `@mkbhd` and `https://www.youtube.com/@veritasium`. The default run saves up to 25 videos per channel and adds channel profile data to each video row.

### What this YouTube channel scraper does

- Scrapes public YouTube channel profiles.
- Scrapes channel videos from the Videos tab.
- Accepts YouTube channel URLs, @handles, `/channel/UC...` IDs, and plain handles.
- Saves one row per channel or one row per video.
- Adds channel profile fields to video rows, so you do not need to join files.
- Sorts videos by latest, popular, or oldest.
- Can keep or skip Shorts and live stream rows.
- Can filter videos by publish date when YouTube feed dates are available.
- Works with Apify API, exports, schedules, webhooks, and integrations.
- Can include visible channel header links for a small extra charge.

### What data you get

Each row includes source and scrape fields so you can trace where the data came from. Video rows also include channel profile fields, which makes the dataset easier to sort, filter, and send to a sheet or database.

#### Channel fields

- Channel ID, handle, URL, and title
- Channel description
- Subscriber text and parsed subscriber count
- Video count text
- Avatar and banner image URLs
- Verification flag when visible
- Visible channel header links when enabled

#### Video fields

- Video ID, URL, and title
- Relative publish text, such as `5 days ago`
- Publish date when available from YouTube feed data
- Duration
- View count text and parsed view count
- Thumbnail URL
- Video type: video, short, or live
- Position in the requested channel order
- Requested sort order

Some fields can be empty when YouTube does not show them on the public page or feed.

### Common use cases

- Track new videos from competitor YouTube channels.
- Build a list of creators in a niche.
- Export channel profile data for lead research.
- Compare channel size, upload volume, and recent video views.
- Feed public YouTube video rows into an AI, BI, CRM, or reporting tool.
- Monitor public creator activity on a schedule.

### How to run it

1. Add one or more YouTube channels.
2. Choose **Channel videos with profile data** or **Channel profiles only**.
3. Set the video limit per channel.
4. Choose latest, popular, or oldest video order.
5. Add a publish-date range if you only want dated video rows.
6. Run the Actor and open the dataset.

For quick tests, use 1-2 channels and a low video limit. For larger runs, raise the per-channel limit or add a total row limit to control cost.

### Input

#### YouTube channels

You can enter:

- `@mkbhd`
- `mkbhd`
- `https://www.youtube.com/@veritasium`
- `https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q`

#### Output shape

Use **Channel videos with profile data** when you want one row per video. Use **Channel profiles only** when you only need one row per channel.

#### Sorting and limits

Set the video order to latest, popular, or oldest. Use the video limit per channel for the number of videos to save from each channel. Use the total row limit when you want one cap for the whole run.

#### Publish date filters

You can set a start date, an end date, or both. Date filters use YouTube feed dates when those dates are available. When date filters are active, rows without a feed date are skipped so the output only contains rows that match the date range.

#### Optional data

Channel images are on by default. Shorts and live streams are kept by default. Description links are off by default because they add a small enrichment charge when enabled.

### Output example

```json
{
	"rowType": "video",
	"sourceTarget": "@mkbhd",
	"channelId": "UCBJycsmduvYEL83R_U4JriQ",
	"channelHandle": "@mkbhd",
	"channelTitle": "Marques Brownlee",
	"channelSubscriberCount": 21000000,
	"videoId": "eFeDpUVEy48",
	"videoUrl": "https://www.youtube.com/watch?v=eFeDpUVEy48",
	"videoTitle": "The Biggest Android Update Ever",
	"videoPublishedText": "5 days ago",
	"videoPublishedAt": "2026-05-14T15:00:00+00:00",
	"videoDurationText": "12:59",
	"videoViewCount": 3900000,
	"videoThumbnailUrl": "https://i.ytimg.com/vi/eFeDpUVEy48/hqdefault.jpg",
	"videoType": "video",
	"position": 1,
	"sortBy": "latest",
	"status": "ok"
}
````

### Pricing

This Actor uses pay-per-event pricing:

- Actor start: `$0.001` per run.
- YouTube channel row:
  - FREE, BRONZE, SILVER: `$0.00045` per saved channel or video row.
  - GOLD: `$0.00036` per saved channel or video row.
  - PLATINUM: `$0.00027` per saved channel or video row.
  - DIAMOND: `$0.00018` per saved channel or video row.
- Description links enrichment: `$0.0004` per row when visible channel header links are enabled.

The default prefill is small, so you can check the output before running more channels.

### Notes and limits

- This Actor scrapes public YouTube pages and feeds.
- It does not need YouTube cookies, login, or a YouTube API key.
- It does not download videos, scrape comments, scrape transcripts, or extract emails.
- Private, removed, blocked, or unresolved channels may return no rows with a warning in the run log.
- Publish dates are filled when YouTube feed data is available. Otherwise the row keeps the relative publish text.

### FAQ

#### Can I scrape YouTube channel videos by handle?

Yes. Add handles like `@mkbhd`, plain handles like `mkbhd`, full channel URLs, or `/channel/UC...` IDs.

#### Can I export YouTube channel profiles only?

Yes. Choose **Channel profiles only** to save one row per channel.

#### Does this YouTube channel scraper include Shorts?

Yes. Shorts are included by default when they appear in channel video rows. You can turn them off in the input.

#### Can I filter YouTube videos by publish date?

Yes, when YouTube feed data has the publish date. Rows without a feed date are skipped while date filters are active.

#### Does it need a YouTube API key?

No. The Actor does not ask for a YouTube API key, cookies, or login.

#### Does it scrape emails, comments, or transcripts?

No. Email extraction, comment scraping, video downloads, and transcripts are outside this Actor. This keeps the Actor focused on channel profiles and channel video rows.

### Support

Open an issue on the Actor page if a public channel does not work, a field looks wrong, or you need a field that fits the channel profile or video-row use case.

# Actor input Schema

## `channels` (type: `array`):

Paste YouTube channel URLs, @handles, /channel/UC... IDs, or plain handles. You can mix these formats in one run.

## `mode` (type: `string`):

Choose one row per channel profile or one row per channel video with profile fields added.

## `maxVideosPerChannel` (type: `integer`):

Max channel videos to save from each channel. Lower this for a quick, low-cost test.

## `maxTotalRows` (type: `integer`):

Optional cap for the whole run. Leave empty to use the video limit per channel.

## `sortBy` (type: `string`):

Order to use from the YouTube channel Videos tab.

## `publishedAfter` (type: `string`):

Optional. Save only videos published on or after this date. Rows without a YouTube feed date are skipped.

## `publishedBefore` (type: `string`):

Optional. Save only videos published on or before this date. Rows without a YouTube feed date are skipped.

## `includeShorts` (type: `boolean`):

Keep YouTube Shorts when they appear in channel video rows.

## `includeLiveStreams` (type: `boolean`):

Keep live stream and replay rows when they appear in channel video rows.

## `includeChannelImages` (type: `boolean`):

Save channel avatar and banner image URLs when YouTube shows them.

## `includeDescriptionLinks` (type: `boolean`):

Save visible channel header links when available. This adds a small enrichment charge.

## `includeVideoTags` (type: `boolean`):

Keep the videoTags array in the output. Tags are saved when YouTube shows them.

## `deduplicateVideos` (type: `boolean`):

Skip repeated video IDs when the same video appears more than once in the run.

## `languageHint` (type: `string`):

Two-letter page language hint for YouTube pages, such as en.

## `countryHint` (type: `string`):

Two-letter country hint for YouTube pages, such as US.

## Actor input object example

```json
{
  "channels": [
    "@mkbhd",
    "https://www.youtube.com/@veritasium"
  ],
  "mode": "channelVideos",
  "maxVideosPerChannel": 25,
  "sortBy": "latest",
  "includeShorts": true,
  "includeLiveStreams": true,
  "includeChannelImages": true,
  "includeDescriptionLinks": false,
  "includeVideoTags": true,
  "deduplicateVideos": true,
  "languageHint": "en",
  "countryHint": "US"
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with YouTube channel profiles, video rows, views, thumbnails, source URLs, and publish data when available.

# 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 = {
    "channels": [
        "@mkbhd",
        "https://www.youtube.com/@veritasium"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/youtube-channel-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 = { "channels": [
        "@mkbhd",
        "https://www.youtube.com/@veritasium",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/youtube-channel-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 '{
  "channels": [
    "@mkbhd",
    "https://www.youtube.com/@veritasium"
  ]
}' |
apify call maximedupre/youtube-channel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Scraper",
        "description": "Get public YouTube channel profiles and recent videos. Export handles, subscribers, views, thumbnails, and source URLs to a dataset or API.",
        "version": "0.0",
        "x-build-id": "Cw4ROHbPZjECjr3Cg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~youtube-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-youtube-channel-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/maximedupre~youtube-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-youtube-channel-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/maximedupre~youtube-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-youtube-channel-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": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "YouTube channels",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Paste YouTube channel URLs, @handles, /channel/UC... IDs, or plain handles. You can mix these formats in one run.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "mode": {
                        "title": "Output shape",
                        "enum": [
                            "channelVideos",
                            "channelProfiles"
                        ],
                        "type": "string",
                        "description": "Choose one row per channel profile or one row per channel video with profile fields added.",
                        "default": "channelVideos"
                    },
                    "maxVideosPerChannel": {
                        "title": "Video limit per channel",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Max channel videos to save from each channel. Lower this for a quick, low-cost test.",
                        "default": 25
                    },
                    "maxTotalRows": {
                        "title": "Total row limit",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Optional cap for the whole run. Leave empty to use the video limit per channel."
                    },
                    "sortBy": {
                        "title": "Sort videos by",
                        "enum": [
                            "latest",
                            "popular",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Order to use from the YouTube channel Videos tab.",
                        "default": "latest"
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Optional. Save only videos published on or after this date. Rows without a YouTube feed date are skipped."
                    },
                    "publishedBefore": {
                        "title": "Published before",
                        "type": "string",
                        "description": "Optional. Save only videos published on or before this date. Rows without a YouTube feed date are skipped."
                    },
                    "includeShorts": {
                        "title": "Include Shorts",
                        "type": "boolean",
                        "description": "Keep YouTube Shorts when they appear in channel video rows.",
                        "default": true
                    },
                    "includeLiveStreams": {
                        "title": "Include live streams",
                        "type": "boolean",
                        "description": "Keep live stream and replay rows when they appear in channel video rows.",
                        "default": true
                    },
                    "includeChannelImages": {
                        "title": "Include channel images",
                        "type": "boolean",
                        "description": "Save channel avatar and banner image URLs when YouTube shows them.",
                        "default": true
                    },
                    "includeDescriptionLinks": {
                        "title": "Include description links",
                        "type": "boolean",
                        "description": "Save visible channel header links when available. This adds a small enrichment charge.",
                        "default": false
                    },
                    "includeVideoTags": {
                        "title": "Include video tags",
                        "type": "boolean",
                        "description": "Keep the videoTags array in the output. Tags are saved when YouTube shows them.",
                        "default": true
                    },
                    "deduplicateVideos": {
                        "title": "Deduplicate videos",
                        "type": "boolean",
                        "description": "Skip repeated video IDs when the same video appears more than once in the run.",
                        "default": true
                    },
                    "languageHint": {
                        "title": "Language hint",
                        "type": "string",
                        "description": "Two-letter page language hint for YouTube pages, such as en.",
                        "default": "en"
                    },
                    "countryHint": {
                        "title": "Country hint",
                        "type": "string",
                        "description": "Two-letter country hint for YouTube pages, such as US.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
