# Twitch Channel Scraper (`khadinakbar/twitch-channel-scraper`) Actor

Scrape public Twitch channels by username or URL — profile, live status, follower count, partner/affiliate type, recent videos (VODs), and top clips. HTTP-only via the Twitch GraphQL API, no login. MCP-ready.

- **URL**: https://apify.com/khadinakbar/twitch-channel-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Videos, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 channel scrapeds

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

## Twitch Channel Scraper

Scrape public **Twitch channels** by username or URL and get a clean, structured record for each one — profile details, **live status**, follower count, partner/affiliate type, recent videos (VODs), and top clips. HTTP-only via the Twitch GraphQL API, **no login required**, and **MCP-ready** for AI agents.

### What it does

Give it a list of Twitch channels (usernames like `shroud`, or full URLs like `https://www.twitch.tv/pokimane`). For each channel it returns one record containing:

- **Identity** — login, display name, channel ID, bio, account creation date, account age.
- **Status** — partner / affiliate flags, broadcaster type.
- **Audience** — total follower count.
- **Live state** — whether the channel is live right now, plus live title, game/category, current viewer count, and stream start time. When offline, it returns the last-set title and category instead.
- **Most recent broadcast** — title and start time.
- **Recent videos (VODs)** — newest first, with view counts, duration, publish date, and game.
- **Top clips** — ranked by views within your chosen time window.
- **Branding** — profile avatar, banner, offline image, and channel color.

### When to use it

- **Influencer / sponsorship scouting** — size up a creator's audience and current activity before reaching out.
- **Streamer analytics & dashboards** — track follower counts and live status across many channels.
- **Esports & gaming research** — pull rosters of channels and what they're streaming.
- **AI agents** — a clean tool call: channel in, structured JSON out.

**Not** for scraping Twitch search results, categories/games, chat messages, or VOD transcripts — those are separate jobs.

### Output

One record per channel. Example (`detailed` format, trimmed):

```json
{
  "channelUrl": "https://www.twitch.tv/shroud",
  "login": "shroud",
  "channelId": "37402112",
  "displayName": "shroud",
  "description": "I'm back baby",
  "createdAt": "2012-11-03T15:50:32.878Z",
  "accountAgeYears": 13.6,
  "isPartner": true,
  "isAffiliate": false,
  "broadcasterType": "partner",
  "followerCount": 11300996,
  "isLive": true,
  "streamTitle": "GETTING MY DRIVERS LICENSE",
  "streamGame": "Forza Horizon 6",
  "streamViewers": 2629,
  "streamStartedAt": "2026-06-20T17:10:04Z",
  "streamType": "live",
  "lastBroadcastTitle": "GETTING MY DRIVERS LICENSE",
  "lastBroadcastStartedAt": "2026-06-20T17:10:04Z",
  "primaryColorHex": "#0000FF",
  "profileImageUrl": "https://static-cdn.jtvnw.net/jtv_user_pictures/...-300x300.png",
  "bannerImageUrl": "https://static-cdn.jtvnw.net/...",
  "recentVideos": [
    { "id": "2801374356", "title": "...", "viewCount": 246565, "durationSeconds": 10812, "publishedAt": "2026-06-17T17:05:31Z", "game": "Just Chatting", "url": "https://www.twitch.tv/videos/2801374356" }
  ],
  "topClips": [
    { "slug": "...", "title": "...", "viewCount": 91234, "durationSeconds": 30, "createdAt": "2026-06-12T...", "url": "https://clips.twitch.tv/..." }
  ],
  "found": true,
  "scrapedAt": "2026-06-20T19:00:00Z"
}
````

| Field | Type | Description |
|---|---|---|
| `login` | string | Lowercase Twitch username |
| `displayName` | string | Channel display name |
| `followerCount` | integer | Total followers |
| `broadcasterType` | string | `partner`, `affiliate`, or `""` |
| `isLive` | boolean | Currently streaming? |
| `streamTitle` / `streamGame` | string | Live (or last-set) title and category |
| `streamViewers` | integer | Current live viewers (null offline) |
| `recentVideos` | array | Recent VODs (newest first) |
| `topClips` | array | Top clips by views in the chosen window |
| `found` | boolean | `false` when a channel doesn't exist or fails |

Choose `responseFormat: "concise"` to drop images, videos, and clips for a smaller payload (handy for AI agents).

### Pricing

Pay-per-event:

- **Actor start** — $0.00005 per run.
- **Channel scraped** — **$0.004 per existing channel** returned. Channels that don't exist or fail are **not** charged.

A 100-channel run costs about **$0.40**. Pay-per-usage (compute + proxy) is also available — pick whichever billing fits at run time.

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `channels` | yes | — | Usernames or channel URLs |
| `maxVideos` | no | 10 | Recent videos per channel (0–100, 0 to skip) |
| `maxClips` | no | 10 | Top clips per channel (0–100, 0 to skip) |
| `clipsPeriod` | no | `LAST_MONTH` | `LAST_DAY` / `LAST_WEEK` / `LAST_MONTH` / `ALL_TIME` |
| `responseFormat` | no | `detailed` | `detailed` or `concise` |

#### Example input

```json
{
  "channels": ["shroud", "pokimane", "https://www.twitch.tv/xqc"],
  "maxVideos": 5,
  "maxClips": 5,
  "clipsPeriod": "LAST_WEEK"
}
```

### Run it

#### API (JavaScript)

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/twitch-channel-scraper').call({
    channels: ['shroud', 'pokimane'],
    maxVideos: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/twitch-channel-scraper").call(
    run_input={"channels": ["shroud", "pokimane"], "maxVideos": 5}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["displayName"], item["followerCount"], item["isLive"])
```

