# Rebrickable LEGO Set Scraper (`parseforge/rebrickable-lego-scraper`) Actor

Search the LEGO set catalog on Rebrickable by keyword, theme, or year. Each set returns its name, set number, release year, theme, part count, and an image. Useful for collectors tracking releases, resellers building inventories, and fans researching themes across decades.

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

## Pricing

from $9.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)

## 🧱 Rebrickable LEGO Set Scraper

> 🚀 **Search the entire LEGO set catalog in seconds.** One query for "millennium falcon" returns 33 sets, from the 7,541 piece UCS down to pocket builds.

> 🕒 **Last updated:** 2026-06-02 · **📊 12 fields** per set · keyword, theme, and year filters · official images

Pull the LEGO set catalog from Rebrickable, the community database of every released set. Search by keyword and refine by theme or release year, and for each set get its name, set number, year, theme, part count, image, and detail link.

**Coverage:** the full Rebrickable catalog of LEGO sets across 494 themes. Search any keyword and filter by theme ID or year range.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Collectors | Track new and retired sets |
| Resellers | Build and price inventories |
| AFOL community | Research themes and eras |
| Data hobbyists | Build LEGO datasets |

### 📋 What the Rebrickable LEGO Set Scraper does

- Searches the LEGO set catalog by keyword.
- Filters by theme ID and by release year range.
- Sorts by year, name, or part count.
- Returns 12 structured fields per set, with the official image.
- Resolves theme IDs to readable theme names.
- Exports to CSV, Excel, JSON, XML, or via API.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | Keywords to search LEGO sets. Leave empty to list by filters. |
| `themeId` | integer | Optional. Restrict to a Rebrickable theme ID. |
| `minYear` | integer | Optional. Only sets from this year onward. |
| `maxYear` | integer | Optional. Only sets up to this year. |
| `ordering` | string | Sort order (newest, name, most parts, and more). |
| `maxItems` | integer | Cap on sets returned. Free plan is limited to 10. |
| `apiKey` | string | Rebrickable API key. A shared key is provided by default. |

