# YouTube Community Posts Scraper (`lurkapi/youtube-community-posts-scraper`) Actor

Scrape community posts from YouTube channels. Extract text, images, polls, videos, likes, comments, and engagement data from any channel's Community tab.

- **URL**: https://apify.com/lurkapi/youtube-community-posts-scraper.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Automation, Social media, Videos
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 post scrapeds

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 Community Posts Scraper

Scrape community posts from any YouTube channel. Get text, images, polls, video links, likes, comments, and engagement data in seconds.

### 🎬 What it does

Give it one or more YouTube channels, and it will:

1. **Visit each channel's Community tab** and collect all posts
2. **Extract post content**: text, images, polls, embedded videos
3. **Capture engagement metrics**: likes, comment counts, timestamps
4. **Return structured data** you can export as JSON, CSV, or Excel

Works with text posts, image posts, polls, video shares, and multi-image posts.

### 📋 How to use it

#### Step 1: Add your channels

Paste channel URLs, @handles, or channel IDs into the input. You can add up to 100 channels per run.

**Supported formats:**
- `@mkbhd`
- `https://www.youtube.com/@MrBeast`
- `https://www.youtube.com/channel/UCBcRF18a7Qf58cCRy5xuWwQ`
- `UCBcRF18a7Qf58cCRy5xuWwQ`

#### Step 2: Configure options

- **Max Posts Per Channel**: How many posts to scrape (default: 50, max: 200). YouTube typically serves up to 200 posts per channel.
- **Post Types**: Filter by type: all, text only, polls only, images only, or video posts only.
- **Keyword Filter**: Only return posts that contain specific text.
- **Date Range**: Only return posts from a specific time period (approximate, since YouTube shows relative timestamps like "2 days ago").

#### Step 3: Run and get results

Click **Start** and wait for the run to finish. Results appear in the **Output** tab as they are scraped. You can export them as JSON, CSV, or Excel.

### 📊 What you get

Each post in the output includes:

| Field | Description |
|-------|-------------|
| `status` | "Success" or an error message explaining what went wrong |
| `postId` | Unique post identifier |
| `postUrl` | Direct link to the post |
| `postType` | text, poll, image, video, or shared |
| `channelName` | Channel display name |
| `channelId` | Channel ID |
| `channelUrl` | Channel URL |
| `text` | Full post text content |
| `publishedTimeText` | When the post was published (e.g. "2 days ago") |
| `likeCount` | Number of likes |
| `commentCount` | Number of comments |
| `pollChoices` | Poll options with vote percentages (poll posts only) |
| `images` | Image URLs with dimensions (image posts only) |
| `videoId` | Embedded video ID (video posts only) |
| `videoTitle` | Embedded video title (video posts only) |

### 🔌 Paid add-ons

These optional features add extra data to each post. You are only charged when the enrichment succeeds.

#### Comments ($0.001 per comment)
Enable **Include Post Comments** to scrape comments on each community post. Comments are embedded in each post's output row. Set the max comments per post (default: 10, max: 100).

#### Image Download ($0.002 per image)
Enable **Download Images** to save full-resolution images from image posts to your Apify storage. Each post's output includes download URLs for the stored images.

#### Language Detection ($0.0005 per detection)
Enable **Detect Post Language** to automatically identify the language of each post's text. Adds a `detectedLanguage` field (e.g. "eng", "spa", "kor").

### 💰 Pricing

You only pay for what you scrape. No monthly fees.

| What you pay for | Cost |
|-----------------|------|
| Each post scraped | $0.003 |
| Each comment scraped (add-on) | $0.001 |
| Each image downloaded (add-on) | $0.002 |
| Each language detection (add-on) | $0.0005 |

**Example**: Scraping 100 posts from a channel costs $0.30. Adding 5 comments per post adds $0.50. Total: $0.80.

### 🌐 Proxy settings

By default, the scraper uses Apify's datacenter proxies for fast, reliable access.

