# Miniature Market Scraper (`crawlerbros/miniature-market-scraper`) Actor

Scrape Miniature Market's tabletop-game catalog - search or browse by category, filter by price and stock, and get product name, price, brand, SKU, and image URLs.

- **URL**: https://apify.com/crawlerbros/miniature-market-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Miniature Market Scraper

Scrape **Miniature Market** — a major U.S. tabletop-game retailer with 30,000+ SKUs across board games, miniatures, trading card games, RPGs, and hobby accessories. Search by product/game name or browse any of 85 real store categories and sub-categories (by game system, publisher line, age range, or deals section), then filter by price range, stock status, and manufacturer. HTTP-only — no login, no cookies, no paid proxy required.

### What this actor does

- **Two modes:** `search` (free-text query) and `category` (browse the site's real navigation taxonomy)
- **85 categories** — top-level departments (Board Games, Miniatures Games, Trading Card Games, Role Playing Games, Collectible Miniatures, Accessories, Family Friendly Games, Deals) plus real sub-categories by game system (Warhammer, Magic: The Gathering, Pokémon, Dungeons & Dragons, Pathfinder, Battletech, and more), by age range, and by deal type (clearance, last chance, daily deal)
- **Filters:** price range (min/max), in-stock-only (excludes preorders), manufacturer/brand substring match, and 8 sort orders
- **Pricing detail:** current price, original list price, and computed discount percentage when the item is on sale
- **Empty fields are omitted** — every record only contains fields Miniature Market actually published for that product

### Output per product

- `title` — product name
- `productUrl` / `sourceUrl` — canonical product page URL
- `imageUrl` — product photo
- `price` — current selling price (USD)
- `listPrice` — original/retail price, only present when the item is discounted
- `discountPercent` — percentage off list price, only present when discounted
- `currency` — always `USD`
- `sku` — Miniature Market's product/order number
- `brand` — manufacturer/publisher (e.g. `Games Workshop`, `Wizards of the Coast`)
- `category` — the category the product was found under
- `availability` — `In Stock` or `Preorder`
- `inStock` — boolean form of `availability`
- `productId` — Miniature Market's internal product identifier
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` or `category` |
| `searchQuery` | string | `Catan` | Free-text query (mode=search) |
| `category` | string | – | One of 85 category/sub-category values (mode=category) |
| `sortBy` | string | `bestResult` | `bestResult` / `nameAsc` / `nameDesc` / `priceAsc` / `priceDesc` / `topseller` / `newItems` / `newlyListed` |
| `minPrice` | number | – | Drop products cheaper than this (USD) |
| `maxPrice` | number | – | Drop products more expensive than this (USD) |
| `inStockOnly` | boolean | `false` | Exclude preorder items |
| `manufacturerContains` | string | – | Case-insensitive substring match on brand/manufacturer |
| `maxItems` | int | `50` | Hard cap (1–5000) |

#### Example: search for a popular game

```json
{
  "mode": "search",
  "searchQuery": "Catan",
  "maxItems": 25
}
````

#### Example: browse Warhammer miniatures, in stock only, sorted by price

```json
{
  "mode": "category",
  "category": "miniaturesWarhammer",
  "inStockOnly": true,
  "sortBy": "priceAsc",
  "maxItems": 50
}
```

#### Example: browse clearance deals under $30

```json
{
  "mode": "category",
  "category": "dealsClearance",
  "maxPrice": 30,
  "maxItems": 100
}
```

#### Example: search filtered by manufacturer and price range

```json
{
  "mode": "search",
  "searchQuery": "starter deck",
  "manufacturerContains": "Wizards of the Coast",
  "minPrice": 10,
  "maxPrice": 50
}
```

### Use cases

- **Price monitoring** — track a game's current price and discount over time
- **Inventory research** — check stock/preorder status across a publisher's catalog
- **Market research** — compare hobby-retail pricing for a game system (Warhammer, Magic, Pokémon, D\&D)
- **Deal hunting** — bulk-export the clearance and last-chance sections
- **Catalog enrichment** — feed product images, SKUs, and brand data into an internal catalog

### FAQ

**What is the data source?**
Miniature Market's public storefront (miniaturemarket.com). No account, login, or API key is used.

**Is this affiliated with Miniature Market?**
No — this is an independent third-party actor that reads publicly available storefront pages.

**Why do some products have no `listPrice` or `discountPercent`?**
Those fields only appear when Miniature Market shows a separate "was" price — i.e. the item is currently marked down. Full-price items only have `price`.

**What does `availability: "Preorder"` mean?**
The product is a confirmed pre-order (not yet shipping). Set `inStockOnly: true` to exclude these.

**Are there rate limits?**
The actor makes plain page requests with polite delays between pages; no login or special access is required. Very large `maxItems` values on a broad, unfiltered browse may take longer since pagination is sequential.

**Why is `category` a fixed list instead of free text?**
Miniature Market's category URLs are stable, human-readable slugs, so every reliably working category and sub-category is enumerated directly — no risk of typos returning zero results.

**Can I filter by manufacturer directly as a dropdown?**
Miniature Market lists hundreds of manufacturers with no stable public ID scheme, so `manufacturerContains` is a substring filter applied to the brand name returned with each product instead of a fixed list.

### Data Source / Limitations

- Prices and stock are the retailer's live listing-page values, refreshed the moment a page is requested.
- `manufacturer`/brand filtering is a substring match on the brand name shown per product listing, not a curated dropdown of every publisher (the site does not expose a small, stable manufacturer list).
- Only products that appear in a search or category listing page are returned; the site does not publicly list fully sold-out (zero-stock, non-preorder) items in these views.

# Actor input Schema

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

What to fetch: free-text search, or browse a category page.

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

Free-text query, e.g. a game or product name (mode=search).

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

Browse a category or sub-category from the site's real navigation taxonomy (mode=category).

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

Result ordering, as offered by the site's own sort dropdown.

## `minPrice` (type: `number`):

Drop products cheaper than this.

## `maxPrice` (type: `number`):

Drop products more expensive than this.

## `inStockOnly` (type: `boolean`):

Exclude preorder items; keep only products immediately purchasable.

## `manufacturerContains` (type: `string`):

Case-insensitive substring match against the product's manufacturer/brand (e.g. `Games Workshop`, `Wizards of the Coast`).

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Catan",
  "sortBy": "bestResult",
  "inStockOnly": false,
  "maxItems": 50
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Miniature Market products.

# 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": "search",
    "searchQuery": "Catan",
    "sortBy": "bestResult",
    "inStockOnly": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/miniature-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 = {
    "mode": "search",
    "searchQuery": "Catan",
    "sortBy": "bestResult",
    "inStockOnly": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/miniature-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 '{
  "mode": "search",
  "searchQuery": "Catan",
  "sortBy": "bestResult",
  "inStockOnly": false,
  "maxItems": 50
}' |
apify call crawlerbros/miniature-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Miniature Market Scraper",
        "description": "Scrape Miniature Market's tabletop-game catalog - search or browse by category, filter by price and stock, and get product name, price, brand, SKU, and image URLs.",
        "version": "1.0",
        "x-build-id": "hjULWrJhYQr2cIl2T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~miniature-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-miniature-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/crawlerbros~miniature-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-miniature-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/crawlerbros~miniature-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-miniature-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "category"
                        ],
                        "type": "string",
                        "description": "What to fetch: free-text search, or browse a category page.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query, e.g. a game or product name (mode=search).",
                        "default": "Catan"
                    },
                    "category": {
                        "title": "Category (mode=category)",
                        "enum": [
                            "boardGames",
                            "miniaturesGames",
                            "tradingCardGames",
                            "rolePlayingGames",
                            "collectibleMiniatures",
                            "accessories",
                            "familyFriendlyGames",
                            "deals",
                            "boardGamesNewArrivals",
                            "boardGamesPreorders",
                            "boardGamesLastChance",
                            "boardGamesMiniatureGames",
                            "boardGamesDeckAndCardGame",
                            "boardGamesDiceGames",
                            "boardGamesCampaignAndLegacyGames",
                            "boardGamesSinglePlayerGames",
                            "boardGamesTwoPlayerGames",
                            "boardGamesCooperativeGames",
                            "boardGamesWargames",
                            "boardGamesOtherBoardGames",
                            "miniaturesNewArrivals",
                            "miniaturesPreorders",
                            "miniaturesLastChance",
                            "miniaturesWarhammer",
                            "miniaturesBattletech",
                            "miniaturesMalifaux",
                            "miniaturesStarWars",
                            "miniaturesInfinity",
                            "miniaturesHeroscape",
                            "miniaturesMarvel",
                            "miniaturesConquest",
                            "miniaturesWarmachine",
                            "miniaturesOther",
                            "tcgNewArrivals",
                            "tcgPreorders",
                            "tcgMagicSingles",
                            "tcgMagicTheGathering",
                            "tcgPokemon",
                            "tcgLorcana",
                            "tcgStarWarsUnlimited",
                            "tcgFleshAndBlood",
                            "tcgOnePiece",
                            "tcgGundamCardGame",
                            "tcgRiftbound",
                            "tcgOther",
                            "rpgNewArrivals",
                            "rpgPreorders",
                            "rpgLastChance",
                            "rpgDungeonsAndDragons",
                            "rpgPathfinder",
                            "rpgStarfinder",
                            "rpgStarWars",
                            "rpgWarhammerRPGs",
                            "rpgArkhamHorror",
                            "rpgWorldOfDarkness",
                            "rpgStarTrekAdventures",
                            "rpgOther",
                            "collectibleMinisNewArrivals",
                            "collectibleMinisPreorders",
                            "collectibleMinisLastChance",
                            "collectibleMinisDAndD",
                            "collectibleMinisPathfinderBattles",
                            "collectibleMinisStarfinderBattles",
                            "collectibleMinisGundam",
                            "collectibleMinisOther",
                            "accessoriesNewArrivals",
                            "accessoriesPreorders",
                            "accessoriesLastChance",
                            "accessoriesDice",
                            "accessoriesDiceStorage",
                            "accessoriesCardSleeves",
                            "accessoriesDeckBoxesAndStorage",
                            "accessoriesDiceTraysAndTowers",
                            "accessoriesTerrain",
                            "accessoriesPaintAndModelTools",
                            "accessoriesPlaymats",
                            "familyNewArrivals",
                            "familyPreorders",
                            "familyAges25",
                            "familyAges69",
                            "familyAges1012",
                            "familyPuzzles",
                            "dealsDailyDeal",
                            "dealsClearance",
                            "dealsLastChance"
                        ],
                        "type": "string",
                        "description": "Browse a category or sub-category from the site's real navigation taxonomy (mode=category)."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "bestResult",
                            "nameAsc",
                            "nameDesc",
                            "priceAsc",
                            "priceDesc",
                            "topseller",
                            "newItems",
                            "newlyListed"
                        ],
                        "type": "string",
                        "description": "Result ordering, as offered by the site's own sort dropdown.",
                        "default": "bestResult"
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Drop products cheaper than this."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Drop products more expensive than this."
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Exclude preorder items; keep only products immediately purchasable.",
                        "default": false
                    },
                    "manufacturerContains": {
                        "title": "Manufacturer / brand contains",
                        "type": "string",
                        "description": "Case-insensitive substring match against the product's manufacturer/brand (e.g. `Games Workshop`, `Wizards of the Coast`)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
