# Twitch Drops Campaign Tracker Scraper (`automation-lab/twitch-drops-campaign-tracker-scraper`) Actor

Track active and expired Twitch Drops campaigns by game, timing, status, and source links from the public TwDrop catalog.

- **URL**: https://apify.com/automation-lab/twitch-drops-campaign-tracker-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Drops Campaign Tracker Scraper

Track public Twitch Drops campaigns without manually checking hundreds of game pages.
This Actor reads the public TwDrop catalog and exports normalized campaign records for alerts, dashboards, research, and recurring monitoring.

### What does Twitch Drops Campaign Tracker Scraper do?

It discovers Twitch Drops campaigns across the TwDrop game catalog.
Each result includes a stable campaign ID, campaign title, game, status, dates, time remaining, source links, Twitch link, game image, and scrape timestamp.
Choose active, expired, or all campaigns.
Filter by game or campaign text.
Schedule the Actor to spot launches and expirations automatically.

### Who is it for?

- 🎮 Gaming publishers tracking promotional campaigns across a market.
- 📣 Community managers planning reminders before Drops expire.
- 🤝 Creator and sponsorship teams finding timely streaming opportunities.
- 🔔 Alert services feeding campaign changes into Discord, Slack, or email.
- 📊 Gaming-data products building searchable campaign archives.
- 🧑‍💻 Developers who need structured Twitch Drops data through an API.

### Why use this Twitch Drops tracker?

Manual checks are slow and difficult to compare over time.
The Actor produces one consistent record per campaign and can run on a schedule.
Stable IDs simplify dataset diffs.
ISO timestamps simplify sorting and alert rules.
No Twitch login or personalized inventory access is required.

### What data can you extract?

| Field | Meaning |
|---|---|
| `campaignId` | Stable campaign UUID exposed by TwDrop |
| `campaignTitle` | Public campaign name |
| `game` | Game title |
| `gameSlug` | TwDrop game slug |
| `status` | `active` or `expired` |
| `startAt` | Parsed ISO start timestamp, when available |
| `endAt` | Parsed ISO end timestamp, when available |
| `timeRemainingSeconds` | Seconds until the campaign ends |
| `sourceUrl` | Stable TwDrop source reference |
| `twitchUrl` | TwDrop redirect to the campaign on Twitch |
| `detailsUrl` | Public campaign detail or publisher link |
| `gameUrl` | TwDrop game campaign page |
| `gameImageUrl` | Public game artwork |
| `rewards` | Reserved normalized reward names when exposed publicly |
| `requirements` | Reserved watch requirements when exposed publicly |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape active Twitch Drops campaigns

1. Open the Actor input page.
2. Select **Active campaigns**.
3. Optionally enter a game name or campaign query.
4. Choose the maximum number of campaigns.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or another Apify format.

### Input options

#### Campaign status

`active` returns live campaigns.
`expired` returns historical campaigns.
`all` returns both groups.

#### Game filter

Enter a partial game name such as `Valorant`, `2XKO`, or `Apex`.
Matching is case-insensitive.
Leave it empty to scan the full catalog.

#### Campaign search

Use `query` to match campaign and game titles.
This is useful for seasons, launches, esports events, or publisher campaigns.

#### Maximum campaigns

`maxItems` controls the maximum dataset size.
Use a small limit for a quick test and a larger limit for archival exports.

#### Detail links

Enable `enrichDetails` to retain public external campaign detail links where TwDrop supplies them.
The Actor never claims rewards and never accesses personalized watch progress.

### Example input

