# Gate.io Market Scraper (`logiover/gateio-market-scraper`) Actor

Scrape live market data for all 2,200+ Gate.io spot trading pairs in one run — last price, 24h change, high/low, base and quote volume and bid/ask. Filter by quote currency. Schedule it for a continuously fresh price feed.

- **URL**: https://apify.com/logiover/gateio-market-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## GOG.com Game Scraper — Scrape GOG Game Listings, Prices & Discounts

![Gate.io Market Scraper](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-58zQLqEdCTNMggf8u-OkGfNHbl2C-unnamed.jpg)

Scrape game listings from **GOG.com**, the DRM-free digital game store by CD PROJEKT, and export structured game data to JSON, CSV, or Excel. This GOG.com scraper extracts prices, discounts, ratings, reviews, developers, publishers, genres and platform compatibility for thousands of games — with keyword search, full-catalog browsing and advanced filters. **HTTP-only, no browser, no login and no API key required.**

### ✨ What this Actor does / Key features

- 🔎 **Keyword search** — search games by name, genre, franchise or any keyword.
- 📚 **Full catalog browsing** — leave the queries empty to browse the entire GOG catalog of 12,000+ games.
- 🎚️ **Advanced filters** — filter by price range (free, under $5/$10/$15/$25, on sale), platform (Windows/macOS/Linux), genre and supported language.
- 🔀 **Multiple sort options** — trending, best selling, price low/high, title A-Z, release date, or rating.
- 💸 **Rich pricing data** — final price, original price, discount percentage, currency, plus free and on-sale flags.
- ⭐ **Ratings & reviews** — user rating (0–5) and review counts for every game.
- ⚡ **Parallel scraping** — configurable concurrency for fast runs (48 products per page).
- 🧹 **Automatic deduplication** — duplicate products across multiple queries are removed automatically.
- 🖥️ **HTTP-only architecture** — no headless browser, making runs ultra-fast and cost-effective.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `queries` | array | Keywords to filter results (e.g., "rpg", "witcher", "indie"). Leave empty to browse the entire GOG catalog. |
| `maxPages` | integer | Maximum pages to scrape per query. Each page returns 48 products. Set to 250 for the full catalog. |
| `maxProductsTotal` | integer | Global limit on total products to scrape. Set 0 for unlimited. |
| `sortBy` | string | Sort order: trending, bestselling, price_asc, price_desc, title, release_date, rating. |
| `priceRange` | string | Price filter: free, under5, under10, under15, under25, discounted, or empty for all. |
| `system` | string | Platform filter: windows, osx, linux, or empty for all. |
| `category` | string | Genre filter (e.g., "role-playing", "action", "strategy"). Leave empty for all. |
| `language` | string | Supported language filter (e.g., "en", "de", "fr", "pl", "tr"). Leave empty for all. |
| `maxConcurrency` | integer | Maximum number of parallel requests. |
| `proxyConfig` | object | Proxy settings. Datacenter proxies work fine for GOG. **Required.** |

### 🚀 Example input

