# itch.io Game Scraper (`parseforge/itch-io-scraper`) Actor

Scrape indie game listings from itch.io including title, developer, price, rating, platforms, genre, and more.

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

## Pricing

from $29.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎮 itch.io Game Scraper

> 🚀 **Export indie game listings from itch.io in seconds.** No login. No API key. Just clean, structured data.

> 🕒 **Last updated:** 2026-05-21 · **📊 13 fields** per record · **108 games/page** · **Global indie game catalog**

Itch.io is the world's largest open marketplace for independent game creators, hosting over 1 million games. This actor scrapes game listings from itch.io browse pages - capturing titles, developers, prices, ratings, platforms, genres, and descriptions in real time. Data is pulled directly from the public HTML - no account required.

The dataset is sourced from itch.io's own browse and discovery pages, covering every game visible to a non-logged-in visitor. Filter by sort order and genre to zero in on exactly the segment you need.

### Target Audience / Use Cases

| Who | How they use it |
|---|---|
| Game market researchers | Track pricing trends, genre popularity, and developer activity |
| Indie game journalists | Find rising games and developer stories |
| Game recommendation engines | Build curated lists of top-rated or trending indie titles |
| Competitive analysts | Monitor top sellers and popular genres |
| Data scientists | Build datasets for game recommendation or NLP models |

### 📋 What the itch.io Scraper does

- Browses itch.io game listings by sort order (top-rated, new-and-popular, top-sellers, newest)
- Filters by genre (platformer, rpg, action, visual-novel, etc.)
- Extracts cover image, title, developer, price, currency, rating, rating count, platforms, genre, and description
- Paginates automatically until your `maxItems` limit is reached
- Handles free and paid games correctly

> 💡 **Why it matters:** itch.io hosts thousands of under-the-radar indie games that never appear on Steam. It is the pulse of the indie game ecosystem - scraping it gives you early signals on genres, pricing, and talent before they go mainstream.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `maxItems` | integer | No | Max number of games to return. Free: limited to 10. Paid: up to 1,000,000. |
| `sortBy` | select | Yes | Sort order: `top-rated`, `new-and-popular`, `top-sellers`, `newest`. Default: `top-rated`. |
| `genre` | string | No | Genre filter (e.g. `platformer`, `rpg`, `action`, `visual-novel`). Leave empty for all genres. |

