# YouTube Shorts & Video Scrapper (`byte_genie/youtube-scrapper`) Actor

The actor returns incredibly rich data: Channel Info: Full statistics, branding, metadata Video Details: 30+ fields per video including engagement metrics Summary Stats: Aggregated data for analysis API Usage: Track your quota consumption

- **URL**: https://apify.com/byte\_genie/youtube-scrapper.md
- **Developed by:** [ByteGenie](https://apify.com/byte_genie) (community)
- **Categories:** Social media, Automation, Agents
- **Stats:** 14 total users, 2 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Data Scraper

A powerful Apify actor that uses the **official YouTube Data API v3** to scrape comprehensive channel and video data. Get rich metadata including statistics, thumbnails, engagement metrics, and more - all 100% reliable without getting blocked!

### ✨ Features

- ✅ **100% Reliable** - Uses official YouTube API, never gets blocked
- 📊 **Rich Data** - Comprehensive metadata for videos and channels
- 🎯 **Smart Filtering** - Filter by content type (shorts/videos/all)
- 📈 **Multiple Sort Options** - Sort by newest, oldest, or most popular
- 💰 **Free Tier** - 10,000 quota units per day (thousands of videos)
- 🚀 **Fast & Efficient** - Direct API access, no browser automation needed
- 📝 **Detailed Analytics** - Engagement rates, statistics, and summaries

### 🎯 What You Can Scrape

#### Channel Information
- Channel ID, title, handle, custom URL
- Subscriber count, video count, total views
- Channel description, country, creation date
- Channel banner, thumbnails (all sizes)
- Keywords, default language
- Upload playlist ID

#### Video Data
- Video ID, title, description, URL
- View count, like count, comment count
- Duration (with short detection)
- All thumbnail sizes (including maxres)
- Tags, category, topic categories
- Upload date and timestamp
- Privacy status, license type
- Made for kids status
- Engagement rate calculation
- HD/SD quality, captions availability
- Default audio language

### 🚀 Quick Start

#### Step 1: Get Your YouTube API Key (Free)

1. **Go to Google Cloud Console**
   - Visit: https://console.cloud.google.com/
   - Sign in with your Google account

2. **Create a New Project** (or select existing)
   - Click "Select a project" → "New Project"
   - Enter project name (e.g., "YouTube Scraper")
   - Click "Create"

3. **Enable YouTube Data API v3**
   - Go to: https://console.cloud.google.com/apis/library
   - Search for "YouTube Data API v3"
   - Click on it and press "ENABLE"

4. **Create API Credentials**
   - Go to: https://console.cloud.google.com/apis/credentials
   - Click "CREATE CREDENTIALS" → "API Key"
   - Your API key will be displayed (looks like: `AIzaSyD-9tSrke72PouQMGMb-9WKnxzY2pnnDEo`)
   - Click "RESTRICT KEY" for security (recommended)

5. **Restrict Your API Key** (Recommended)
   - Under "Application restrictions":
     - Select "IP addresses" for server use
     - Or "None" for testing
   - Under "API restrictions":
     - Select "Restrict key"
     - Choose "YouTube Data API v3"
   - Click "Save"

#### Step 2: Run the Actor

Use your API key in the input:

```json
{
  "youtube_api_key": "YOUR_API_KEY_HERE",
  "channel": "@MrBeast",
  "content_type": "all",
  "max_results": 50,
  "sort_by": "newest"
}
````

### 📥 Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `youtube_api_key` | String | ✅ Yes | - | Your YouTube Data API v3 key |
| `channel` | String | ✅ Yes | - | Channel input (see formats below) |
| `content_type` | String | No | `"all"` | Filter: `"all"`, `"shorts"`, `"videos"` |
| `max_results` | Integer | No | `50` | Number of videos to fetch (1-500) |
| `sort_by` | String | No | `"newest"` | Sort order: `"newest"`, `"oldest"`, `"popular"` |

#### Supported Channel Input Formats

The actor accepts multiple channel input formats:

- **Handle**: `@MrBeast` or `MrBeast`
- **Channel URL**: `https://www.youtube.com/@MrBeast`
- **Channel ID URL**: `https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA`
- **Custom URL**: `https://www.youtube.com/c/MrBeast6000`
- **Legacy User URL**: `https://www.youtube.com/user/MrBeast6000`
- **Direct Channel ID**: `UCX6OQ3DkcsbYNE6H8uQQuVA`

### 📤 Output Example

```json
{
  "success": true,
  "channel": {
    "channel_id": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "title": "MrBeast",
    "custom_url": "https://www.youtube.com/@mrbeast",
    "handle": "mrbeast",
    "description": "SUBSCRIBE FOR A COOKIE!",
    "country": "US",
    "published_at": "2012-02-20T00:43:50Z",
    "statistics": {
      "subscriber_count": 234000000,
      "video_count": 741,
      "view_count": 42853906283
    },
    "thumbnails": {
      "default": { "url": "...", "width": 88, "height": 88 },
      "medium": { "url": "...", "width": 240, "height": 240 },
      "high": { "url": "...", "width": 800, "height": 800 }
    }
  },
  "videos": [
    {
      "video_id": "kX3nB4PpJko",
      "title": "Last To Take Hand Off Jet, Keeps It!",
      "description": "Subscribe to help me win against T-Series...",
      "url": "https://www.youtube.com/watch?v=kX3nB4PpJko",
      "published_at": "2024-06-01T12:00:09Z",
      "duration": {
        "iso8601": "PT17M49S",
        "seconds": 1069,
        "human_readable": "17m 49s",
        "is_short": false
      },
      "statistics": {
        "view_count": 149823447,
        "like_count": 5234122,
        "comment_count": 89234
      },
      "engagement_rate": 3.5523,
      "thumbnails": {
        "maxres": { "url": "...", "width": 1280, "height": 720 }
      },
      "tags": ["mrbeast", "challenge", "jet"],
      "content_type": "video"
    }
  ],
  "summary": {
    "total_videos_fetched": 50,
    "total_views": 4234567890,
    "total_likes": 123456789,
    "shorts_count": 12,
    "videos_count": 38
  },
  "api_usage": {
    "api_calls_made": 3,
    "estimated_quota_used": 103,
    "daily_quota_limit": 10000,
    "quota_remaining": 9897
  }
}
```

### 💡 API Quota Information

#### Free Tier Limits

- **10,000 quota units per day** (resets at midnight Pacific Time)
- Most operations cost 1 unit
- Search operations cost 100 units
- You can typically fetch **thousands of videos per day**

#### Quota Costs

| Operation | Quota Cost | Videos per 10,000 quota |
|-----------|------------|-------------------------|
| Get channel info | 1 unit | - |
| List videos | 1 unit | ~10,000 videos |
| Search channel | 100 units | ~100 searches |

#### Need More Quota?

1. Go to: https://console.cloud.google.com/apis/api/youtube.googleapis.com/quotas
2. Click "EDIT QUOTAS"
3. Request increase (can get 50,000-1,000,000 units/day)
4. Fill form with use case
5. Usually approved within 24-48 hours

### 🔍 Use Cases

- **Content Analysis** - Analyze channel performance and trends
- **Competitor Research** - Track competitor channels and strategies
- **Market Research** - Study content trends in your niche
- **Data Collection** - Build datasets for ML/AI projects
- **Social Media Monitoring** - Track brand mentions and engagement
- **Content Planning** - Identify successful content patterns

### 🛠️ Advanced Features

#### Filter by Content Type

- `"all"` - Get all videos
- `"shorts"` - Only YouTube Shorts (≤60 seconds)
- `"videos"` - Only regular videos (>60 seconds)

#### Sort Options

- `"newest"` - Most recent videos first
- `"oldest"` - Oldest videos first
- `"popular"` - Most viewed videos first

#### Batch Processing

Set `max_results` up to 500 to fetch large batches efficiently.

## Advanced Usage Examples

### Example 1: Get Latest Shorts from a Channel

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "@NatGeo",
  "content_type": "shorts",
  "max_results": 20,
  "sort_by": "newest"
}
```

### Example 2: Analyze Most Popular Videos

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "@TED",
  "content_type": "videos",
  "max_results": 100,
  "sort_by": "popular"
}
```

