# Twitch Scraper (`maximedupre/twitch-scraper`) Actor

Scrape public Twitch channel profiles, live streams, games, clips, and VOD metadata. Export source URLs, public metrics, media URLs, and timestamps.

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

## Pricing

from $1.60 / 1,000 scraped twitch 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

### 🎮 Twitch scraper for channels, streams, games, clips, and VODs

Twitch Scraper collects public data from [Twitch](https://www.twitch.tv/) channels, live streams, games, clips, and VOD pages. Add channel URLs, usernames, game names, game directory URLs, VOD URLs, or VOD IDs, then export rows with profile fields, live status, viewer counts, media URLs, source URLs, and scrape timestamps.

Use this Twitch scraper for creator research, live-stream monitoring, game discovery, clip tracking, VOD enrichment, or repeatable Twitch data feeds. It works with public Twitch surfaces and does not ask for cookies, a login, or a Twitch API key.

For a small first run, keep **Mode** set to `Top live streams` and start the Actor. Switch to `Channel profiles` with a target such as `https://www.twitch.tv/shroud` when you want one channel profile.

### ✅ What this Actor does

- Scrapes Twitch channel profiles.
- Searches Twitch channels by keyword.
- Scrapes top live streams.
- Scrapes live streams for a game or game directory.
- Scrapes top games.
- Scrapes clips from a channel for a selected time period.
- Scrapes public VOD metadata from Twitch video URLs or IDs.
- Saves one dataset row per Twitch result.
- Adds source fields so every row can be traced back to the input.
- Stops at your selected result limits and skips unavailable public items.

This Actor focuses on public Twitch metadata. It does not download videos, scrape private chat, log in, bypass subscriber-only content, or collect hidden data.

### 📦 Data you can export

Every row includes `rowType`, `sourceMode`, `sourceTarget`, `sourceRank`, `sourceUrl`, and `scrapedAt`. Other fields depend on the Twitch surface you scrape.

Channel rows can include:

- Channel ID, login, display name, description, and URL
- Profile and banner image URLs
- Follower count when Twitch exposes it
- Partner and affiliate flags
- Live status, viewers, stream title, current game, and start time
- Channel creation date
- Last broadcast title, game, and date
- Optional recent VODs and top clips

Stream rows can include:

- Stream ID, title, viewer count, game, start time, and preview image URL
- Broadcaster profile details
- Tags and source ranking

Game rows can include:

- Game ID, display name, viewer count, broadcaster count, box art URL, and tags

Clip and video rows can include:

- Clip or video ID, title, views, duration, creation date, thumbnail URL, and URL
- Game details
- Broadcaster details
- Curator details for clips

Unavailable fields are saved as `null` or empty arrays instead of guessed values.

### 🚀 How to run

1. Choose **Mode** based on the Twitch surface you want.
2. Add one target per line unless you are using **Top live streams** or **Top games**, which can run without targets.
3. Set **Results per target** for search, stream, game, clip, and top-list modes.
4. For channel profiles, decide whether to include recent videos and top clips.
5. For clips, choose the clip period.
6. Run the Actor and open the dataset.

Start with one or two targets and a low result limit when testing a new workflow.

### 🔎 Input options

`mode` controls what the Actor collects:

- `channels` gets one public channel profile per channel target.
- `searchChannels` searches Twitch channels by keyword.
- `topStreams` gets top live streams and does not require targets.
- `gameStreams` gets live streams for a game name or game directory URL.
- `topGames` gets top Twitch games and does not require targets.
- `clips` gets clips from channel targets.
- `videos` gets one VOD metadata row per VOD URL or ID.

`targets` accepts values for the selected mode: usernames such as `shroud`, channel URLs such as `https://www.twitch.tv/shroud`, game names such as `Just Chatting`, game directory URLs, VOD URLs, or VOD IDs.

`maxResults` limits rows per target for browse and search modes. Twitch browse surfaces are capped at 30 results per target.

`clipPeriod` controls the clip time range.

`includeRecentVideos`, `includeTopClips`, `recentVideosLimit`, and `topClipsLimit` control optional channel enrichment.

Example input:

```json
{
	"mode": "channels",
	"targets": ["https://www.twitch.tv/shroud"],
	"maxResults": 30,
	"clipPeriod": "LAST_WEEK",
	"includeRecentVideos": true,
	"includeTopClips": false,
	"recentVideosLimit": 5,
	"topClipsLimit": 5
}
````

### 📄 Output example

```json
{
	"rowType": "channel",
	"sourceMode": "channels",
	"sourceTarget": "https://www.twitch.tv/shroud",
	"sourceRank": 1,
	"sourceUrl": "https://www.twitch.tv/shroud",
	"id": "37402112",
	"login": "shroud",
	"displayName": "shroud",
	"profileImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/example-profile_image-300x300.png",
	"bannerImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/example-channel_offline_image.png",
	"followersCount": 10000000,
	"isPartner": true,
	"isAffiliate": false,
	"isLive": true,
	"currentViewers": 25000,
	"streamTitle": "Live stream title",
	"currentGame": "Just Chatting",
	"startedAt": "2026-05-27T12:00:00.000Z",
	"createdAt": "2011-11-22T00:00:00.000Z",
	"lastBroadcastTitle": "Previous broadcast title",
	"lastBroadcastGame": "Marvel Rivals",
	"lastBroadcastDate": "2026-05-26T21:10:00.000Z",
	"recentVideos": [
		{
			"id": "1234567890",
			"title": "Recent VOD title",
			"url": "https://www.twitch.tv/videos/1234567890",
			"createdAt": "2026-05-26T21:10:00.000Z",
			"durationSeconds": 5400,
			"viewCount": 123456
		}
	],
	"topClips": [],
	"scrapedAt": "2026-05-27T12:30:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. Channel profile rows use the channel event because they can include richer profile and enrichment data. Stream, game, clip, and video rows use the lighter Twitch item event.

You only pay for rows that are successfully saved to the dataset. Unavailable channels, missing videos, and empty searches do not create paid output rows.

### 💡 Common use cases

- Build creator lists with profile, follower, and live-status fields.
- Monitor live streams for a game, category, or competitor set.
- Track games and streamers gaining attention.
- Export clips and VOD metadata for content research.
- Enrich a CRM or creator database with Twitch profile fields.
- Schedule recurring exports into Apify integrations, webhooks, spreadsheets, or BI tools.

### ⚠️ Limits and notes

- The Actor uses public Twitch data, so fields can be missing when Twitch does not expose them.
- Top streams, top games, channel search, game streams, and clips are capped at 30 rows per target.
- `channels` mode saves one channel row per valid target.
- `videos` mode saves one VOD row per valid VOD URL or ID.
- Clip URLs are not input targets. Use a channel target and choose a clip period.
- Results can change quickly because Twitch live streams, viewer counts, games, clips, and VOD availability change throughout the day.

### ❓ FAQ

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

No. The Actor works with public Twitch surfaces and does not require a Twitch API key, cookies, or login.

#### 📥 Can it download Twitch videos or clips?

No. It exports public metadata and source URLs. It does not download media files.

#### 🎯 Can I run it without targets?

Yes, but only for **Top live streams** and **Top games**. Other modes need at least one target.

#### 🧩 Why are some fields empty?

Twitch does not expose every field on every public page. Empty fields are returned as `null` or empty arrays instead of being guessed.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~twitch-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) - Export YouTube channel profiles and recent video rows without a YouTube API key.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search Twitter/X posts and export current trending topics.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Save public TikTok video or audio files with dataset metadata.
- [SoundCloud Scraper ↗](https://apify.com/maximedupre/soundcloud-scraper) - Collect public tracks, artists, playlists, albums, and comments from SoundCloud.
- [Reddit Scraper ↗](https://apify.com/maximedupre/reddit-scraper) - Search Reddit posts and comments around a topic or brand.

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

# Actor input Schema

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

Choose which public Twitch surface to scrape.

## `targets` (type: `array`):

Add one target per line. Use usernames or channel URLs for channel profiles and clips, a search phrase for channel search, a game name or game directory URL for game streams, and VOD URLs or IDs for videos. Top live streams and top games can run with an empty target list.

## `maxResults` (type: `integer`):

Maximum rows to save for each target. Twitch browse and search surfaces are capped at 30 results per target.

## `clipPeriod` (type: `string`):

Time range to use when scraping clips from channel targets.

## `includeRecentVideos` (type: `boolean`):

Add recent VOD metadata to channel profile rows when Twitch exposes it.

## `includeTopClips` (type: `boolean`):

Add top clip metadata to channel profile rows when Twitch exposes it.

## `recentVideosLimit` (type: `integer`):

Maximum recent VODs to include on each channel profile row.

## `topClipsLimit` (type: `integer`):

Maximum top clips to include on each channel profile row.

## Actor input object example

```json
{
  "mode": "topStreams",
  "targets": [],
  "maxResults": 30,
  "clipPeriod": "LAST_WEEK",
  "includeRecentVideos": true,
  "includeTopClips": false,
  "recentVideosLimit": 5,
  "topClipsLimit": 5
}
```

# Actor output Schema

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

Open the dataset with public Twitch result rows.

# 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 = {
    "mode": "topStreams",
    "targets": [],
    "maxResults": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/twitch-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 = {
    "mode": "topStreams",
    "targets": [],
    "maxResults": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/twitch-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 '{
  "mode": "topStreams",
  "targets": [],
  "maxResults": 30
}' |
apify call maximedupre/twitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Scraper",
        "description": "Scrape public Twitch channel profiles, live streams, games, clips, and VOD metadata. Export source URLs, public metrics, media URLs, and timestamps.",
        "version": "0.0",
        "x-build-id": "CFet1ip5hloaf6CpI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~twitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-twitch-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~twitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-twitch-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~twitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-twitch-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": [
                    "mode",
                    "maxResults",
                    "clipPeriod",
                    "includeRecentVideos",
                    "includeTopClips",
                    "recentVideosLimit",
                    "topClipsLimit"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "channels",
                            "searchChannels",
                            "topStreams",
                            "gameStreams",
                            "topGames",
                            "clips",
                            "videos"
                        ],
                        "type": "string",
                        "description": "Choose which public Twitch surface to scrape.",
                        "default": "topStreams"
                    },
                    "targets": {
                        "title": "Targets",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add one target per line. Use usernames or channel URLs for channel profiles and clips, a search phrase for channel search, a game name or game directory URL for game streams, and VOD URLs or IDs for videos. Top live streams and top games can run with an empty target list.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxResults": {
                        "title": "Results per target",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum rows to save for each target. Twitch browse and search surfaces are capped at 30 results per target.",
                        "default": 30
                    },
                    "clipPeriod": {
                        "title": "Clip period",
                        "enum": [
                            "LAST_DAY",
                            "LAST_WEEK",
                            "LAST_MONTH",
                            "ALL_TIME"
                        ],
                        "type": "string",
                        "description": "Time range to use when scraping clips from channel targets.",
                        "default": "LAST_WEEK"
                    },
                    "includeRecentVideos": {
                        "title": "Recent videos",
                        "type": "boolean",
                        "description": "Add recent VOD metadata to channel profile rows when Twitch exposes it.",
                        "default": true
                    },
                    "includeTopClips": {
                        "title": "Top clips",
                        "type": "boolean",
                        "description": "Add top clip metadata to channel profile rows when Twitch exposes it.",
                        "default": false
                    },
                    "recentVideosLimit": {
                        "title": "Recent videos per channel",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum recent VODs to include on each channel profile row.",
                        "default": 5
                    },
                    "topClipsLimit": {
                        "title": "Top clips per channel",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum top clips to include on each channel profile row.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
