# L2BEAT Rollup TVL Scraper (`parseforge/l2beat-rollup-tvl-scraper`) Actor

Track Ethereum L2 and rollup metrics from L2BEAT across 117 plus projects. Returns project name, slug, category, maturity stage, total value secured with native and bridged splits, 7 day change, and a structured risk summary. Great for TVL tracking and rollup comparison.

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

## Pricing

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

## 🟣 L2BEAT Rollup TVL Scraper

> 🚀 **Pull live Ethereum L2 metrics in one run.** Returns 117+ rollups and scaling projects with TVS, stage, category, and a structured risk summary per project.

> 🕒 **Last updated:** 2026-06-05 · **📊 19 fields** per record · 117+ projects covered · Ethereum L2/L3 scaling ecosystem

L2BEAT is the leading independent research hub tracking Ethereum scaling. This Actor reads the L2BEAT public scaling summary and turns every rollup, validium, and optimium into a clean, structured record you can drop straight into a model, a dashboard, or a spreadsheet.

Coverage spans Optimistic Rollups, ZK Rollups, Validiums, Optimiums, and other scaling designs. For each project you get its maturity stage, total value secured (TVS) with a native, canonical, and external breakdown, a 7 day TVS change, and the five core L2BEAT risk dimensions with their values and sentiment.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Crypto analysts, DeFi researchers, quant teams, builders, and journalists | TVL/TVS tracking, rollup comparison, risk monitoring, ecosystem dashboards |

### 📋 What the L2BEAT Rollup TVL Scraper does

It calls the L2BEAT scaling summary, maps every project into one record, and returns identification, classification, value, and risk fields. You can narrow results by project type, category, and maturity stage, and optionally include archived projects.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `maxItems` | integer | Cap on number of projects returned. Free plan is limited to 10. |
| `type` | select | Filter by layer type. `layer2`, `layer3`, or all. |
| `category` | select | Filter by category. Optimistic Rollup, ZK Rollup, Validium, Optimium, Other. |
| `stage` | select | Filter by L2BEAT maturity stage. Stage 0, Stage 1, Stage 2, Not applicable. |
| `includeArchived` | boolean | Include projects L2BEAT has archived. Off by default. |

Example 1 — top 25 projects across the whole ecosystem:

