# Arkham Wallet Data (`maximedupre/arkham-intelligence-wallet-data-scraper`) Actor

Scrape Arkham Intelligence wallet data from addresses or Arkham wallet URLs. Export entity labels, tags, balances, history, loans, portfolio snapshots, volume, and P\&L data in normalized rows.

- **URL**: https://apify.com/maximedupre/arkham-intelligence-wallet-data-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Other
- **Stats:** 4 total users, 1 monthly users, 99.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 wallet data 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

### 🧭 Arkham Intelligence wallet data scraper

Arkham Wallet Data scrapes public wallet analytics from [Arkham Intelligence](https://intel.arkm.com/). Paste wallet addresses or Arkham wallet URLs, choose one data type, and export normalized rows with entity labels, tags, balances, history, loans, portfolio snapshots, volume, or P&L data.

Use this Arkham Intelligence wallet data scraper when you need repeatable wallet research for on-chain investigations, portfolio review, compliance triage, crypto market research, lead enrichment, or internal dashboards. Instead of opening Arkham wallet pages by hand, you can run the Actor in Apify Console, call it through the Apify API, schedule repeat runs, export CSV/JSON/Excel files, or connect finished datasets to webhooks and integrations.

For a quick first run, keep the prefilled Vitalik wallet, leave **Data to collect** set to `Intelligence`, and start the Actor. The output gives you a small sample with wallet, chain, Arkham entity, label, contract flags, source URL, scrape time, and the raw Arkham payload.

### ✅ What this Actor does

- Accepts wallet addresses and Arkham wallet URLs that contain a wallet address.
- Collects one Arkham data type per run: intelligence, volume, history, loans, balances, portfolio, or flow.
- Supports optional chain filtering across Arkham-supported chains such as Ethereum, Base, Arbitrum One, Optimism, Avalanche, BNB Chain, Polygon, Flare, Bitcoin, Solana, Tron, Dogecoin, TON, Sonic, Mantle, Linea, Blast, and Manta.
- Uses a portfolio date only when **Portfolio snapshot** is selected.
- Saves one dataset row per successful wallet, data type, and chain result when chain-specific data is available.
- Preserves analysis-friendly top-level fields plus the raw Arkham payload when it fits in one dataset row.
- Runs without asking for your Arkham login, cookies, API key, private wallet data, or wallet connection.

This Actor is focused on Arkham wallet analytics. It does not scrape transfers and swaps as a separate feed, monitor wallets in real time, send alerts by itself, or provide investment advice.

### 📦 Data you can extract

Each output row represents one successful Arkham wallet data result. Fields include:

- `inputIndex`, `inputValue`, and `walletAddress` for tracing the row back to your input.
- `dataType` and `chain` for grouping rows by the selected Arkham data surface.
- `sourceUrl` pointing back to the Arkham wallet page.
- `arkhamEntityName`, `arkhamEntityId`, and `arkhamEntityType` when Arkham exposes entity data.
- `arkhamLabelName`, `isUserAddress`, and `isContract` when available.
- `tokenCount`, `seriesPointCount`, and `totalUsd` when the selected payload contains those values.
- `rawPayload` with the original Arkham response for the selected wallet, data type, and chain when it fits in one dataset row. Very large history payloads are saved as a compact sample with truncation metadata.
- `scrapeStatus` and `scrapedAt` for run auditing.

Some fields are empty for some wallets, chains, or data types. For example, an intelligence row may include entity and label fields, while a balance-history row may be more useful inside `rawPayload`.

### 🚀 How to run it

1. Open the Input tab.
2. Add wallet addresses or Arkham wallet URLs in **Wallet addresses or Arkham wallet URLs**.
3. Choose **Data to collect**.
4. Optional: select **Chains** only when you want a narrower run.
5. Optional: set **Portfolio date** only for portfolio snapshots.
6. Run the Actor and open the dataset.

You can export results as JSON, CSV, Excel, XML, RSS, or HTML. You can also schedule the Actor or use the Apify API to pull fresh wallet data into your own workflow.

### ⚙️ Input example

```json
{
	"wallets": [
		"0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
		"https://intel.arkm.com/explorer/address/0x00000000219ab540356cbb839cbe05303d7705fa"
	],
	"dataType": "intelligence",
	"chains": ["ethereum", "base", "polygon"]
}
````

For portfolio snapshots, add `portfolioDate`:

```json
{
	"wallets": ["0xd8da6bf26964af9d7eed9e03e53415d37aa96045"],
	"dataType": "portfolio",
	"portfolioDate": "2024-01-01"
}
```

### 🧾 Output example

```json
{
	"inputIndex": 1,
	"inputValue": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
	"walletAddress": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
	"dataType": "intelligence",
	"chain": "ethereum",
	"sourceUrl": "https://intel.arkm.com/explorer/address/0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
	"arkhamEntityName": "vitalik.eth",
	"arkhamEntityId": null,
	"arkhamEntityType": null,
	"arkhamLabelName": null,
	"isUserAddress": true,
	"isContract": false,
	"tokenCount": null,
	"seriesPointCount": null,
	"totalUsd": null,
	"rawPayload": {
		"chain": "ethereum"
	},
	"scrapeStatus": "ok",
	"scrapedAt": "2026-06-05T22:40:00.000Z"
}
```

The exact Arkham data changes by wallet, chain, and data type. Use `rawPayload` when you need the full source-specific object.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successful wallet data result saved to the dataset. Invalid inputs, unsupported wallet-chain combinations, empty targets, and source failures do not create dataset rows.

Pricing is tiered by Apify plan and starts at `$0.0009` per saved wallet data result on higher tiers. Keep the first run small until the output shape fits your workflow.

### ⚠️ Limits and caveats

- Arkham may expose different fields for different wallets, chains, and data types.
- Very large Arkham history payloads may be compacted inside `rawPayload` so the result can fit Apify's dataset row limit.
- **Portfolio date** affects only portfolio snapshots.
- Leaving **Chains** empty collects every supported chain for the selected data type when Arkham returns data for those chains.
- Unsupported wallet-chain combinations can be skipped while the rest of the run continues.
- The Actor collects public Arkham wallet data available at run time. It does not access private Arkham account data.
- The output is wallet intelligence data, not financial advice.

### ❓ FAQ

#### 🔐 Do I need an Arkham account or API key?

No. The Actor does not ask for Arkham credentials, cookies, API keys, private wallet data, or wallet connection details.

#### 🔁 Can I scrape many wallets in one run?

Yes. Add one wallet address or Arkham wallet URL per row. The dataset keeps `inputIndex`, `inputValue`, and `walletAddress` so you can trace each result back to the submitted wallet.

#### 🌐 What happens if a chain has no data?

The Actor skips unsupported or empty wallet-chain results and continues with the rest of the run. Only successful data rows are saved to the dataset.

#### 📅 Can I request historical portfolio data?

Yes, for **Portfolio snapshot** runs. Use `portfolioDate` with an absolute date such as `2024-01-01` or a relative value such as `7 days`.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~arkham-intelligence-wallet-data-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [GMGN CopyTrade Wallet Scraper ↗](https://apify.com/maximedupre/gmgn-copytrade-wallet-scraper) - Export public GMGN smart money wallet leaderboards for crypto research.
- [Stocktwits Scraper ↗](https://apify.com/maximedupre/stocktwits-scraper) - Scrape public ticker messages, sentiment, and trending symbols for market monitoring.
- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Check public profile stats across major social platforms.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X posts, profiles, and trends for social and market research.
- [Ubersuggest Scraper ↗](https://apify.com/maximedupre/ubersuggest-scraper) - Collect SEO metrics, backlinks, and keyword ideas for research workflows.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `wallets` (type: `array`):

Enter one wallet address per row. You can also paste Arkham wallet URLs that contain a wallet address.

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

Choose the Arkham wallet data type to collect in this run.

## `chains` (type: `array`):

Leave empty to collect every supported chain for the selected data type. Select chains only when you want a narrower run.

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

Used only for Portfolio snapshot. Choose an absolute date such as 2024-01-01 or a relative value such as 7 days.

## Actor input object example

```json
{
  "wallets": [
    "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    "0x00000000219ab540356cbb839cbe05303d7705fa",
    "0x28c6c06298d514db089934071355e5743bf21d60",
    "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
  ],
  "dataType": "intelligence"
}
```

# Actor output Schema

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

Open the dataset to view scraped Arkham wallet analytics.

# 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 = {
    "wallets": [
        "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
        "0x00000000219ab540356cbb839cbe05303d7705fa",
        "0x28c6c06298d514db089934071355e5743bf21d60",
        "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/arkham-intelligence-wallet-data-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 = { "wallets": [
        "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
        "0x00000000219ab540356cbb839cbe05303d7705fa",
        "0x28c6c06298d514db089934071355e5743bf21d60",
        "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/arkham-intelligence-wallet-data-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 '{
  "wallets": [
    "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    "0x00000000219ab540356cbb839cbe05303d7705fa",
    "0x28c6c06298d514db089934071355e5743bf21d60",
    "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
  ]
}' |
apify call maximedupre/arkham-intelligence-wallet-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/arkham-intelligence-wallet-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arkham Wallet Data",
        "description": "Scrape Arkham Intelligence wallet data from addresses or Arkham wallet URLs. Export entity labels, tags, balances, history, loans, portfolio snapshots, volume, and P&L data in normalized rows.",
        "version": "0.1",
        "x-build-id": "92AMMnvCTKypIAGvp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~arkham-intelligence-wallet-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-arkham-intelligence-wallet-data-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/maximedupre~arkham-intelligence-wallet-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-arkham-intelligence-wallet-data-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/maximedupre~arkham-intelligence-wallet-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-arkham-intelligence-wallet-data-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": [
                    "wallets",
                    "dataType"
                ],
                "properties": {
                    "wallets": {
                        "title": "Wallet addresses or Arkham wallet URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Enter one wallet address per row. You can also paste Arkham wallet URLs that contain a wallet address.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "dataType": {
                        "title": "Data to collect",
                        "enum": [
                            "intelligence",
                            "volume",
                            "history",
                            "loans",
                            "balances",
                            "portfolio",
                            "flow"
                        ],
                        "type": "string",
                        "description": "Choose the Arkham wallet data type to collect in this run.",
                        "default": "intelligence"
                    },
                    "chains": {
                        "title": "Chains",
                        "type": "array",
                        "description": "Leave empty to collect every supported chain for the selected data type. Select chains only when you want a narrower run.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bitcoin",
                                "ethereum",
                                "solana",
                                "tron",
                                "dogecoin",
                                "ton",
                                "base",
                                "arbitrum_one",
                                "sonic",
                                "optimism",
                                "mantle",
                                "avalanche",
                                "bsc",
                                "linea",
                                "polygon",
                                "blast",
                                "manta",
                                "flare"
                            ],
                            "enumTitles": [
                                "Bitcoin",
                                "Ethereum",
                                "Solana",
                                "Tron",
                                "Dogecoin",
                                "TON",
                                "Base",
                                "Arbitrum One",
                                "Sonic",
                                "Optimism",
                                "Mantle",
                                "Avalanche",
                                "BNB Chain",
                                "Linea",
                                "Polygon",
                                "Blast",
                                "Manta",
                                "Flare"
                            ]
                        }
                    },
                    "portfolioDate": {
                        "title": "Portfolio date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Used only for Portfolio snapshot. Choose an absolute date such as 2024-01-01 or a relative value such as 7 days."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
