# Master of Malt Scraper (`crawlerbros/master-of-malt-scraper`) Actor

Scrape Master of Malt's drinks marketplace - search whisky, gin, rum, vodka, beer, wine, liqueurs, brandy, champagne and sake by name, browse by category, find top-rated products, and pull full product detail with customer reviews and ratings.

- **URL**: https://apify.com/crawlerbros/master-of-malt-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, 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

## Master of Malt Scraper

Scrape **Master of Malt** — one of the world's largest online drinks marketplaces, covering whisky, gin, rum, vodka, beer, wine, liqueurs, brandy, champagne, and sake. Search products by name, browse by category, find the top-rated bottles in any category, or pull full product detail with customer reviews and star ratings. No login, no API key, no residential proxy required.

### What this actor does

- **Four modes:** `search`, `browseCategory`, `topRated`, `byProductUrls`
- **Real category taxonomy:** whisky, gin, rum, vodka, beer, wine, liqueur, brandy, champagne, sake
- **Filters:** min rating, min number of ratings, price range (GBP), ABV range, country of origin, in-stock only
- **Sort:** relevance, price (asc/desc), rating (desc), ABV (desc)
- **Full customer reviews** — written reviews with author, date, and star rating on product-detail lookups
- **Empty fields are omitted**

### Output per product

- `productId` — Master of Malt internal product ID
- `name`, `shortName`
- `category` (e.g. `Whiskies`), `style` (e.g. `Single Malt`), `categoryTags[]`
- `distillery` / `bottler` — producer or brand
- `country`, `region` — e.g. `Scotland` / `Islay`
- `abv` — alcohol by volume (%)
- `ageYears`, `volumeCl`, `vintage`
- `priceGBP`, `originalPriceGBP`, `isOnSale`
- `inStock`, `isBestSeller`
- `avgRating` (0–5), `ratingCount`
- `imageUrl`
- `sourceUrl` — canonical product page URL
- `recordType: "product"`, `scrapedAt`

#### Additional fields (mode = `byProductUrls` only)

- `description` — full tasting-note / marketing description
- `brand`, `sku`
- `priceGBP`, `inStock` — primary listing's current price and stock status
- `awards[]` — competition medals/awards (e.g. "Double Gold — 2022 San Francisco World Spirits Competition"), when the product has any
- `reviews[]` — up to 25 written customer reviews, each with `author`, `date`, `rating`, `reviewText`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browseCategory` / `topRated` / `byProductUrls` |
| `searchQuery` | string | `laphroaig` | Free-text product/brand query (mode=search) |
| `category` | string | – | `whisky` / `gin` / `rum` / `vodka` / `beer` / `wine` / `liqueur` / `brandy` / `champagne` / `sake` — required for `browseCategory` and `topRated`, optional filter for `search` |
| `productUrls` | array | – | Product page URLs or paths (mode=byProductUrls) |
| `sortBy` | string | `relevance` | `relevance` / `priceAsc` / `priceDesc` / `ratingDesc` / `abvDesc` |
| `minRating` | number | – | Drop products below this average rating (0–5) |
| `minRatingCount` | int | – | Drop products with fewer ratings than this |
| `minPriceGBP` / `maxPriceGBP` | number | – | Price range in GBP |
| `minAbv` / `maxAbv` | number | – | ABV percentage range |
| `country` | string | – | Filter by country of origin (substring match) |
| `inStockOnly` | bool | `false` | Only emit in-stock products |
| `maxItems` | int | `20` | Hard cap on emitted records (1–500) |
| `proxyConfiguration` | object | AUTO | Apify proxy config (free AUTO/datacenter group is sufficient) |

#### Example: search by name

```json
{
  "mode": "search",
  "searchQuery": "hendricks gin",
  "maxItems": 30
}
````

#### Example: browse a category with filters

```json
{
  "mode": "browseCategory",
  "category": "whisky",
  "minAbv": 40,
  "maxPriceGBP": 100,
  "inStockOnly": true,
  "maxItems": 50
}
```

#### Example: top-rated rums

```json
{
  "mode": "topRated",
  "category": "rum",
  "minRatingCount": 10,
  "maxItems": 20
}
```

#### Example: full product detail with reviews

```json
{
  "mode": "byProductUrls",
  "productUrls": [
    "https://www.masterofmalt.com/whiskies/laphroaig/laphroaig-10-year-old-sherry-oak-whisky/"
  ]
}
```

### Use cases

- **Price monitoring** — track bottle prices and sale status across whisky, gin, rum and more
- **Market research** — analyze rating distribution and review sentiment by category or country
- **Recommendation engines** — feed real customer ratings into a drinks recommender
- **Retail intelligence** — spot best-sellers and top-rated products per category
- **Content & comparison sites** — build "best whisky under £50" style roundups from live data

### FAQ

**Is this affiliated with Master of Malt?**  No — this is an independent, third-party actor that reads publicly available product and review pages.

**Do I need an account, cookies, or API key?**  No. All modes work anonymously.

**Why do some products have no `avgRating`?**  Ratings are only included when the product has at least one customer review; new or unreviewed listings omit the field entirely rather than showing a `0`.

