# DefiLlama Scraper (`crawlerbros/defillama-scraper`) Actor

Pull DeFi data from DefiLlama's public APIs with protocols + historical TVL, chain TVL aggregates, stablecoins, yield pools, DEX volumes, lending markets, bridge volumes. No auth, no proxy, no cookies.

- **URL**: https://apify.com/crawlerbros/defillama-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## DefiLlama Scraper

Pull DeFi metrics from DefiLlama's public APIs — protocols, TVL, stablecoins, yield pools, DEX volumes, lending markets, fees, bridge volumes, and current token prices. **No auth, no proxy, no cookies** required.

### Quick Start

```json
{
  "mode": "protocols",
  "minTvlUsd": 1000000,
  "category": "Lending",
  "maxItems": 20
}
````

### Modes

| Mode | What it does | Key inputs |
|---|---|---|
| `protocols` | Every DeFi protocol with current TVL, chain breakdown, market cap, FDV, 1h/1d/7d change | `category`, `minTvlUsd` |
| `byProtocol` | Summary + full historical TVL series for one protocol | `protocolSlug` |
| `tvl` | Current TVL by chain (all chains) | `chain`, `minTvlUsd` |
| `historicalChainTvl` | Daily TVL series for one chain | `chain` |
| `stablecoins` | Every stablecoin with circulating supply, peg type, chains, current price | `stablecoinIncludePrices` |
| `stablecoinChains` | Aggregate stablecoin circulating supply per chain | — |
| `stablecoinPrices` | Historical price series for one stablecoin | `stablecoinId` |
| `yields` | Every yield pool with APY, TVL, project, chain, IL risk | `chain`, `minTvlUsd` |
| `yieldsByPool` | Historical APY + TVL for one pool | `poolId` |
| `dexVolumes` | DEX overview — every DEX with 24h/7d/30d/all-time volume | — |
| `dexByProtocol` | Summary + daily-volume history for one DEX | `protocolSlug` |
| `lendingMarkets` | Lending overview — every lending protocol with totals | — |
| `lendingByProtocol` | Summary + daily-volume history for one lending protocol | `protocolSlug` |
| `fees` | Protocol fees & revenue overview | — |
| `bridges` | Cross-chain bridge volumes (24h/7d/30d, daily txs) | — |
| `bridgeByName` | Daily volume history for one bridge | `bridgeName` |
| `currentPrices` | Current USD prices for tokens (DefiLlama coin ID format) | `tokenIds` |
| `byUrl` | Auto-detect mode from any defillama.com URL | `url` |

### Sample record (`mode=protocols`)

```json
{
  "recordType": "protocol",
  "name": "Aave",
  "slug": "aave",
  "symbol": "AAVE",
  "url": "https://aave.com",
  "logo": "https://icons.llama.fi/aave.png",
  "chains": ["Ethereum", "Polygon", "Avalanche", "Optimism", "Arbitrum"],
  "category": "Lending",
  "tvlUsd": 12345678901.23,
  "chainTvls": {"Ethereum": 10000000000, "Polygon": 1000000000},
  "change1d": -1.2,
  "change7d": 5.7,
  "marketCapUsd": 999000000,
  "fullyDilutedValuationUsd": 1500000000,
  "defillamaUrl": "https://defillama.com/protocol/aave",
  "scrapedAt": "2026-05-09T12:00:00+00:00"
}
```

### Token IDs for `currentPrices`

DefiLlama uses a `<source>:<id>` format:

- `coingecko:bitcoin`, `coingecko:ethereum`
- `ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48` (USDC on mainnet)
- `bsc:0x55d398326f99059ff775485246999027b3197955` (USDT on BSC)
- `arbitrum:0xff970a61a04b1ca14834a43f5de4533ebddb5cc8` (USDC on Arbitrum)

Up to 100 IDs per call.

### FAQ

**Do I need an API key?**
No. All endpoints used by this actor are public. Heavy traffic may hit DefiLlama's rate limits — the actor honors `Retry-After` headers and uses exponential backoff.

**How do I find the right `protocolSlug` / `chain` / `bridgeName` / `poolId`?**
Browse [defillama.com](https://defillama.com), copy any URL you see, and use `mode=byUrl` to auto-detect everything. Or paste the slug from the URL directly into `protocolSlug`.

**Why don't I see TVL series with `mode=protocols`?**
The `protocols` endpoint returns *current* TVL only (with 1h/1d/7d change). For full historical TVL, use `mode=byProtocol` with a `protocolSlug` — that returns the entire TVL time series since the protocol launched.

**Some chains show "0" TVL — why?**
DefiLlama's "all-chain" totals include `chainTvls` that distinguish staked, borrowed, and pooled TVL. Entries with 0 are stripped from output to keep records clean.

**Can I filter by chain inside `mode=protocols`?**
Use the chain dropdown — but for chain-specific TVL series, `mode=historicalChainTvl` is faster and more accurate.

**What's the rate limit?**
DefiLlama's public API doesn't publish a hard limit but recommends ~300 req/min. The actor paces itself with exponential backoff.

### Limitations

- **`bridges` and `bridgeByName` now require a paid DefiLlama plan** (the public `bridges.llama.fi` endpoint was migrated behind their subscription wall in 2025). The actor still ships these modes — they soft-fail with a clean `set_status_message` pointing users at https://defillama.com/subscription. Every other mode remains free.
- DefiLlama merges some legacy / forked protocols under a parent record — the `slug` is authoritative.
- `currentPrices` confidence scores are upstream-provided; tokens with `confidence < 0.5` may be stale.
- `tokenIds` cap is 100 per call; for larger lists, run multiple calls.
- Stablecoin `pegType` is a free-text upstream field; new pegs may appear that aren't yet in the canonical set.

### Output schema

Every record carries `recordType` and `scrapedAt`, plus mode-specific fields. Empty / null fields are stripped before push (no `null`, `""`, `[]`, `{}` in the dataset).

### URL fields

Every record includes a verified `defillamaUrl` pointing to the canonical DefiLlama page for the entity (`/protocol/`, `/chain/`, `/stablecoin/`, `/yields/pool/`). Note that `defillama.com` is fronted by Cloudflare, which 403s default-curl requests; visit in a browser (or send a normal browser User-Agent) for HTML rendering. Logo / icon URLs (`icons.llamao.fi`, `icons.llama.fi`) are 200 from any client without anti-bot protection.

# Actor input Schema

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

What to fetch.

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

DefiLlama protocol slug — visible in the URL on defillama.com (e.g. `aave`, `lido`, `uniswap`, `curve-dex`). Example: `aave`.

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

Chain name as DefiLlama uses it. Use the dropdown for top chains, OR paste an exact chain name from the chains list (case-sensitive — DefiLlama uses `Ethereum`, `BSC`, etc.).

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

Filter protocols by DefiLlama category (e.g. `Lending`, `Dexes`, `Liquid Staking`, `Yield Aggregator`, `Bridge`, `CDP`, `Yield`, `Derivatives`, `Cross Chain`).

## `minTvlUsd` (type: `integer`):

Drop records with TVL below this threshold (USD).

## `stablecoinId` (type: `integer`):

DefiLlama stablecoin ID (e.g. `1` = USDT, `2` = USDC). See `mode=stablecoins` to enumerate.

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

DefiLlama yield pool UUID (visible in the pool URL on yields.llama.fi).

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

Bridge identifier from the bridges list.

## `tokenIds` (type: `array`):

List of token IDs in DefiLlama format: `coingecko:bitcoin`, `ethereum:0x...`, `bsc:0x...`. Up to 100 per call.

## `stablecoinIncludePrices` (type: `boolean`):

When true, the stablecoins endpoint includes current price data per asset.

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

Any defillama.com URL — auto-detected. Examples: defillama.com/protocol/aave , defillama.com/chain/Ethereum , stablecoins.llama.fi (homepage → top stablecoins).

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

Hard cap on emitted records. Example: `100`.

## Actor input object example

```json
{
  "mode": "protocols",
  "chain": "",
  "category": "",
  "tokenIds": [],
  "stablecoinIncludePrices": true,
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped DefiLlama records.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "protocols",
    "chain": "",
    "category": "",
    "tokenIds": [],
    "stablecoinIncludePrices": true,
    "maxItems": 20
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "protocols",
    "chain": "",
    "category": "",
    "tokenIds": [],
    "stablecoinIncludePrices": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/defillama-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "protocols",
  "chain": "",
  "category": "",
  "tokenIds": [],
  "stablecoinIncludePrices": true,
  "maxItems": 20
}' |
apify call crawlerbros/defillama-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DefiLlama Scraper",
        "description": "Pull DeFi data from DefiLlama's public APIs with protocols + historical TVL, chain TVL aggregates, stablecoins, yield pools, DEX volumes, lending markets, bridge volumes. No auth, no proxy, no cookies.",
        "version": "1.0",
        "x-build-id": "pkzL6QvfO708Pn4YN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~defillama-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-defillama-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~defillama-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-defillama-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~defillama-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-defillama-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "protocols",
                            "byProtocol",
                            "tvl",
                            "historicalChainTvl",
                            "stablecoins",
                            "stablecoinChains",
                            "stablecoinPrices",
                            "yields",
                            "yieldsByPool",
                            "dexVolumes",
                            "dexByProtocol",
                            "lendingMarkets",
                            "lendingByProtocol",
                            "fees",
                            "bridges",
                            "bridgeByName",
                            "currentPrices",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "protocols"
                    },
                    "protocolSlug": {
                        "title": "Protocol slug (mode=byProtocol / dexByProtocol / lendingByProtocol)",
                        "type": "string",
                        "description": "DefiLlama protocol slug — visible in the URL on defillama.com (e.g. `aave`, `lido`, `uniswap`, `curve-dex`). Example: `aave`."
                    },
                    "chain": {
                        "title": "Chain (mode=historicalChainTvl, optional filter)",
                        "enum": [
                            "",
                            "Ethereum",
                            "Tron",
                            "Solana",
                            "BSC",
                            "Bitcoin",
                            "Base",
                            "Arbitrum",
                            "Polygon",
                            "Avalanche",
                            "Sui",
                            "Hyperliquid",
                            "Optimism",
                            "Sei",
                            "Aptos",
                            "Mantle",
                            "Sonic",
                            "Cronos",
                            "Linea",
                            "Cardano",
                            "Mixin",
                            "Hedera",
                            "Manta",
                            "Blast",
                            "Scroll",
                            "Algorand",
                            "Polygon zkEVM",
                            "Fantom",
                            "Gnosis",
                            "Celo",
                            "zkSync Era",
                            "Stellar"
                        ],
                        "type": "string",
                        "description": "Chain name as DefiLlama uses it. Use the dropdown for top chains, OR paste an exact chain name from the chains list (case-sensitive — DefiLlama uses `Ethereum`, `BSC`, etc.).",
                        "default": ""
                    },
                    "category": {
                        "title": "Category filter (mode=protocols)",
                        "enum": [
                            "",
                            "Lending",
                            "Dexes",
                            "Liquid Staking",
                            "Yield Aggregator",
                            "Bridge",
                            "CDP",
                            "Yield",
                            "Derivatives",
                            "Cross Chain",
                            "Restaking",
                            "Liquid Restaking",
                            "RWA",
                            "Stablecoin Issuer",
                            "Insurance",
                            "Synthetics",
                            "Options",
                            "Indexes",
                            "NFT Marketplace",
                            "NFT Lending",
                            "Launchpad",
                            "Prediction Market",
                            "Privacy",
                            "Algo-Stables",
                            "Services"
                        ],
                        "type": "string",
                        "description": "Filter protocols by DefiLlama category (e.g. `Lending`, `Dexes`, `Liquid Staking`, `Yield Aggregator`, `Bridge`, `CDP`, `Yield`, `Derivatives`, `Cross Chain`).",
                        "default": ""
                    },
                    "minTvlUsd": {
                        "title": "Minimum TVL in USD (mode=protocols / yields)",
                        "minimum": 0,
                        "maximum": 1000000000000,
                        "type": "integer",
                        "description": "Drop records with TVL below this threshold (USD)."
                    },
                    "stablecoinId": {
                        "title": "Stablecoin ID (mode=stablecoinPrices)",
                        "minimum": 1,
                        "maximum": 999,
                        "type": "integer",
                        "description": "DefiLlama stablecoin ID (e.g. `1` = USDT, `2` = USDC). See `mode=stablecoins` to enumerate."
                    },
                    "poolId": {
                        "title": "Pool ID (mode=yieldsByPool)",
                        "type": "string",
                        "description": "DefiLlama yield pool UUID (visible in the pool URL on yields.llama.fi)."
                    },
                    "bridgeName": {
                        "title": "Bridge name (mode=bridgeByName)",
                        "type": "string",
                        "description": "Bridge identifier from the bridges list."
                    },
                    "tokenIds": {
                        "title": "Token IDs (mode=currentPrices)",
                        "type": "array",
                        "description": "List of token IDs in DefiLlama format: `coingecko:bitcoin`, `ethereum:0x...`, `bsc:0x...`. Up to 100 per call.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "stablecoinIncludePrices": {
                        "title": "Include current prices (mode=stablecoins)",
                        "type": "boolean",
                        "description": "When true, the stablecoins endpoint includes current price data per asset.",
                        "default": true
                    },
                    "url": {
                        "title": "URL (mode=byUrl)",
                        "type": "string",
                        "description": "Any defillama.com URL — auto-detected. Examples: defillama.com/protocol/aave , defillama.com/chain/Ethereum , stablecoins.llama.fi (homepage → top stablecoins)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Example: `100`.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