#### MCP (AI agents)

Exposed as `khadinakbar/twitch-channel-scraper` through the [Apify MCP server](https://mcp.apify.com). An agent passes a channel list and gets structured JSON back — ideal for "how big is this streamer and are they live?" questions.

### FAQ

**Do I need a Twitch account or API key?** No. It uses Twitch's public, anonymous web GraphQL endpoint.

**Can it scrape private or subscriber-only data?** No. Public channel data only.

**Does it return live viewer counts?** Yes, when the channel is live (`streamViewers`). Counts are a snapshot at scrape time.

**What happens for a channel that doesn't exist?** You get a record with `found: false` and an `error` note, and you are not charged for it.

**How many channels per run?** No hard limit — pass as many as you like; cost scales linearly at $0.004 per existing channel.

### Legal

This actor collects only publicly available data from Twitch and does not bypass authentication or access private information. You are responsible for using the data in compliance with Twitch's Terms of Service, applicable laws (including data-protection laws such as GDPR/CCPA), and any third-party rights. This tool is intended for lawful purposes such as research, analytics, and business intelligence. It is not affiliated with or endorsed by Twitch Interactive, Inc.

# Actor input Schema

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

List of Twitch channels to scrape, as usernames or full channel URLs (e.g. "shroud" or "https://www.twitch.tv/pokimane"). @handles and URLs with extra path/query are accepted and normalized to the login. Each unique channel returns one dataset record. This is NOT a search query and NOT a category/game name — provide exact channel identities.

## `maxVideos` (type: `integer`):

How many recent videos (past broadcasts / VODs) to include per channel, newest first. Range 0–100; defaults to 10. Set 0 to skip videos entirely and reduce output size. Each video item carries id, title, viewCount, durationSeconds, publishedAt, game, and url.

## `maxClips` (type: `integer`):

How many top clips to include per channel, sorted by views within the selected period. Range 0–100; defaults to 10. Set 0 to skip clips. Each clip item carries slug, title, viewCount, durationSeconds, createdAt, and url.

## `clipsPeriod` (type: `string`):

Time window used to rank the top clips returned. One of LAST\_DAY, LAST\_WEEK, LAST\_MONTH, or ALL\_TIME; defaults to LAST\_MONTH. Only affects clips, not videos. Ignored when maxClips is 0.

## `responseFormat` (type: `string`):

Controls record richness. 'detailed' (default) returns all fields including images, recent videos, and top clips. 'concise' returns only core channel + live-status fields for a smaller, cheaper-to-read payload (useful for AI agents). Does NOT change pricing.

## `proxyConfiguration` (type: `object`):

Proxy settings for outbound requests. Defaults to Apify datacenter proxy, which is sufficient for the Twitch GraphQL API. You normally do not need to change this.

## Actor input object example

```json
{
  "channels": [
    "shroud",
    "ninja"
  ],
  "maxVideos": 10,
  "maxClips": 10,
  "clipsPeriod": "LAST_MONTH",
  "responseFormat": "detailed",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

One record per Twitch channel with profile, live status, followers, videos, and clips. Download as JSON, CSV, Excel, HTML, or RSS.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "channels": [
        "shroud",
        "pokimane",
        "https://www.twitch.tv/xqc"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/twitch-channel-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "channels": [
        "shroud",
        "pokimane",
        "https://www.twitch.tv/xqc",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/twitch-channel-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channels": [
    "shroud",
    "pokimane",
    "https://www.twitch.tv/xqc"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/twitch-channel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Channel Scraper",
        "description": "Scrape public Twitch channels by username or URL — profile, live status, follower count, partner/affiliate type, recent videos (VODs), and top clips. HTTP-only via the Twitch GraphQL API, no login. MCP-ready.",
        "version": "1.0",
        "x-build-id": "cnxlH6H72dJ7YbC1b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~twitch-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-twitch-channel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~twitch-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-twitch-channel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~twitch-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-twitch-channel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "Twitch channels",
                        "type": "array",
                        "description": "List of Twitch channels to scrape, as usernames or full channel URLs (e.g. \"shroud\" or \"https://www.twitch.tv/pokimane\"). @handles and URLs with extra path/query are accepted and normalized to the login. Each unique channel returns one dataset record. This is NOT a search query and NOT a category/game name — provide exact channel identities.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "Max recent videos per channel",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many recent videos (past broadcasts / VODs) to include per channel, newest first. Range 0–100; defaults to 10. Set 0 to skip videos entirely and reduce output size. Each video item carries id, title, viewCount, durationSeconds, publishedAt, game, and url.",
                        "default": 10
                    },
                    "maxClips": {
                        "title": "Max top clips per channel",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many top clips to include per channel, sorted by views within the selected period. Range 0–100; defaults to 10. Set 0 to skip clips. Each clip item carries slug, title, viewCount, durationSeconds, createdAt, and url.",
                        "default": 10
                    },
                    "clipsPeriod": {
                        "title": "Clips time window",
                        "enum": [
                            "LAST_DAY",
                            "LAST_WEEK",
                            "LAST_MONTH",
                            "ALL_TIME"
                        ],
                        "type": "string",
                        "description": "Time window used to rank the top clips returned. One of LAST_DAY, LAST_WEEK, LAST_MONTH, or ALL_TIME; defaults to LAST_MONTH. Only affects clips, not videos. Ignored when maxClips is 0.",
                        "default": "LAST_MONTH"
                    },
                    "responseFormat": {
                        "title": "Response format",
                        "enum": [
                            "detailed",
                            "concise"
                        ],
                        "type": "string",
                        "description": "Controls record richness. 'detailed' (default) returns all fields including images, recent videos, and top clips. 'concise' returns only core channel + live-status fields for a smaller, cheaper-to-read payload (useful for AI agents). Does NOT change pricing.",
                        "default": "detailed"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for outbound requests. Defaults to Apify datacenter proxy, which is sufficient for the Twitch GraphQL API. You normally do not need to change this.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