**What currency are prices in?**  GBP (British Pounds), Master of Malt's base currency.

**How does `topRated` differ from `browseCategory` sorted by rating?**  `topRated` first gathers a larger candidate pool within the category (filtering out very-low-review-count outliers by default), then ranks by rating — giving a more meaningful "best of" list than a single sorted page.

**Why is `category` required for `browseCategory` and `topRated` but optional for `search`?**  `search` is a free-text query across the whole catalog; `category` there just narrows the results. `browseCategory`/`topRated` need a category to know which slice of the catalog to browse.

**Can I look up a specific bottle directly?**  Yes — use `mode=byProductUrls` with the product's page URL to get full details and up to 25 written reviews.

**How fresh is the data?**  Real-time — every run reads the live site.

# Actor input Schema

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

What to fetch.

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

Free-text product/brand search (mode=search), e.g. `laphroaig`, `hendricks gin`, `brewdog`.

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

Drinks category. Required for mode=browseCategory and mode=topRated; optional extra filter for mode=search.

## `productUrls` (type: `array`):

Full Master of Malt product page URLs, or paths (e.g. `/whiskies/laphroaig/laphroaig-10-year-old-sherry-oak-whisky/`).

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

Result ordering for search/browseCategory (topRated always sorts by rating).

## `minRating` (type: `number`):

Drop products with an average customer rating below this value.

## `minRatingCount` (type: `integer`):

Drop products with fewer customer ratings than this (avoids single-review outliers).

## `minPriceGBP` (type: `number`):

Drop products priced below this (GBP).

## `maxPriceGBP` (type: `number`):

Drop products priced above this (GBP).

## `minAbv` (type: `number`):

Drop products with alcohol-by-volume below this percentage.

## `maxAbv` (type: `number`):

Drop products with alcohol-by-volume above this percentage.

## `country` (type: `string`):

Filter to products from a specific country (e.g. `Scotland`, `Japan`, `Ireland`). Case-insensitive substring match.

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

Only emit products currently in stock.

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

Hard cap on emitted records.

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

Apify proxy (free AUTO/datacenter group is sufficient).

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "laphroaig",
  "category": "",
  "productUrls": [],
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Master of Malt 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": "laphroaig",
    "productUrls": [],
    "sortBy": "relevance",
    "inStockOnly": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/master-of-malt-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": "laphroaig",
    "productUrls": [],
    "sortBy": "relevance",
    "inStockOnly": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/master-of-malt-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": "laphroaig",
  "productUrls": [],
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/master-of-malt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Master of Malt Scraper",
        "description": "Scrape Master of Malt's drinks marketplace - search whisky, gin, rum, vodka, beer, wine, liqueurs, brandy, champagne and sake by name, browse by category, find top-rated products, and pull full product detail with customer reviews and ratings.",
        "version": "1.0",
        "x-build-id": "P7lm6B6hRpOt1tiS7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~master-of-malt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-master-of-malt-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~master-of-malt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-master-of-malt-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~master-of-malt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-master-of-malt-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",
                            "browseCategory",
                            "topRated",
                            "byProductUrls"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text product/brand search (mode=search), e.g. `laphroaig`, `hendricks gin`, `brewdog`.",
                        "default": "laphroaig"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "whisky",
                            "gin",
                            "rum",
                            "vodka",
                            "beer",
                            "wine",
                            "liqueur",
                            "brandy",
                            "champagne",
                            "sake"
                        ],
                        "type": "string",
                        "description": "Drinks category. Required for mode=browseCategory and mode=topRated; optional extra filter for mode=search.",
                        "default": ""
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=byProductUrls)",
                        "type": "array",
                        "description": "Full Master of Malt product page URLs, or paths (e.g. `/whiskies/laphroaig/laphroaig-10-year-old-sherry-oak-whisky/`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "ratingDesc",
                            "abvDesc"
                        ],
                        "type": "string",
                        "description": "Result ordering for search/browseCategory (topRated always sorts by rating).",
                        "default": "relevance"
                    },
                    "minRating": {
                        "title": "Min average rating (0-5)",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop products with an average customer rating below this value."
                    },
                    "minRatingCount": {
                        "title": "Min number of ratings",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop products with fewer customer ratings than this (avoids single-review outliers)."
                    },
                    "minPriceGBP": {
                        "title": "Min price (GBP)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Drop products priced below this (GBP)."
                    },
                    "maxPriceGBP": {
                        "title": "Max price (GBP)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Drop products priced above this (GBP)."
                    },
                    "minAbv": {
                        "title": "Min ABV (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Drop products with alcohol-by-volume below this percentage."
                    },
                    "maxAbv": {
                        "title": "Max ABV (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Drop products with alcohol-by-volume above this percentage."
                    },
                    "country": {
                        "title": "Country of origin",
                        "type": "string",
                        "description": "Filter to products from a specific country (e.g. `Scotland`, `Japan`, `Ireland`). Case-insensitive substring match."
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only emit products currently in stock.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy (free AUTO/datacenter group is sufficient).",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