```json
{
    "maxItems": 25
}
````

Example 2 — only Stage 1 Optimistic Rollups:

```json
{
    "maxItems": 50,
    "type": "layer2",
    "category": "Optimistic Rollup",
    "stage": "Stage 1"
}
```

> ⚠️ **Good to Know:** TVS values are reported in USD and reflect L2BEAT's latest snapshot. A small number of projects have no TVS breakdown yet, in which case those numeric fields are null. The `providers` list is empty for projects L2BEAT has not mapped to a stack.

### 📊 Output

| Field | Description |
|---|---|
| 📌 `name` | Project display name |
| 🔖 `slug` | L2BEAT project slug |
| 🆔 `id` | Project identifier |
| 🧱 `type` | Layer type (layer2 or layer3) |
| 🗂 `category` | Rollup category |
| 🏁 `stage` | L2BEAT maturity stage |
| ⛓ `hostChain` | Host chain (typically Ethereum) |
| 🗄 `isArchived` | Whether the project is archived |
| 🔍 `isUnderReview` | Whether the project is under review |
| 🎯 `purposes` | Project purposes |
| 🏗 `providers` | Stack/provider tags |
| 💰 `tvsTotal` | Total value secured in USD |
| 🪙 `tvsNative` | Native portion of TVS |
| 🔗 `tvsCanonical` | Canonically bridged portion of TVS |
| 🌐 `tvsExternal` | Externally bridged portion of TVS |
| 📈 `tvsChange7d` | 7 day TVS change as a ratio |
| 🛡 `riskSummary` | Array of risk dimensions with value and sentiment |
| 🔗 `l2beatUrl` | Link to the project page on L2BEAT |
| 🕒 `scrapedAt` | Timestamp of the run |

Real sample records from a live run:

```json
{
    "name": "Arbitrum One",
    "slug": "arbitrum",
    "id": "arbitrum",
    "type": "layer2",
    "category": "Optimistic Rollup",
    "stage": "Stage 1",
    "hostChain": "Ethereum",
    "isArchived": false,
    "isUnderReview": false,
    "purposes": ["Universal"],
    "providers": ["Arbitrum"],
    "tvsTotal": 17806262272,
    "tvsNative": 9165601520.576172,
    "tvsCanonical": 2551004595.15484,
    "tvsExternal": 6089664490.957825,
    "tvsChange7d": -0.1382014587942224,
    "riskSummary": [
        { "name": "Sequencer Failure", "value": "Self sequence", "sentiment": "good" },
        { "name": "State Validation", "value": "Fraud proofs (INT)", "sentiment": "good" },
        { "name": "Data Availability", "value": "Onchain", "sentiment": "good" },
        { "name": "Exit Window", "value": "None", "sentiment": "bad" },
        { "name": "Proposer Failure", "value": "Self propose", "sentiment": "good" }
    ],
    "l2beatUrl": "https://l2beat.com/scaling/projects/arbitrum",
    "scrapedAt": "2026-06-05T16:32:22.585Z",
    "error": null
}
```

```json
{
    "name": "Base Chain",
    "slug": "base",
    "type": "layer2",
    "category": "Optimistic Rollup",
    "stage": "Stage 1",
    "isUnderReview": true,
    "providers": ["OP Stack"],
    "tvsTotal": 10867476480,
    "tvsChange7d": -0.07423451500892642,
    "l2beatUrl": "https://l2beat.com/scaling/projects/base"
}
```

```json
{
    "name": "Polygon PoS",
    "slug": "polygon-pos",
    "type": "layer2",
    "category": "Other",
    "stage": "Not applicable",
    "providers": [],
    "tvsTotal": 4266212096,
    "tvsChange7d": -0.04787872963738371,
    "l2beatUrl": "https://l2beat.com/scaling/projects/polygon-pos"
}
```

### ✨ Why choose this Actor

- One record per project with consistent, typed fields.
- Full TVS breakdown plus 7 day momentum, not just a single number.
- Structured risk summary across the five L2BEAT risk dimensions.
- Filter by type, category, and stage without writing any code.
- Keyless public source, so runs are simple and stable.

### 📈 How it compares to alternatives

| Approach | Effort | Structured risk | Filters |
|---|---|---|---|
| Manual reading of the L2BEAT site | High | No | No |
| Generic page scraper | Medium | Often broken | No |
| L2BEAT Rollup TVL Scraper | Low | Yes | Yes |

### 🚀 How to use

1. Sign up or sign in to Apify using our [referral link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the L2BEAT Rollup TVL Scraper.
3. Set `maxItems` and any filters you want, or leave defaults.
4. Click Start and let the run finish.
5. Open the dataset to view, sort, and pull your records.

### 💼 Business use cases

**Research and analytics**

| Need | How this helps |
|---|---|
| Rank rollups by TVS | Sort on `tvsTotal` across the full set |
| Track momentum | Use `tvsChange7d` to spot inflows and outflows |

**Risk and compliance**

| Need | How this helps |
|---|---|
| Monitor maturity | Filter by `stage` to watch Stage 0 vs Stage 1 vs Stage 2 |
| Compare risk posture | Read `riskSummary` sentiment across projects |

**Product and BD**

| Need | How this helps |
|---|---|
| Map the ecosystem | Group by `category` and `providers` |
| Find host chains | Read `hostChain` to see what settles where |

**Content and media**

| Need | How this helps |
|---|---|
| Build charts | Feed TVS fields into a dashboard |
| Cite sources | Link readers to `l2beatUrl` |

### 🔌 Automating L2BEAT Rollup TVL Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub, and Google Drive through the Apify API and integrations. Schedule recurring runs, then route the dataset to a sheet, a database, or a notification channel.

### 🌟 Beyond business use cases

- **Research:** academic study of Ethereum scaling and bridge risk.
- **Personal:** track the rollups you hold or follow.
- **Non-profit:** transparency reporting on public chain infrastructure.
- **Experimentation:** prototype risk scoring or TVS forecasting models.

### 🤖 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 it to rank, summarize, or chart the rollups for you.

### ❓ Frequently Asked Questions

**What is TVS?** Total value secured, L2BEAT's measure of the value protected by a scaling project.

**How many projects are covered?** Over 117 at the time of writing, across all scaling categories.

**Is the source official?** Data comes from the public L2BEAT scaling summary.

**Do I need an API key?** No, the source is keyless.

**Can I filter results?** Yes, by type, category, and maturity stage.

**Why are some TVS fields null?** A few projects have no TVS breakdown yet on L2BEAT.

**Why is `providers` sometimes empty?** L2BEAT has not mapped every project to a stack.

**What does `tvsChange7d` mean?** The 7 day change in TVS expressed as a ratio.

**How often is data refreshed?** Each run pulls the latest L2BEAT snapshot.

**Does it include archived projects?** Only if you enable `includeArchived`.

**Can I get only Stage 1 ZK Rollups?** Yes, set `category` to ZK Rollup and `stage` to Stage 1.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and scheduler to wire results into your own stack or any of the supported integrations.

### 🔗 Recommended Actors

- [ParseForge collection](https://apify.com/parseforge) for more crypto and web data Actors.

> 💡 **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 L2BEAT. Only publicly available data collected.

# Actor input Schema

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

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

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

Filter projects by layer type. Leave empty to include every type.

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

Filter projects by rollup category. Leave empty to include every category.

## `stage` (type: `string`):

Filter projects by L2BEAT maturity stage. Leave empty to include every stage.

## `includeArchived` (type: `boolean`):

Include projects that L2BEAT has archived. Off by default.

## Actor input object example

```json
{
  "maxItems": 10,
  "type": "",
  "category": "",
  "stage": "",
  "includeArchived": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/l2beat-rollup-tvl-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/l2beat-rollup-tvl-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/l2beat-rollup-tvl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "L2BEAT Rollup TVL Scraper",
        "description": "Track Ethereum L2 and rollup metrics from L2BEAT across 117 plus projects. Returns project name, slug, category, maturity stage, total value secured with native and bridged splits, 7 day change, and a structured risk summary. Great for TVL tracking and rollup comparison.",
        "version": "0.1",
        "x-build-id": "s8XX0sgg0qxY76gzy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~l2beat-rollup-tvl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-l2beat-rollup-tvl-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~l2beat-rollup-tvl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-l2beat-rollup-tvl-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~l2beat-rollup-tvl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-l2beat-rollup-tvl-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": {
                    "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"
                    },
                    "type": {
                        "title": "Project Type",
                        "enum": [
                            "",
                            "layer2",
                            "layer3"
                        ],
                        "type": "string",
                        "description": "Filter projects by layer type. Leave empty to include every type.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "Optimistic Rollup",
                            "ZK Rollup",
                            "Validium",
                            "Optimium",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Filter projects by rollup category. Leave empty to include every category.",
                        "default": ""
                    },
                    "stage": {
                        "title": "Maturity Stage",
                        "enum": [
                            "",
                            "Stage 0",
                            "Stage 1",
                            "Stage 2",
                            "Not applicable"
                        ],
                        "type": "string",
                        "description": "Filter projects by L2BEAT maturity stage. Leave empty to include every stage.",
                        "default": ""
                    },
                    "includeArchived": {
                        "title": "Include Archived Projects",
                        "type": "boolean",
                        "description": "Include projects that L2BEAT has archived. Off by default.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```