- **Automatic (default)**: Apify selects the best proxy.
- **Datacenter**: Fast and cheap. Works well for most channels.
- **Residential**: Use if you get frequent blocks or empty results.
- **Own proxies**: Provide your own proxy URLs.
- **No proxy**: Disable proxies. There will be no IP rotation if you get blocked.

### 💡 Good to know

- YouTube serves up to **200 community posts** per channel. There is no way to access older posts beyond this limit.
- **Date filtering is approximate.** YouTube shows relative timestamps ("3 weeks ago"), not exact dates. Filtering works best for recent posts.
- **Not all channels have a Community tab.** Channels need to meet YouTube's eligibility requirements. If a channel has no community posts, you will get an error message explaining this.
- **Video posts include video details, not the video file itself.** For video-type community posts, the scraper returns the video ID, title, and thumbnail. To download the actual video, use the [YouTube Video Downloader](https://apify.com/lurkapi/youtube-video-downloader).
- **Image storage** depends on your Apify plan. How long downloaded images are kept depends on your subscription.
- The scraper handles text posts, image posts (single and multi-image), polls, video shares, and shared/reposted content.

### ❓ FAQ

**Why did a channel return an error?**
The most common reasons: the channel does not exist, is private, or does not have a Community tab enabled. Check the `status` field in the output for a specific explanation.

**Which proxy should I use?**
Start with the default (Automatic). If you see empty results or errors mentioning "blocked" or "sign-in required", switch to Residential proxies.

**Can I scrape more than 200 posts?**
No. YouTube limits community post feeds to approximately 200 posts. This is a platform restriction that all scrapers share.

**How accurate is the date filter?**
It is approximate. YouTube provides relative timestamps ("2 weeks ago"), which the scraper converts to dates. Posts near the boundary of your date range may be included or excluded. For best results, add a buffer of a few days.

**Are poll votes and percentages available?**
The total vote count is extracted for each poll. Individual choice percentages are not available because YouTube only shows them to users who have voted, and the scraper runs without authentication.

### 🔗 Other tools you might like

- [YouTube Comments Scraper](https://apify.com/lurkapi/youtube-comments-scraper) - Scrape comments from YouTube videos and Shorts.
- [YouTube Video Downloader](https://apify.com/lurkapi/youtube-video-downloader) - Download YouTube videos and audio files.
- [YouTube Channel Email Scraper](https://apify.com/lurkapi/youtube-channel-email-scraper) - Extract contact emails from YouTube channels.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with YouTube's Terms of Service and applicable laws in your jurisdiction. The developer is not liable for misuse. Data availability depends on YouTube at run time.

**Keywords:** youtube community posts, youtube community tab scraper, youtube posts extractor, youtube channel posts, youtube engagement data

# Actor input Schema

## `urls` (type: `array`):

YouTube channel URLs, @handles, or channel IDs. Accepts formats like @mkbhd, https://www.youtube.com/@mkbhd, https://www.youtube.com/channel/UCBcRF18a7Qf58cCRy5xuWwQ, or bare channel IDs starting with UC. Up to 100 channels per run.
## `maxPostsPerChannel` (type: `integer`):

Maximum number of community posts to scrape per channel. YouTube typically serves up to 200 posts per channel.
## `postTypes` (type: `string`):

Filter by post type. 'All' includes every post type.
## `keyword` (type: `string`):

Only include posts containing this text. Leave empty to include all posts. Case-insensitive.
## `dateFrom` (type: `string`):

Only include posts published after this date (approximate). YouTube shows relative timestamps like '2 days ago', so filtering is approximate.
## `dateTo` (type: `string`):

Only include posts published before this date (approximate).
## `includeComments` (type: `boolean`):

Scrape comments on each community post. Comments are embedded in each post's output row. This is a paid add-on ($0.001 per comment) and increases run time.
## `maxCommentsPerPost` (type: `integer`):

Maximum number of comments to scrape per community post. Only used when 'Include Post Comments' is enabled.
## `downloadImages` (type: `boolean`):

Download full-resolution images from image posts to Apify Key-Value Store. Adds download URLs to the output. You are only charged per image successfully stored ($0.002 per image).
## `detectLanguage` (type: `boolean`):

Detect the language of each post's text using NLP. Adds a 'detectedLanguage' field to the output. You are only charged when a language is successfully detected, not when detection fails ($0.0005 per detection).
## `concurrency` (type: `integer`):

Number of channels to process in parallel. Higher values are faster but use more memory.
## `proxyConfig` (type: `object`):

Select proxies for accessing YouTube.

## Actor input object example

```json
{
  "urls": [
    "@mkbhd"
  ],
  "maxPostsPerChannel": 50,
  "postTypes": "all",
  "includeComments": false,
  "maxCommentsPerPost": 10,
  "downloadImages": false,
  "detectLanguage": false,
  "concurrency": 3,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
````

# Actor output Schema

## `posts` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "urls": [
        "@mkbhd"
    ],
    "postTypes": "all",
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/youtube-community-posts-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 = {
    "urls": ["@mkbhd"],
    "postTypes": "all",
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/youtube-community-posts-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 '{
  "urls": [
    "@mkbhd"
  ],
  "postTypes": "all",
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lurkapi/youtube-community-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Community Posts Scraper",
        "description": "Scrape community posts from YouTube channels. Extract text, images, polls, videos, likes, comments, and engagement data from any channel's Community tab.",
        "version": "0.0",
        "x-build-id": "bEEWORMmdzbifeiRO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~youtube-community-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-youtube-community-posts-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/lurkapi~youtube-community-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-youtube-community-posts-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/lurkapi~youtube-community-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-youtube-community-posts-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "YouTube Channel URLs, @handles, or Channel IDs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "YouTube channel URLs, @handles, or channel IDs. Accepts formats like @mkbhd, https://www.youtube.com/@mkbhd, https://www.youtube.com/channel/UCBcRF18a7Qf58cCRy5xuWwQ, or bare channel IDs starting with UC. Up to 100 channels per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerChannel": {
                        "title": "Max Posts Per Channel",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of community posts to scrape per channel. YouTube typically serves up to 200 posts per channel.",
                        "default": 50
                    },
                    "postTypes": {
                        "title": "Post Types to Include",
                        "enum": [
                            "all",
                            "text",
                            "poll",
                            "image",
                            "video"
                        ],
                        "type": "string",
                        "description": "Filter by post type. 'All' includes every post type.",
                        "default": "all"
                    },
                    "keyword": {
                        "title": "Keyword Filter",
                        "type": "string",
                        "description": "Only include posts containing this text. Leave empty to include all posts. Case-insensitive."
                    },
                    "dateFrom": {
                        "title": "Posts From Date",
                        "type": "string",
                        "description": "Only include posts published after this date (approximate). YouTube shows relative timestamps like '2 days ago', so filtering is approximate."
                    },
                    "dateTo": {
                        "title": "Posts To Date",
                        "type": "string",
                        "description": "Only include posts published before this date (approximate)."
                    },
                    "includeComments": {
                        "title": "Include Post Comments",
                        "type": "boolean",
                        "description": "Scrape comments on each community post. Comments are embedded in each post's output row. This is a paid add-on ($0.001 per comment) and increases run time.",
                        "default": false
                    },
                    "maxCommentsPerPost": {
                        "title": "Max Comments Per Post",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of comments to scrape per community post. Only used when 'Include Post Comments' is enabled.",
                        "default": 10
                    },
                    "downloadImages": {
                        "title": "Download Images",
                        "type": "boolean",
                        "description": "Download full-resolution images from image posts to Apify Key-Value Store. Adds download URLs to the output. You are only charged per image successfully stored ($0.002 per image).",
                        "default": false
                    },
                    "detectLanguage": {
                        "title": "Detect Post Language",
                        "type": "boolean",
                        "description": "Detect the language of each post's text using NLP. Adds a 'detectedLanguage' field to the output. You are only charged when a language is successfully detected, not when detection fails ($0.0005 per detection).",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of channels to process in parallel. Higher values are faster but use more memory.",
                        "default": 3
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies for accessing YouTube.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