```json
{
  "mode": "active",
  "game": "",
  "query": "",
  "maxItems": 100,
  "enrichDetails": true
}
````

### Example output

```json
{
  "campaignId": "77663c46-f1a1-11f0-8694-0a58a9feac02",
  "campaignTitle": "2XKO Season 1 Launch",
  "game": "2XKO",
  "gameSlug": "2xko",
  "status": "expired",
  "startAt": "2026-01-20T22:00:00.000Z",
  "endAt": "2026-02-03T21:59:00.000Z",
  "timeRemainingSeconds": 0,
  "sourceUrl": "https://twdrop.de/games/2xko#77663c46-f1a1-11f0-8694-0a58a9feac02",
  "twitchUrl": "https://twdrop.de/t/2xko/77663c46-f1a1-11f0-8694-0a58a9feac02/twitch",
  "scrapedAt": "2026-07-12T05:00:00.000Z"
}
```

### How much does it cost to track Twitch Drops campaigns?

The Actor uses pay-per-event pricing: a small run-start fee plus a charge for each campaign saved.
Apify plan tiers receive automatic volume discounts.
The Console shows the exact price before each run.
Set `maxItems` to control the maximum result charge.
A focused game monitor is usually cheaper than repeatedly exporting the entire archive.

### Scheduling campaign alerts

Create an Apify schedule that runs hourly or daily.
Keep the same input and compare datasets by `campaignId`.
A new ID indicates a newly discovered campaign.
A status change or lower `timeRemainingSeconds` can trigger an expiry reminder.
Use webhooks to start an integration after every successful run.

### Integrations

- 🔔 Send newly discovered campaigns to Discord through a webhook workflow.
- 💬 Post expiring campaigns to Slack with Make or Zapier.
- 📧 Generate community reminder emails from active records.
- 📊 Load campaign history into Google Sheets or a BI warehouse.
- 🗄️ Store records in PostgreSQL, Snowflake, BigQuery, or S3.
- ⚡ Trigger another Actor when a campaign is launched.

### API usage: JavaScript example

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/twitch-drops-campaign-tracker-scraper').call({
  mode: 'active',
  maxItems: 100,
  enrichDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient
import os
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/twitch-drops-campaign-tracker-scraper').call(run_input={
    'mode': 'active',
    'maxItems': 100,
    'enrichDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~twitch-drops-campaign-tracker-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"active","maxItems":100,"enrichDetails":true}'
```

### Use with Apify MCP

Connect AI assistants through `https://mcp.apify.com?tools=automation-lab/twitch-drops-campaign-tracker-scraper`.
In Claude Code, ask: “Run the Twitch Drops campaign tracker and summarize campaigns ending soon.”
In Claude Desktop, ask: “Find active Drops for games containing Apex and return their Twitch links.”
MCP lets an assistant run the Actor and inspect its dataset without custom glue code.

### Data quality and limitations

TwDrop is a third-party public tracker, not Twitch itself.
Campaign availability and translations reflect what TwDrop exposes.
Some campaigns do not publish reward names or watch requirements, so the corresponding arrays can be empty.
Dates are normalized from the visible German date format.
When a parsed `endAt` is in the past, the Actor always reports `expired`, even if TwDrop's visual styling is stale. If an end date is unavailable, status falls back to TwDrop's current visual label.
External detail links may point to a publisher page rather than a dedicated reward page.
Markup changes can temporarily affect extraction; source URLs are retained for verification.

### Tips for reliable monitoring

- Use `active` for frequent low-cost checks.
- Use `all` for periodic archive snapshots.
- Filter by game when only one community matters.
- Deduplicate on `campaignId`, not title.
- Compare `endAt` rather than localized display strings.
- Keep `scrapedAt` to audit when a status was observed.
- Configure a webhook only after a run succeeds.

### Legality: is scraping Twitch Drops legal?

The Actor accesses public, unauthenticated pages and does not bypass account controls.
It does not claim Drops, log in to Twitch, or access personal watch progress.
You are responsible for your use of the data and for complying with applicable laws, contracts, and website terms.
Avoid republishing copyrighted images in ways that exceed your rights.

### Troubleshooting

#### Why did I get no campaigns?

Check whether your game or query filter is too narrow.
Try `mode: "all"` and remove filters to verify the catalog.
A game may have no campaign in the selected status.

#### Why are rewards empty?

