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

Find public YouTube channels from search keywords. Export channel IDs, handles, subscriber and video counts, descriptions, source-video evidence, and public URLs. No YouTube login, cookies, or API key needed.

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

## Pricing

from $1.50 / 1,000 discovered channels

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### 🔎 YouTube channel search scraper for keyword discovery

YouTube Channel Search Scraper finds public [YouTube](https://www.youtube.com/) channels from search keywords and exports one clean row per discovered channel. Add keywords such as `coffee roasting`, `indie game dev`, or your niche, then get channel IDs, handles, subscriber counts, video counts, descriptions, source-video evidence, public links, and scrape metadata.

Use this Actor when you need to turn manual YouTube searching into a repeatable channel list for creator research, influencer discovery, competitor mapping, market research, outreach prep, or content planning. You do not need YouTube cookies, a login, or a YouTube API key.

For a small first run, keep the prefilled `coffee roasting` keyword and the default limit of 25 channels. The Actor searches YouTube results, checks the channel filter when selected, enriches channels from their public About pages, and saves accepted channels to the dataset during the run.

### ✅ What this Actor does

- Finds YouTube channels from one or more search keywords.
- Accepts typed keywords, pasted keyword lists, and uploaded TXT or CSV files.
- Can discover channels from video search results, YouTube's channel filter, or both.
- Saves one dataset item per discovered channel.
- Adds source evidence, including the video that exposed a channel when it was found through video results.
- Adds public channel details such as channel ID, handle, URL, title, description, subscribers, videos, total views, country, avatar, banner, tabs, RSS URL, and external links when YouTube exposes them.
- Supports optional cleanup filters for minimum subscribers, minimum videos, and verified channels.
- Can dedupe channels across multiple search terms.
- Works with Apify exports, API access, schedules, webhooks, and integrations.

### 📦 Data you can export

Each output row represents one discovered YouTube channel. Depending on what YouTube shows publicly, rows can include:

- `searchTerm`, `rank`, `discoverySource`, and `sourceResultPosition`
- `channelId`, `channelHandle`, `channelUrl`, and `channelTitle`
- `channelDescription`, `subscriberCount`, `videoCount`, and `totalViews`
- `country`, `createdAtText`, and `isVerified`
- `thumbnailUrl`, `avatarUrl`, `bannerUrl`, `tabs`, `rssUrl`, and `externalLinks`
- `sourceVideoId`, `sourceVideoTitle`, `sourceVideoUrl`, publish text, and view-count text
- `languageHint`, `countryHint`, `scrapedAt`, and `status`

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or read it through the Apify API.

### 👥 Common use cases

- Build niche YouTube creator lists from topics, products, and audience interests.
- Find channels for influencer research before checking fit, quality, or contact details.
- Map competitor channels around a market or content category.
- Collect source-video evidence that explains why a channel matched a keyword.
- Prepare repeatable channel discovery runs for scheduled reports or internal tools.

### ▶️ How to run it

1. Open the Actor and keep the prefilled `coffee roasting` keyword for a quick test.
2. Choose how many channels to save per search term.
3. Keep discovery mode on **Video results and channel filter** for broad coverage.
4. Optionally add filters such as minimum subscribers or verified channels only.
5. Start the run and export the dataset when it finishes.

For larger batches, paste one keyword per line in **Search terms as text** or upload a TXT/CSV file. CSV files can use a `searchTerm`, `term`, `query`, `keyword`, or `keywords` column.

### ⚙️ Input options

- **Search terms**: the main keywords to search on YouTube.
- **Search terms as text**: optional pasted list for larger keyword batches.
- **Search term files**: optional TXT or CSV uploads.
- **Channels per search term**: result limit for each keyword.
- **Total channels**: maximum rows across the whole run.
- **Discovery mode**: video results, channel filter, or both.
- **Dedupe across search terms**: save the same channel once when several keywords find it.
- **Filters**: minimum subscribers, minimum videos, and verified-only mode.
- **Raw result**: optional raw YouTube search result for debugging or custom parsing.
- **Page language and country**: YouTube locale hints for search result pages.

### 🧾 Example output

```json
{
  "searchTerm": "coffee roasting",
  "rank": 1,
  "discoverySource": "video_results",
  "channelId": "UCMb0O2CdPBNi-QqPk5T3gsQ",
  "channelHandle": "@jameshoffmann",
  "channelUrl": "https://www.youtube.com/@jameshoffmann",
  "channelTitle": "James Hoffmann",
  "subscriberCount": 2530000,
  "videoCount": 401,
  "sourceVideoId": "N6BJVM5tvnw",
  "sourceVideoTitle": "Coffee Roasting Explained",
  "sourceVideoUrl": "https://www.youtube.com/watch?v=N6BJVM5tvnw",
  "scrapedAt": "2026-06-01T16:00:00.000Z",
  "status": "ok"
}
````

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each public YouTube channel saved to the dataset. Runs that find no channels do not save placeholder rows.

### ⚠️ Limits and caveats

- The Actor collects public YouTube channel data only.
- It does not collect private analytics, hidden emails, comments, transcripts, or full video datasets.
- Subscriber counts can be approximate when YouTube shows abbreviated values such as `19.7K`.
- Some fields are `null` when YouTube does not expose them for a channel or search result.
- Unsupported, unavailable, or blocked search results are reported in logs instead of saved as fake rows.

### ❓ FAQ

#### 🔑 Do I need a YouTube API key?

No. The Actor is designed for public YouTube pages and does not ask for a YouTube API key, login, or cookies.

#### 📚 Can it find channels from many keywords?

Yes. Add keywords in the list field, paste them as text, or upload TXT/CSV files. Use the total channel limit to keep larger runs bounded.

#### 🎥 Does it return videos too?

It returns source-video evidence when a video search result exposed the channel. It does not scrape a full video list for each channel. Use YouTube Channel Scraper for known-channel video rows.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~youtube-channel-search-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Scrape profiles and video rows from known YouTube channels.
- [YouTube Channel Statistics Scraper ↗](https://apify.com/maximedupre/youtube-channel-statistics-scraper) - Export subscriber, view, and video counts for known channels.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Collect TikTok autocomplete keyword suggestions for content research.
- [Reddit Comments Search Scraper ↗](https://apify.com/maximedupre/reddit-comments-search-scraper) - Search public Reddit comments by keyword, subreddit, and freshness.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X/Twitter posts and trending topics.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `searchTerms` (type: `array`):

Enter YouTube search keywords, topics, products, or niches. Each term is checked separately.

## `searchTermsText` (type: `string`):

Optional. Paste one search term per line, or use comma-separated terms for a quick batch.

## `searchTermsFiles` (type: `array`):

Optional. Upload TXT or CSV keyword files. CSV columns named searchTerm, term, query, keyword, or keywords are used first.

## `maxChannelsPerSearchTerm` (type: `integer`):

Maximum discovered channels to save for each search term. Keep 25 for a useful first run.

## `maxTotalResults` (type: `integer`):

Maximum discovered channels to save across the whole run.

## `discoveryMode` (type: `string`):

Use regular YouTube video results, YouTube's channel filter, or both. Both modes give broader coverage.

## `dedupeAcrossSearchTerms` (type: `boolean`):

Save the same channel only once when multiple search terms find it.

## `minSubscribers` (type: `integer`):

Optional. Skip channels below this public subscriber count when YouTube exposes it.

## `minVideos` (type: `integer`):

Optional. Skip channels below this public video count when YouTube exposes it.

## `verifiedOnly` (type: `boolean`):

Save only channels that YouTube marks as verified.

## `includeRawSource` (type: `boolean`):

Add the raw YouTube search result that exposed each channel. Leave off for cleaner exports.

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

Two-letter 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
{
  "searchTerms": [
    "coffee roasting",
    "indie game dev"
  ],
  "maxChannelsPerSearchTerm": 25,
  "maxTotalResults": 100,
  "discoveryMode": "both",
  "dedupeAcrossSearchTerms": false,
  "verifiedOnly": false,
  "includeRawSource": false,
  "languageHint": "en",
  "countryHint": "US"
}
```

# Actor output Schema

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

Open the dataset with one item per discovered YouTube channel.

# 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 = {
    "searchTerms": [
        "coffee roasting",
        "indie game dev"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/youtube-channel-search-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 = { "searchTerms": [
        "coffee roasting",
        "indie game dev",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/youtube-channel-search-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 '{
  "searchTerms": [
    "coffee roasting",
    "indie game dev"
  ]
}' |
apify call maximedupre/youtube-channel-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Search Scraper",
        "description": "Find public YouTube channels from search keywords. Export channel IDs, handles, subscriber and video counts, descriptions, source-video evidence, and public URLs. No YouTube login, cookies, or API key needed.",
        "version": "0.1",
        "x-build-id": "9tedCXd0PbvTYP5uN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~youtube-channel-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-youtube-channel-search-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-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-youtube-channel-search-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-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-youtube-channel-search-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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Enter YouTube search keywords, topics, products, or niches. Each term is checked separately.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "searchTermsText": {
                        "title": "Search terms as text",
                        "type": "string",
                        "description": "Optional. Paste one search term per line, or use comma-separated terms for a quick batch."
                    },
                    "searchTermsFiles": {
                        "title": "Search term files",
                        "type": "array",
                        "description": "Optional. Upload TXT or CSV keyword files. CSV columns named searchTerm, term, query, keyword, or keywords are used first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxChannelsPerSearchTerm": {
                        "title": "Channels per search term",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum discovered channels to save for each search term. Keep 25 for a useful first run.",
                        "default": 25
                    },
                    "maxTotalResults": {
                        "title": "Total channels",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum discovered channels to save across the whole run.",
                        "default": 100
                    },
                    "discoveryMode": {
                        "title": "Discovery mode",
                        "enum": [
                            "both",
                            "videoResults",
                            "channelFilter"
                        ],
                        "type": "string",
                        "description": "Use regular YouTube video results, YouTube's channel filter, or both. Both modes give broader coverage.",
                        "default": "both"
                    },
                    "dedupeAcrossSearchTerms": {
                        "title": "Dedupe across search terms",
                        "type": "boolean",
                        "description": "Save the same channel only once when multiple search terms find it.",
                        "default": false
                    },
                    "minSubscribers": {
                        "title": "Minimum subscribers",
                        "minimum": 0,
                        "maximum": 1000000000,
                        "type": "integer",
                        "description": "Optional. Skip channels below this public subscriber count when YouTube exposes it."
                    },
                    "minVideos": {
                        "title": "Minimum videos",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Optional. Skip channels below this public video count when YouTube exposes it."
                    },
                    "verifiedOnly": {
                        "title": "Verified channels only",
                        "type": "boolean",
                        "description": "Save only channels that YouTube marks as verified.",
                        "default": false
                    },
                    "includeRawSource": {
                        "title": "Include raw result",
                        "type": "boolean",
                        "description": "Add the raw YouTube search result that exposed each channel. Leave off for cleaner exports.",
                        "default": false
                    },
                    "languageHint": {
                        "title": "Page language",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter language hint for YouTube pages, such as en.",
                        "default": "en"
                    },
                    "countryHint": {
                        "title": "Page country",
                        "minLength": 2,
                        "maxLength": 2,
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```