**Example 1: search by keyword**
```json
{
  "searchTerms": ["millennium falcon"],
  "ordering": "-num_parts",
  "maxItems": 50
}
````

**Example 2: a theme in a year range**

```json
{
  "searchTerms": [],
  "themeId": 171,
  "minYear": 2015,
  "maxYear": 2024,
  "ordering": "-year"
}
```

> ⚠️ **Good to Know:** Rebrickable requires a free API key. A shared key ships by default, but you can add your own. Rebrickable is an inventory database, so it has no pricing. Some catalog entries (stickers, books) have a part count of zero.

### 📊 Output

Each record contains the following fields:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Official set image |
| 🧱 `name` | Set name |
| 🔢 `setNum` | Set number |
| 🔗 `setUrl` | Rebrickable detail page |
| 📅 `year` | Release year |
| 🏷 `theme` | Theme name |
| 🆔 `themeId` | Theme ID |
| 🧩 `numParts` | Part count |
| 🕒 `lastModified` | Last catalog update |
| 🔎 `searchTerm` | Query that surfaced this set |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Error message, null on success |

**Real sample records:**

```json
{
  "imageUrl": "https://cdn.rebrickable.com/media/sets/75192-1/30881.jpg",
  "name": "Millennium Falcon",
  "setNum": "75192-1",
  "setUrl": "https://rebrickable.com/sets/75192-1/millennium-falcon/",
  "year": 2017,
  "theme": "Ultimate Collector Series",
  "themeId": 171,
  "numParts": 7541,
  "lastModified": "2021-11-27T08:23:26.191796Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://cdn.rebrickable.com/media/sets/10179-1/15011.jpg",
  "name": "Millennium Falcon",
  "setNum": "10179-1",
  "setUrl": "https://rebrickable.com/sets/10179-1/millennium-falcon/",
  "year": 2007,
  "theme": "Ultimate Collector Series",
  "themeId": 171,
  "numParts": 5198,
  "error": null
}
```

```json
{
  "imageUrl": "https://cdn.rebrickable.com/media/sets/75212-1/19741.jpg",
  "name": "Kessel Run Millennium Falcon",
  "setNum": "75212-1",
  "setUrl": "https://rebrickable.com/sets/75212-1/kessel-run-millennium-falcon/",
  "year": 2018,
  "theme": "Star Wars",
  "themeId": 158,
  "numParts": 1414,
  "error": null
}
```

### ✨ Why choose this Actor

- **Whole-catalog search.** Find any set across 494 themes by keyword.
- **Readable themes.** Theme IDs resolved to names for you.
- **Flexible filters.** Narrow by theme, year range, and sort order.
- **Official images.** Every set carries its catalog image.
- **Ready to export.** CSV, Excel, JSON, XML, or API, with a clean table view.

### 📈 How it compares to alternatives

| | Rebrickable LEGO Set Scraper | Manual browsing | Generic web scrapers |
|---|---|---|---|
| Whole-catalog keyword search | ✅ | ❌ | ⚠️ Needs setup |
| Theme name resolution | ✅ | ⚠️ | ❌ |
| Year and theme filters | ✅ | ⚠️ | ❌ |
| Official images | ✅ | ✅ | ⚠️ |
| Export to CSV/Excel/JSON/XML | ✅ | ❌ | ⚠️ |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Rebrickable LEGO Set Scraper.
3. Enter `searchTerms`, optionally set a `themeId` or year range, and set `maxItems`.
4. Click **Start** and watch the dataset fill in real time.
5. Export your results as CSV, Excel, JSON, or XML, or pull them via API.

### 💼 Business use cases

**🛒 Reselling**
| Goal | How |
|---|---|
| Build inventory lists | Search a theme and capture set numbers |
| Spot big sets | Sort by part count |

**📦 Collection management**
| Goal | How |
|---|---|
| Track a theme | Filter by theme ID |
| Find new releases | Sort by newest first |

**📊 Market research**
| Goal | How |
|---|---|
| Study eras | Filter by year range |
| Map themes | Aggregate sets by theme |

**🧮 Dataset building**
| Goal | How |
|---|---|
| Build catalogs | Export names, numbers, and images |
| Analyze trends | Pair year with part count |

### 🔌 Automating Rebrickable LEGO Set Scraper

Connect this Actor to your stack with Apify integrations: **Make**, **Zapier**, **Slack**, **Airbyte**, **GitHub**, and **Google Drive**. Schedule runs and push fresh catalog data into spreadsheets, databases, or alerts.

### 🌟 Beyond business use cases

- **Research:** study how LEGO themes and set sizes evolved.
- **Personal:** plan your next build or wishlist.
- **Non-profit:** catalog donated sets for community programs.
- **Experimentation:** build LEGO analytics projects.

### 🤖 Ask an AI assistant

Paste your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask for the biggest sets, releases by year, or theme breakdowns.

### ❓ Frequently Asked Questions

**1. Do I need an API key?**
Rebrickable requires a free key. A shared key ships by default, and you can add your own.

**2. How do I search a theme?**
Use the keyword search, or set `themeId` to restrict results to one theme.

**3. Does it include prices?**
No. Rebrickable is an inventory database and does not hold pricing.

**4. Why do some sets show zero parts?**
Catalog entries like stickers and books have no brick count.

**5. Can I filter by year?**
Yes. Set `minYear` and `maxYear`.

**6. Are theme names included?**
Yes. Theme IDs are resolved to readable names.

**7. What export formats are supported?**
CSV, Excel, JSON, XML, and API.

**8. How do I find the biggest sets?**
Sort by most parts using the ordering option.

**9. Can I run it on a schedule?**
Yes, with Apify Schedules and integrations.

**10. Is there a free option?**
Yes. Free runs are limited to 10 items as a preview. Paid plans unlock up to 1,000,000.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and 5,000-plus integrations to push Rebrickable data into Make, Zapier, Google Sheets, Airtable, databases, and more.

### 🔗 Recommended Actors

- [Pokemon Catalog Scraper](https://apify.com/parseforge/pokemon-catalog-scraper)
- [TCGplayer Scraper](https://apify.com/parseforge/tcgplayer-scraper)
- [BoardGameGeek Scraper](https://apify.com/parseforge/boardgamegeek-scraper)
- [eBay Scraper](https://apify.com/parseforge/ebay-scraper)
- [BrickLink alternatives via Reverb](https://apify.com/parseforge/reverb-com-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Rebrickable or the LEGO Group. LEGO is a trademark of the LEGO Group. Data is provided by the Rebrickable community platform.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search LEGO sets (e.g. "star wars", "castle"). One result set per term. Leave empty to list sets by the chosen filters and order.

## `themeId` (type: `integer`):

Optional. Restrict to a Rebrickable theme ID (e.g. 158 = Star Wars, 1 = Technic).

## `minYear` (type: `integer`):

Optional. Only sets released in or after this year.

## `maxYear` (type: `integer`):

Optional. Only sets released in or before this year.

## `ordering` (type: `string`):

Sort order for results.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

## `apiKey` (type: `string`):

Rebrickable API key. A shared key is provided by default. Get your own free key at rebrickable.com account settings.

## Actor input object example

```json
{
  "searchTerms": [
    "star wars"
  ],
  "ordering": "-year",
  "maxItems": 10,
  "apiKey": "5c66b3e63d28c87237a0f02fc4a2812e"
}
```

# 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 = {
    "searchTerms": [
        "star wars"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/rebrickable-lego-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 = {
    "searchTerms": ["star wars"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/rebrickable-lego-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 '{
  "searchTerms": [
    "star wars"
  ],
  "maxItems": 10
}' |
apify call parseforge/rebrickable-lego-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rebrickable LEGO Set Scraper",
        "description": "Search the LEGO set catalog on Rebrickable by keyword, theme, or year. Each set returns its name, set number, release year, theme, part count, and an image. Useful for collectors tracking releases, resellers building inventories, and fans researching themes across decades.",
        "version": "0.1",
        "x-build-id": "NJwWfLUJ9hwqyoLRB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~rebrickable-lego-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-rebrickable-lego-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~rebrickable-lego-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-rebrickable-lego-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~rebrickable-lego-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-rebrickable-lego-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search LEGO sets (e.g. \"star wars\", \"castle\"). One result set per term. Leave empty to list sets by the chosen filters and order.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "themeId": {
                        "title": "Theme ID",
                        "type": "integer",
                        "description": "Optional. Restrict to a Rebrickable theme ID (e.g. 158 = Star Wars, 1 = Technic)."
                    },
                    "minYear": {
                        "title": "Min year",
                        "type": "integer",
                        "description": "Optional. Only sets released in or after this year."
                    },
                    "maxYear": {
                        "title": "Max year",
                        "type": "integer",
                        "description": "Optional. Only sets released in or before this year."
                    },
                    "ordering": {
                        "title": "Order by",
                        "enum": [
                            "-year",
                            "year",
                            "name",
                            "-num_parts",
                            "num_parts",
                            "-last_modified_dt"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": "-year"
                    },
                    "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."
                    },
                    "apiKey": {
                        "title": "Rebrickable API key",
                        "type": "string",
                        "description": "Rebrickable API key. A shared key is provided by default. Get your own free key at rebrickable.com account settings.",
                        "default": "5c66b3e63d28c87237a0f02fc4a2812e"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```