TwDrop's public catalog often exposes campaign timing and links but not structured reward requirements.
The Actor does not invent missing values.
Follow `detailsUrl` or `twitchUrl` for the authoritative campaign presentation.

#### Why is a time remaining value zero?

Expired campaigns intentionally return zero when an end timestamp is known. Active campaigns with a known end date return a positive value.
The Actor reconciles status against `endAt`; use both fields when building alerts and treat a missing end date as source-limited timing.

### FAQ

#### Does this Actor require a Twitch account?

No. It reads public TwDrop pages without Twitch authentication.

#### Can it claim Drops for me?

No. Claiming rewards and tracking personalized progress are intentionally out of scope.

#### Can I monitor one game?

Yes. Set the partial `game` filter and schedule recurring runs.

#### Can I export old campaigns?

Yes. Choose `expired` or `all` and increase `maxItems`.

#### Can I use a proxy?

Yes. Proxy configuration is optional because direct HTTP normally works.

#### How do I detect new campaigns?

Compare `campaignId` values between scheduled run datasets.

### Related scrapers

Explore other gaming and social-media data tools from [automation-lab](https://apify.com/automation-lab/).
Combine this Actor with Twitch channel or schedule actors when you need creator and broadcast context alongside Drops campaigns.
Only use actors that match your intended data source and legal basis.

### Support

If a run produces unexpected output, open an issue from the Actor page.
Include the input, run ID, affected game, and expected campaign.
That evidence makes target-markup changes faster to diagnose.

# Actor input Schema

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

Collect active campaigns, expired campaigns, or both.

## `game` (type: `string`):

Optional partial game name, for example Valorant or 2XKO.

## `query` (type: `string`):

Optional text matched against campaign titles and game names.

## `maxItems` (type: `integer`):

Stop after this many campaign records.

## `enrichDetails` (type: `boolean`):

Include each campaign's external detail link when TwDrop provides one.

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

Optional Apify Proxy. Direct requests work by default.

## Actor input object example

```json
{
  "mode": "active",
  "maxItems": 20,
  "enrichDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "active",
    "game": "",
    "query": "",
    "maxItems": 20,
    "enrichDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/twitch-drops-campaign-tracker-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": "active",
    "game": "",
    "query": "",
    "maxItems": 20,
    "enrichDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/twitch-drops-campaign-tracker-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": "active",
  "game": "",
  "query": "",
  "maxItems": 20,
  "enrichDetails": true
}' |
apify call automation-lab/twitch-drops-campaign-tracker-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Drops Campaign Tracker Scraper",
        "description": "Track active and expired Twitch Drops campaigns by game, timing, status, and source links from the public TwDrop catalog.",
        "version": "0.1",
        "x-build-id": "1Ukufob5lOgh8ZOM6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~twitch-drops-campaign-tracker-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-twitch-drops-campaign-tracker-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/automation-lab~twitch-drops-campaign-tracker-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-twitch-drops-campaign-tracker-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/automation-lab~twitch-drops-campaign-tracker-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-twitch-drops-campaign-tracker-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",
                "properties": {
                    "mode": {
                        "title": "🎯 Campaign status",
                        "enum": [
                            "active",
                            "all",
                            "expired"
                        ],
                        "type": "string",
                        "description": "Collect active campaigns, expired campaigns, or both.",
                        "default": "active"
                    },
                    "game": {
                        "title": "Game filter",
                        "type": "string",
                        "description": "Optional partial game name, for example Valorant or 2XKO."
                    },
                    "query": {
                        "title": "Campaign search",
                        "type": "string",
                        "description": "Optional text matched against campaign titles and game names."
                    },
                    "maxItems": {
                        "title": "Maximum campaigns",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many campaign records.",
                        "default": 100
                    },
                    "enrichDetails": {
                        "title": "Include detail links",
                        "type": "boolean",
                        "description": "Include each campaign's external detail link when TwDrop provides one.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy. Direct requests work by default."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```