```json
{
  "queries": ["rpg", "witcher", "indie"],
  "maxPages": 10,
  "maxProductsTotal": 0,
  "sortBy": "bestselling",
  "priceRange": "discounted",
  "system": "windows",
  "category": "role-playing",
  "language": "en",
  "maxConcurrency": 3,
  "proxyConfig": { "useApifyProxy": true }
}
````

### 📦 Output

Each game is saved as a structured item in the dataset. Export the full dataset to JSON, CSV, Excel or XML, or pull it via the Apify API.

| Field | Description |
|-------|-------------|
| `productId` | GOG product ID |
| `slug` | URL-friendly identifier |
| `title` | Game title |
| `finalPrice` | Current price after discount |
| `originalPrice` | Original base price |
| `discountPercentage` | Discount percentage (0–100) |
| `currency` | Currency symbol |
| `isFree` | Whether the game is free |
| `isDiscounted` | Whether the game is currently on sale |
| `rating` | User rating (0–5 scale) |
| `reviewsCount` | Number of user reviews |
| `developer` | Game developer |
| `publisher` | Game publisher |
| `category` | Primary genre |
| `platformWindows` | Windows compatibility |
| `platformMac` | macOS compatibility |
| `platformLinux` | Linux compatibility |
| `releaseDate` | Release date |
| `isInDevelopment` | Early access / in development |
| `isComingSoon` | Upcoming release |
| `productUrl` | Full GOG product page URL |
| `thumbnailUrl` | Product thumbnail image |
| `searchQuery` | Query used to find this product |
| `pageNumber` | Page number from results |
| `scrapedAt` | Scraping timestamp |

### 💡 Use cases

- **Price tracking & deal hunting** — monitor GOG discounts and build price-drop alerts for specific games.
- **Game catalog & aggregator builders** — feed structured GOG data into your own game discovery or comparison site.
- **Market research** — analyze pricing, genres, ratings and release trends across the DRM-free PC gaming market.
- **Competitive analysis** — game studios and publishers can benchmark prices, discounts and reviews against competitors.
- **Linux gaming research** — filter for Linux-compatible titles to map native game availability.
- **Data journalism & analytics** — study discount cycles, top-rated genres and catalog growth over time.

### ❓ Frequently Asked Questions

**Is it legal to scrape GOG.com?**
The Actor only collects publicly available product listing data — prices, ratings, descriptions and metadata that GOG publishes on its store. You are responsible for using the data in compliance with GOG's terms and applicable laws. Scraping public catalog data for research and analytics is common practice.

**Do I need an API key or a login?**
No. There is no GOG account, login or API key required. You only need an Apify account to run the Actor.

**Does it need residential proxies?**
No. Datacenter proxies work perfectly — GOG.com has no aggressive anti-bot protection. The Actor still adds small delays to stay respectful of the site.

**How many games can I scrape?**
GOG's catalog has 12,000+ DRM-free games. To get the full catalog, leave `queries` empty and set `maxPages` high (around 250). Each page returns 48 products.

**Can I filter by price, platform or genre?**
Yes. You can filter by price range, operating system (Windows/macOS/Linux), genre and supported language, and sort by trending, best selling, price, title, release date or rating.

**How much does it cost?**
The Actor is HTTP-only and runs on cheap datacenter proxies. As a rough guide it costs about $2.00 per 1,000 results on a pay-per-result basis.

**What output formats are supported?**
Results are stored in a structured Apify dataset and can be exported as JSON, CSV, Excel, or XML, or accessed programmatically through the Apify API.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to track GOG prices and discounts daily or weekly. Output exports to JSON, CSV, or Excel, and integrates with Google Sheets, webhooks and your own database through the Apify API.

# Actor input Schema

## `queries` (type: `array`):

Keywords to filter results (e.g., 'rpg', 'witcher', 'indie'). Leave EMPTY to browse the entire GOG catalog (12,000+ games).

## `maxPages` (type: `integer`):

Maximum number of pages to scrape. Each page returns 48 products. Set to 250 for full catalog.

## `maxProductsTotal` (type: `integer`):

Global limit on total products to scrape. Set 0 for unlimited.

## `sortBy` (type: `string`):

Sort order for results

## `priceRange` (type: `string`):

Filter by price range

## `system` (type: `string`):

Filter by operating system

## `category` (type: `string`):

Filter by game genre (e.g., 'role-playing', 'action', 'strategy', 'adventure', 'simulation', 'shooter', 'puzzle', 'racing', 'sports'). Leave empty for all.

## `language` (type: `string`):

Filter by supported language (e.g., 'en', 'de', 'fr', 'es', 'pt', 'ru', 'zh', 'ja', 'ko', 'pl', 'tr'). Leave empty for all.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests

## `proxyConfig` (type: `object`):

Proxy settings. Datacenter proxies work fine for GOG.

## Actor input object example

```json
{
  "queries": [],
  "maxPages": 10,
  "maxProductsTotal": 0,
  "sortBy": "trending",
  "priceRange": "",
  "system": "",
  "category": "",
  "language": "",
  "maxConcurrency": 3,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `productId` (type: `string`):

GOG product ID

## `slug` (type: `string`):

URL slug

## `title` (type: `string`):

Game title

## `finalPrice` (type: `string`):

Current/final price

## `originalPrice` (type: `string`):

Original base price

## `discountPercentage` (type: `string`):

Discount percentage

## `currency` (type: `string`):

Currency symbol

## `isFree` (type: `string`):

Whether the game is free

## `isDiscounted` (type: `string`):

Whether the game is on sale

## `rating` (type: `string`):

Rating score (0-5)

## `reviewsCount` (type: `string`):

Number of reviews

## `developer` (type: `string`):

Game developer

## `publisher` (type: `string`):

Game publisher

## `category` (type: `string`):

Primary genre/category

## `platformWindows` (type: `string`):

Windows support

## `platformMac` (type: `string`):

macOS support

## `platformLinux` (type: `string`):

Linux support

## `releaseDate` (type: `string`):

Release date

## `isInDevelopment` (type: `string`):

In early access

## `isComingSoon` (type: `string`):

Not yet released

## `productUrl` (type: `string`):

Full GOG product URL

## `thumbnailUrl` (type: `string`):

Product thumbnail

## `searchQuery` (type: `string`):

Search query used

## `pageNumber` (type: `string`):

Page number

## `scrapedAt` (type: `string`):

Scraping timestamp

# 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 = {
    "queries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/gateio-market-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 = { "queries": [] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/gateio-market-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 '{
  "queries": []
}' |
apify call logiover/gateio-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gate.io Market Scraper",
        "description": "Scrape live market data for all 2,200+ Gate.io spot trading pairs in one run — last price, 24h change, high/low, base and quote volume and bid/ask. Filter by quote currency. Schedule it for a continuously fresh price feed.",
        "version": "0.0",
        "x-build-id": "442E2mhzCVoYr9btn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~gateio-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-gateio-market-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/logiover~gateio-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-gateio-market-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/logiover~gateio-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-gateio-market-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": [
                    "proxyConfig"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords to filter results (e.g., 'rpg', 'witcher', 'indie'). Leave EMPTY to browse the entire GOG catalog (12,000+ games).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Max Pages Per Query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape. Each page returns 48 products. Set to 250 for full catalog.",
                        "default": 10
                    },
                    "maxProductsTotal": {
                        "title": "Max Products Total",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Global limit on total products to scrape. Set 0 for unlimited.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "trending",
                            "bestselling",
                            "price_asc",
                            "price_desc",
                            "title",
                            "release_date",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Sort order for results",
                        "default": "trending"
                    },
                    "priceRange": {
                        "title": "Price Range",
                        "enum": [
                            "",
                            "free",
                            "under5",
                            "under10",
                            "under15",
                            "under25",
                            "discounted"
                        ],
                        "type": "string",
                        "description": "Filter by price range",
                        "default": ""
                    },
                    "system": {
                        "title": "Platform",
                        "enum": [
                            "",
                            "windows",
                            "osx",
                            "linux"
                        ],
                        "type": "string",
                        "description": "Filter by operating system",
                        "default": ""
                    },
                    "category": {
                        "title": "Genre",
                        "type": "string",
                        "description": "Filter by game genre (e.g., 'role-playing', 'action', 'strategy', 'adventure', 'simulation', 'shooter', 'puzzle', 'racing', 'sports'). Leave empty for all.",
                        "default": ""
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Filter by supported language (e.g., 'en', 'de', 'fr', 'es', 'pt', 'ru', 'zh', 'ja', 'ko', 'pl', 'tr'). Leave empty for all.",
                        "default": ""
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of parallel requests",
                        "default": 3
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies work fine for GOG.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```