### Example 3: Get Channel's First Videos

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "https://www.youtube.com/@LinusTechTips",
  "content_type": "all",
  "max_results": 50,
  "sort_by": "oldest"
}
```

### Example 4: Using Channel ID Directly

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "UCX6OQ3DkcsbYNE6H8uQQuVA",
  "content_type": "all",
  "max_results": 25,
  "sort_by": "newest"
}
```

### Example 5: Music Channel Analysis

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "@BillieEilish",
  "content_type": "videos",
  "max_results": 200,
  "sort_by": "popular"
}
```

### Example 6: News Channel Recent Shorts

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "@CNN",
  "content_type": "shorts",
  "max_results": 30,
  "sort_by": "newest"
}
```

### Example 7: Gaming Channel Full Catalog

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "@PewDiePie",
  "content_type": "all",
  "max_results": 500,
  "sort_by": "newest"
}
```

### Example 8: Educational Content

```json
{
  "youtube_api_key": "YOUR_API_KEY",
  "channel": "@veritasium",
  "content_type": "videos",
  "max_results": 50,
  "sort_by": "popular"
}
```

### 🚨 Troubleshooting

#### Common Errors

| Error | Solution |
|-------|----------|
| "API key not valid" | Check if key is correct and YouTube Data API v3 is enabled |
| "Quota exceeded" | Wait for daily reset or request quota increase |
| "Channel not found" | Verify channel exists and try different input format |
| "Access Not Configured" | Enable YouTube Data API v3 in Google Cloud Console |

#### Getting Help

1. Check the error message in the output
2. Verify your API key is valid
3. Ensure YouTube Data API v3 is enabled
4. Check quota usage in Google Cloud Console
5. Try with a different channel to isolate issues

### 📝 Changelog

#### Version 1.0.0 (2024-09-14)

- Initial release
- Full YouTube Data API v3 integration
- Channel and video data extraction
- Shorts detection and filtering
- Engagement metrics calculation
- Comprehensive error handling

### 📄 License

This project is licensed under the Apache 2.0 License.

***

**Note**: This actor uses the official YouTube Data API v3 and complies with YouTube's Terms of Service. Always respect content creators' rights and YouTube's usage policies.

# Actor input Schema

## `youtube_api_key` (type: `string`):

Your YouTube Data API v3 key (get it from Google Cloud Console)

## `channel` (type: `string`):

YouTube channel handle (@username), URL, or channel ID

## `content_type` (type: `string`):

Filter by content type: all content, only shorts (≤60s), or only regular videos (>60s)

## `max_results` (type: `integer`):

Maximum number of videos to fetch (1-500)

## `sort_by` (type: `string`):

How to sort the results

## Actor input object example

```json
{
  "youtube_api_key": "AIzaSyD-XXXXXXXXXXXXXXXXXXXXXXXXXX",
  "channel": "@MrBeast or https://www.youtube.com/@MrBeast or UCX6OQ3DkcsbYNE6H8uQQuVA",
  "content_type": "all",
  "max_results": 50,
  "sort_by": "newest"
}
```

# 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 = {
    "channel": "@MrBeast"
};

// Run the Actor and wait for it to finish
const run = await client.actor("byte_genie/youtube-scrapper").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 = { "channel": "@MrBeast" }

# Run the Actor and wait for it to finish
run = client.actor("byte_genie/youtube-scrapper").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 '{
  "channel": "@MrBeast"
}' |
apify call byte_genie/youtube-scrapper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Shorts & Video Scrapper",
        "description": "The actor returns incredibly rich data: Channel Info: Full statistics, branding, metadata Video Details: 30+ fields per video including engagement metrics Summary Stats: Aggregated data for analysis API Usage: Track your quota consumption",
        "version": "0.0",
        "x-build-id": "bEdvWlBvMWwH6mxDQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/byte_genie~youtube-scrapper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-byte_genie-youtube-scrapper",
                "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/byte_genie~youtube-scrapper/runs": {
            "post": {
                "operationId": "runs-sync-byte_genie-youtube-scrapper",
                "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/byte_genie~youtube-scrapper/run-sync": {
            "post": {
                "operationId": "run-sync-byte_genie-youtube-scrapper",
                "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": [
                    "youtube_api_key",
                    "channel"
                ],
                "properties": {
                    "youtube_api_key": {
                        "title": "YouTube API Key",
                        "type": "string",
                        "description": "Your YouTube Data API v3 key (get it from Google Cloud Console)"
                    },
                    "channel": {
                        "title": "Channel",
                        "type": "string",
                        "description": "YouTube channel handle (@username), URL, or channel ID"
                    },
                    "content_type": {
                        "title": "Content Type",
                        "enum": [
                            "all",
                            "shorts",
                            "videos"
                        ],
                        "type": "string",
                        "description": "Filter by content type: all content, only shorts (≤60s), or only regular videos (>60s)",
                        "default": "all"
                    },
                    "max_results": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of videos to fetch (1-500)",
                        "default": 50
                    },
                    "sort_by": {
                        "title": "Sort Order",
                        "enum": [
                            "newest",
                            "oldest",
                            "popular"
                        ],
                        "type": "string",
                        "description": "How to sort the results",
                        "default": "newest"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```