# Blockchain Data API — Wallet, Prices & Whale Alerts (`imapp/blockchain-api`) Actor

Zero-anti-bot blockchain data API. Query wallet portfolios, live token prices, whale alerts, and cross-chain balances across Ethereum, Base, Polygon & more. No scraping, no CAPTCHAs, no ToS issues. Pay only $0.0004 per result. Start with a free 7-day Pro trial (100K calls/mo).

- **URL**: https://apify.com/imapp/blockchain-api.md
- **Developed by:** [INAPP](https://apify.com/imapp) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0002 / result

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Blockchain Data API

Zero-anti-bot blockchain data API. Wallet portfolios,
whale alerts, cross-chain balances, and live token prices — no scraping, no
CAPTCHAs, no ToS issues.

### Quick Start

```bash
## Health check
curl https://imapp--blockchain-api.apify.actor/health
## {"status":"ok","service":"blockchain-api","version":"0.2.10"}

## Token price
curl https://imapp--blockchain-api.apify.actor/v1/token-price/ETH
## {"symbol":"ETH","price_usd":2987.45,"source":"coingecko"}

## Wallet portfolio
curl -X POST https://imapp--blockchain-api.apify.actor/v1/wallet \
  -H "Content-Type: application/json" \
  -d '{"address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"}'

## Whale alerts
curl -X POST https://imapp--blockchain-api.apify.actor/v1/whale-alerts \
  -H "Content-Type: application/json" \
  -d '{"address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "eth_threshold": 50}'

## Cross-chain balances
curl -X POST https://imapp--blockchain-api.apify.actor/v1/cross-chain \
  -H "Content-Type: application/json" \
  -d '{"address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "chains": ["eth","polygon","avax"]}'
````

### API Reference

All data endpoints are versioned under `/v1`. The `/health` endpoint is unversioned.

#### `GET /health`

```json
{"status":"ok","service":"blockchain-api","version":"0.2.10"}
```

#### `POST /v1/trial`

Get a free 7-day Pro trial API key (25 RPS, 100K calls/mo, all endpoints).

Limited to **1 key per IP address**. Returns your existing key if you already
have one. Rate-limited to 1 request per 60 seconds for new key generation.

```bash
curl -X POST https://imapp--blockchain-api.apify.actor/v1/trial
```

```json
{
  "api_key": "trial_a1b2c3d4e5f6g7h8",
  "tier": "pro",
  "expires_in_days": 7,
  "usage_instructions": {
    "authorization": "Bearer trial_a1b2c3d4e5f6g7h8",
    "endpoints": [
      "GET /v1/token-price/{symbol}",
      "POST /v1/wallet",
      "POST /v1/whale-alerts",
      "POST /v1/cross-chain"
    ],
    "docs": "/docs"
  }
}
```

#### `GET /v1/token-price/{symbol}`

Live USD price. Sources: CoinGecko → Chainlink → fallback.

| Param | Description |
|-------|-------------|
| `symbol` | `ETH`, `MATIC`, or `AVAX` (case-insensitive) |

```json
{"symbol":"ETH","price_usd":2987.45,"source":"coingecko"}
```

#### `POST /v1/wallet`

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `address` | string | *required* | 0x-prefixed address |
| `include_tokens` | bool | `true` | ERC-20 token balances |
| `include_nfts` | bool | `false` | NFT holdings |
| `include_transfers` | bool | `false` | Recent transfers |
| `transfer_limit` | int | `20` | Max transfers (1–100) |
| `chain` | string | `"eth"` | Chain key |

#### `POST /v1/whale-alerts`

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `address` | string | *required* | Address to monitor |
| `eth_threshold` | float | `50` | ETH alert threshold |
| `usd_threshold` | float | `100000` | USD alert threshold |
| `direction` | string | `"both"` | `"in"`, `"out"`, or `"both"` |
| `lookback_blocks` | int | `1000` | Blocks to scan (~4 hours) |

#### `POST /v1/cross-chain`

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `address` | string | *required* | Address |
| `chains` | list | all | `eth`, `arb`, `base`, `polygon`, `opt`, `avax` |
| `include_tokens` | bool | `true` | Include token counts |
| `include_nfts` | bool | `false` | Include NFT counts |

### Supported Chains

| Key | Chain | Currency |
|-----|-------|----------|
| `eth` | Ethereum | ETH |
| `arb` | Arbitrum | ETH |
| `base` | Base | ETH |
| `polygon` | Polygon | MATIC |
| `opt` | Optimism | ETH |
| `avax` | Avalanche C-Chain | AVAX |

### Pricing

**Pay per result** — you only pay for what you use.

| Event | Price | Note |
|-------|-------|------|
| **API result** | **$0.0004** | Charged per API response. 10K calls = $4, 100K = $40, 500K = $200. |
| **Actor start** | **$0.00005** | One-time fee per session (first 5s waived). |

| Apify user tier | Your price per result |
|----------------|---------------------|
| Free | $0.0004 |
| Bronze | $0.0003 |
| Silver | $0.00025 |
| Gold | $0.0002 |

Higher Apify tiers get automatic volume discounts — no coupon codes, no hidden fees.

#### Tier limits (enforced server-side)

| Tier | Calls/mo | RPS | Chains |
|------|----------|-----|--------|
| **Free** | 3,000 | 2 | 1 |
| **Starter** | 10,000 | 5 | 3 |
| **Pro** | 100,000 | 25 | 6 |
| **Enterprise** | 500,000 | 50 | 6 |

At $0.0004/result, 10K calls cost just **$4** — 60% less than GoldRush ($10/mo minimum).
Pro at 100K calls ($40) undercuts QuickNode ($49/mo) and Infura ($50/mo).
Enterprise at 500K calls ($200) competes with Moralis ($199/mo) on volume while
offering dedicated rate limits (50 RPS) and 6 chains.

New users get a **free 7-day Pro trial** (25 RPS, 100K calls/mo, all endpoints) by calling
`POST /v1/trial`. No credit card required.

### Authentication

Pass your API key via `x-api-key` or `Authorization: Bearer` header:

```bash
curl https://imapp--blockchain-api.apify.actor/v1/token-price/ETH \
  -H "x-api-key: sk_starter_abc123"
```

No key? You get the free tier automatically.

### Rate Limits

Each tier has a **requests-per-second** cap and a **monthly quota**. Exceed either and
you get `429 Too Many Requests` with `Retry-After`.

Every response includes rate-limit headers:

```
X-RateLimit-Limit-RPS: 5
X-RateLimit-Remaining-RPS: 4
X-RateLimit-Limit-Monthly: 10000
X-RateLimit-Remaining-Monthly: 9997
X-Tier: free
```

When rate-limited:

```json
{"detail":"RPS limit exceeded","retry_after_seconds":0.85}
```

### Errors

| Status | Code | Meaning |
|--------|------|---------|
| 400 | `invalid_chain` / `unknown_token` | Bad parameter |
| 422 | validation | Invalid address format |
| 429 | rate\_limited | RPS or monthly quota exceeded |
| 502 | `rpc_error` / `price_unavailable` | Upstream failure |

### License

MIT

# Actor input Schema

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

Your Alchemy API key for blockchain RPC calls. Get one at https://dashboard.alchemy.com/

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

Verbosity of server logs.

## `maxConcurrentRpc` (type: `integer`):

Maximum number of concurrent outbound RPC calls per request.

## `maxConcurrentRequests` (type: `integer`):

Maximum number of concurrent inbound HTTP requests (global semaphore).

## `rpcTimeout` (type: `number`):

Timeout for individual JSON-RPC calls in seconds.

## `fallbackPrices` (type: `object`):

Fallback prices used when CoinGecko and Chainlink are both unavailable.

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

Priority order for fetching token prices.

## `whaleThresholds` (type: `object`):

Default thresholds for whale transaction detection.

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

JSON mapping of API keys to tier names for monetization.

## Actor input object example

```json
{
  "alchemyApiKey": "alcht_...",
  "logLevel": "info",
  "maxConcurrentRpc": 5,
  "maxConcurrentRequests": 20,
  "rpcTimeout": 15,
  "fallbackPrices": {
    "eth": 3000,
    "matic": 0.68,
    "avax": 35
  },
  "priceFeedOrder": "coingecko,chainlink",
  "whaleThresholds": {
    "eth": 50,
    "usd": 100000
  },
  "apiKeysJson": "{}"
}
```

# 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 = {
    "alchemyApiKey": "alcht_..."
};

// Run the Actor and wait for it to finish
const run = await client.actor("imapp/blockchain-api").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 = { "alchemyApiKey": "alcht_..." }

# Run the Actor and wait for it to finish
run = client.actor("imapp/blockchain-api").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 '{
  "alchemyApiKey": "alcht_..."
}' |
apify call imapp/blockchain-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Blockchain Data API — Wallet, Prices & Whale Alerts",
        "description": "Zero-anti-bot blockchain data API. Query wallet portfolios, live token prices, whale alerts, and cross-chain balances across Ethereum, Base, Polygon & more. No scraping, no CAPTCHAs, no ToS issues. Pay only $0.0004 per result. Start with a free 7-day Pro trial (100K calls/mo).",
        "version": "0.2",
        "x-build-id": "0002JOYSnkooe8aMf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/imapp~blockchain-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-imapp-blockchain-api",
                "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/imapp~blockchain-api/runs": {
            "post": {
                "operationId": "runs-sync-imapp-blockchain-api",
                "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/imapp~blockchain-api/run-sync": {
            "post": {
                "operationId": "run-sync-imapp-blockchain-api",
                "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": [
                    "alchemyApiKey"
                ],
                "properties": {
                    "alchemyApiKey": {
                        "title": "RPC API Key",
                        "type": "string",
                        "description": "Your Alchemy API key for blockchain RPC calls. Get one at https://dashboard.alchemy.com/"
                    },
                    "logLevel": {
                        "title": "Log Level",
                        "enum": [
                            "debug",
                            "info",
                            "warning",
                            "error"
                        ],
                        "type": "string",
                        "description": "Verbosity of server logs.",
                        "default": "info"
                    },
                    "maxConcurrentRpc": {
                        "title": "Max Concurrent RPC Calls",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of concurrent outbound RPC calls per request.",
                        "default": 5
                    },
                    "maxConcurrentRequests": {
                        "title": "Max Concurrent HTTP Requests",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of concurrent inbound HTTP requests (global semaphore).",
                        "default": 20
                    },
                    "rpcTimeout": {
                        "title": "RPC Timeout (seconds)",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "number",
                        "description": "Timeout for individual JSON-RPC calls in seconds.",
                        "default": 15
                    },
                    "fallbackPrices": {
                        "title": "Fallback Token Prices (USD)",
                        "type": "object",
                        "description": "Fallback prices used when CoinGecko and Chainlink are both unavailable.",
                        "properties": {
                            "eth": {
                                "title": "ETH Fallback Price (USD)",
                                "type": "number",
                                "description": "Fallback ETH price in USD when price feeds are unavailable.",
                                "default": 3000,
                                "minimum": 0
                            },
                            "matic": {
                                "title": "MATIC Fallback Price (USD)",
                                "type": "number",
                                "description": "Fallback MATIC price in USD when price feeds are unavailable.",
                                "default": 0.68,
                                "minimum": 0
                            },
                            "avax": {
                                "title": "AVAX Fallback Price (USD)",
                                "type": "number",
                                "description": "Fallback AVAX price in USD when price feeds are unavailable.",
                                "default": 35,
                                "minimum": 0
                            }
                        },
                        "default": {
                            "eth": 3000,
                            "matic": 0.68,
                            "avax": 35
                        }
                    },
                    "priceFeedOrder": {
                        "title": "Price Feed Priority Order",
                        "enum": [
                            "coingecko,chainlink",
                            "chainlink,coingecko",
                            "coingecko",
                            "chainlink"
                        ],
                        "type": "string",
                        "description": "Priority order for fetching token prices.",
                        "default": "coingecko,chainlink"
                    },
                    "whaleThresholds": {
                        "title": "Whale Alert Thresholds",
                        "type": "object",
                        "description": "Default thresholds for whale transaction detection.",
                        "properties": {
                            "eth": {
                                "title": "ETH Threshold",
                                "type": "number",
                                "description": "Minimum ETH value to trigger an alert.",
                                "default": 50,
                                "minimum": 0
                            },
                            "usd": {
                                "title": "USD Threshold",
                                "type": "number",
                                "description": "Minimum USD value to trigger an alert.",
                                "default": 100000,
                                "minimum": 0
                            }
                        },
                        "default": {
                            "eth": 50,
                            "usd": 100000
                        }
                    },
                    "apiKeysJson": {
                        "title": "API Key Tiers (JSON)",
                        "type": "string",
                        "description": "JSON mapping of API keys to tier names for monetization.",
                        "default": "{}"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