**Example - Top 50 RPGs:**
```json
{
    "maxItems": 50,
    "sortBy": "top-rated",
    "genre": "rpg"
}
````

**Example - New and popular games (all genres):**

```json
{
    "maxItems": 100,
    "sortBy": "new-and-popular"
}
```

> ⚠️ **Good to Know:** Free plan users are limited to 10 items per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock full access up to 1,000,000 items.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Cover image URL |
| 🎮 `title` | string | Game title |
| 👤 `developer` | string | Developer or studio name |
| 💰 `price` | string | Price (numeric string) or null if free |
| 💱 `currency` | string | Currency symbol (e.g. `$`) |
| ⭐ `rating` | string | Average rating out of 5 |
| 🔢 `ratingCount` | string | Total number of ratings |
| 🖥️ `platform` | string | Comma-separated platforms (Windows, macOS, Linux, Android) |
| 🏷️ `genre` | string | Primary genre tag |
| 📝 `description` | string | Short description |
| 🔗 `url` | string | Link to the game page on itch.io |
| 🕒 `scrapedAt` | string | ISO timestamp of when the record was scraped |
| ❌ `error` | string | Error message if scraping failed for this record |

**Sample record:**

```json
{
    "imageUrl": "https://img.itch.zone/aW1nLzcwMTIxNDMucG5n/315x250%23c/BalGQb.png",
    "title": "Our Life: Beginnings & Always",
    "developer": "GBPatch",
    "price": null,
    "currency": null,
    "rating": "4.94",
    "ratingCount": "7304",
    "platform": "Windows, Linux, macOS, Android",
    "genre": "Visual Novel",
    "description": "Grow from childhood to adulthood with the lonely boy next door in this near-fully customizable visual novel.",
    "url": "https://gbpatch.itch.io/our-life",
    "scrapedAt": "2026-05-21T23:40:12.431Z"
}
```

**Sample paid game record:**

```json
{
    "imageUrl": "https://img.itch.zone/aW1nLzIxNjc2MzA3LnBuZw==/315x250%23c/3FvfSq.png",
    "title": "Lancer Tactics",
    "developer": "Massif Press",
    "price": "20",
    "currency": "$",
    "rating": null,
    "ratingCount": null,
    "platform": "Windows",
    "genre": "Strategy",
    "description": "A tactical RPG set in the Lancer universe.",
    "url": "https://massif-press.itch.io/lancer-tactics",
    "scrapedAt": "2026-05-21T23:40:12.436Z"
}
```

### ✨ Why choose this Actor

- 🚀 **Fast** - no browser needed, pure HTTP with got-scraping for speed
- 🔒 **Reliable** - Chrome-like TLS fingerprint bypasses bot detection
- 🌐 **No auth required** - public itch.io data, no login or API key needed
- 🎯 **Flexible** - filter by sort order and genre
- 💸 **Fair pricing** - free preview, pay only for what you need
- 🛡️ **Real-time** - all data scraped live, no cached responses

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | itch.io OAuth API |
|---|---|---|---|
| No auth required | ✅ | ✅ | ❌ requires OAuth |
| Pagination | ✅ automatic | ❌ manual | ✅ |
| Genre filter | ✅ | ❌ manual | ✅ |
| Rating + platforms | ✅ | ❌ complex parsing | ✅ |
| Cloud scalable | ✅ | ❌ | ❌ |
| Structured output | ✅ JSON/CSV/XLSX | ❌ raw HTML | partial |

### 🚀 How to use

1. [Create a free Apify account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the itch.io Game Scraper in the Apify Store
3. Set `sortBy`, optional `genre`, and `maxItems`
4. Click **Start** and wait for results
5. Download your dataset as JSON, CSV, or Excel

### 💼 Business use cases

#### Game Market Research

Track pricing strategies across genres. See how free vs. paid games compare in ratings on itch.io. Identify which genres are most crowded or underserved.

#### Indie Game Discovery Platforms

Build a curated discovery engine on top of itch.io's catalog. Aggregate top-rated games by genre to power recommendation features or newsletters.

#### Competitive Intelligence

Monitor top-selling games, track new releases, and identify trending developers before they break into mainstream coverage.

#### Academic and Data Science Projects

Build training datasets for game recommendation systems, NLP models trained on game descriptions, or sentiment analysis of player-facing copy.

### 🔌 Automating itch.io Game Scraper

Integrate this actor into your workflows using:

- **Make (Integromat)** - Trigger runs on a schedule and send results to Google Sheets or Airtable
- **Zapier** - Connect to Slack notifications when new top-rated games are found
- **Apify API** - Call programmatically from your own backend or data pipeline
- **Webhooks** - Post dataset results to any HTTP endpoint when the run completes

### 🌟 Beyond business use cases

#### Research

Track the indie game ecosystem over time. Analyze how genre trends shift year over year on itch.io, or study how free vs. paid pricing correlates with ratings.

#### Creative projects

Build a personal game backlog tracker, a browser extension for itch.io recommendations, or a weekly newsletter of the best new indie releases.

#### Non-profit and education

Educators can use this data to teach game design students about market positioning, pricing psychology, and genre saturation.

#### Experimentation

Use the dataset to prototype a game recommendation engine, test genre classification models, or experiment with NLP on game descriptions.

### 🤖 Ask an AI assistant about this scraper

Not sure which fields you need? Ask an AI assistant: "What fields does the itch.io Game Scraper return?" or "How do I filter itch.io games by genre using the Apify actor?" - this README has all the context needed.

### ❓ Frequently Asked Questions

**🔑 Do I need an itch.io account?**
No. All data is scraped from public browse pages. No login or OAuth is required.

**📦 How many games can I scrape?**
Free users: up to 10 items per run. Paid users: up to 1,000,000 per run. Each itch.io page has up to 108 games.

**🏷️ What genre values can I use?**
Any genre string that itch.io accepts as a query param. Common values: `platformer`, `rpg`, `action`, `adventure`, `visual-novel`, `puzzle`, `simulation`, `strategy`, `shooter`, `sports`. Leave empty for all genres.

**💰 Does it handle free games?**
Yes. Free games return `price: null, currency: null`. Paid games return the numeric price as a string and the currency symbol.

**⭐ Why do some games have null ratings?**
Itch.io only shows ratings when a game has received enough ratings to display. Top-sellers may show fewer rated games than top-rated.

**🖥️ What platforms does it detect?**
Windows, macOS, Linux, and Android - corresponding to the platform icons shown on itch.io game cards.

**🔄 How often does itch.io update its listings?**
Itch.io updates continuously. Run this actor on a schedule to capture the latest rankings.

**📄 Can I paginate through all games?**
Yes. The actor automatically paginates through pages until your `maxItems` limit is reached.

**🚀 How fast is it?**
A run of 100 items typically completes in under 10 seconds. 1,000 items takes around 60-90 seconds.

**🛡️ Is it blocked by itch.io?**
The actor uses got-scraping with Chrome-like headers and TLS fingerprints. Public browse pages are freely accessible and have not shown blocking behavior.

### 🔌 Integrate with any app

Export results to: **Google Sheets**, **Excel**, **Airtable**, **Notion**, **PostgreSQL**, **MySQL**, **BigQuery**, **MongoDB**, **Slack**, **Email**, **Webhooks**, **REST API**, **GraphQL**, **AWS S3**, **Google Cloud Storage**, **Dropbox**, **Zapier**, **Make**, **n8n**, **Power Automate**

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Steam Game Scraper](https://apify.com/parseforge) | Scrape Steam game listings, reviews, and prices |
| [IndieDB Scraper](https://apify.com/parseforge) | Scrape IndieDB game profiles and news |
| [Kickstarter Scraper](https://apify.com/parseforge/kickstarter-scraper) | Scrape crowdfunded game campaigns |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more high-quality open web datasets - games, jobs, real estate, finance, and more.

***

**Disclaimer:** This actor is not affiliated with, endorsed by, or connected to itch.io or its parent company. It accesses only publicly available information. Use responsibly and in accordance with itch.io's Terms of Service.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

How to sort the game listings.

## `genre` (type: `string`):

Optional genre to filter by (e.g. platformer, rpg, action). Leave empty for all genres.

## Actor input object example

```json
{
  "maxItems": 10,
  "sortBy": "top-rated"
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10,
    "sortBy": "top-rated"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/itch-io-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 = {
    "maxItems": 10,
    "sortBy": "top-rated",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/itch-io-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 '{
  "maxItems": 10,
  "sortBy": "top-rated"
}' |
apify call parseforge/itch-io-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "itch.io Game Scraper",
        "description": "Scrape indie game listings from itch.io including title, developer, price, rating, platforms, genre, and more.",
        "version": "0.1",
        "x-build-id": "oKqsg8YKfYa24naOX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~itch-io-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-itch-io-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/parseforge~itch-io-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-itch-io-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/parseforge~itch-io-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-itch-io-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": [
                    "sortBy"
                ],
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "top-rated",
                            "new-and-popular",
                            "top-sellers",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to sort the game listings."
                    },
                    "genre": {
                        "title": "Genre Filter",
                        "type": "string",
                        "description": "Optional genre to filter by (e.g. platformer, rpg, action). Leave empty for all genres."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```