# Mempool.space Bitcoin Blocks Scraper (`parseforge/mempool-bitcoin-scraper`) Actor

Track the Bitcoin network from mempool.space without an API key. Pull recent blocks with height, mining pool, reward, total fees, and transaction count, plus recommended fee tiers, mempool congestion, difficulty, and address or transaction lookups. Good for fee timing and research.

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

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ₿ Mempool.space Bitcoin Scraper

> 🚀 **Pull live Bitcoin chain data in seconds.** One run returns the latest 15 blocks with mining pool, reward, fees, and transaction counts, plus on-demand fee, mempool, difficulty, address, and transaction lookups.

> 🕒 **Last updated:** 2026-06-04 · **📊 22 fields** per block record · keyless public API · full Bitcoin mainnet coverage

Track the Bitcoin network without running a node or registering for an API key. This Actor reads directly from the public mempool.space REST API and returns clean, flat records for recent blocks, recommended fees, mempool congestion, the next difficulty adjustment, and lookups for any address or transaction.

Coverage spans the entire Bitcoin mainnet. Block data includes the mining pool, coinbase address, block reward, total fees, median and average fee rates, plus input and output totals straight from the chain.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Crypto analysts and traders | Fee timing and mempool congestion monitoring |
| Bitcoin researchers and educators | Block, pool, and reward analysis |
| Wallet and dashboard builders | Address balance and transaction lookups |
| Quant and data teams | Feeding chain metrics into models and reports |

### 📋 What the Mempool.space Bitcoin Scraper does

Auto-detects what you want from your input and queries the matching mempool.space endpoint:

- **Recent blocks** (default) returns the latest blocks with height, hash, pool, reward, fees, and size.
- **Recommended fees** returns the five fee tiers in sat/vB.
- **Mempool summary** returns pending transaction count, virtual size, total fees, and current fee tiers.
- **Difficulty adjustment** returns progress, estimated change, remaining blocks, and the next retarget.
- **Address lookup** returns balance and confirmed and pending transaction stats for any Bitcoin address.
- **Transaction lookup** returns size, weight, fee, input and output counts, and confirmation status for any txid.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | `blocks` (default), `fees`, `mempool`, or `difficulty`. |
| `address` | string | Optional Bitcoin address. When set, overrides `mode` and returns an address summary. |
| `txid` | string | Optional transaction ID. When set, overrides `mode` and returns a transaction. |
| `maxItems` | integer | Free users limited to 10. Paid users up to 1,000,000. Only `blocks` returns multiple rows. |

**Example 1 — latest blocks:**
```json
{ "mode": "blocks", "maxItems": 15 }
````

**Example 2 — look up an address:**

```json
{ "address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa" }
```

> ⚠️ **Good to Know:** Only the `blocks` mode returns multiple rows (up to 15 most recent blocks). The `fees`, `mempool`, `difficulty`, `address`, and `txid` modes each return a single summary record. All values come straight from mempool.space and reflect the chain state at the moment of the run.

### 📊 Output

Each block record contains the following fields:

| Field | Description |
|---|---|
| 🧱 `height` | Block height |
| 🔑 `hash` | Block hash |
| 🔗 `blockUrl` | Link to the block on mempool.space |
| 🕒 `timestampIso` | Block time in ISO 8601 |
| 🔢 `txCount` | Number of transactions in the block |
| 📦 `sizeBytes` | Block size in bytes |
| ⚖️ `weight` | Block weight |
| 🎯 `difficulty` | Network difficulty at this block |
| ⛏ `miningPool` | Mining pool that found the block |
| 📬 `coinbaseAddress` | Coinbase payout address |
| 🎁 `rewardSats` | Block reward in satoshis |
| 💸 `totalFeesSats` | Total fees in satoshis |
| 📊 `medianFeeRate` | Median fee rate in sat/vB |
| 📈 `avgFeeRate` | Average fee rate in sat/vB |
| 🔽 `totalInputs` | Total transaction inputs |
| 🔼 `totalOutputs` | Total transaction outputs |
| 🕒 `scrapedAt` | When the record was collected |
| ❌ `error` | Null on success, message on failure |

**3 real sample records from a verified run:**

```json
{
  "height": 952381,
  "hash": "00000000000000000001f5876f88fa06db67d8e7c1faece31b229d67d40ee2c7",
  "blockUrl": "https://mempool.space/block/00000000000000000001f5876f88fa06db67d8e7c1faece31b229d67d40ee2c7",
  "timestampIso": "2026-06-04T19:18:04.000Z",
  "txCount": 4085,
  "sizeBytes": 1642484,
  "miningPool": "ViaBTC",
  "coinbaseAddress": "1PuJjnF476W3zXfVYmJfGnouzFDAXakkL4",
  "rewardSats": 316083398,
  "totalFeesSats": 3583398,
  "medianFeeRate": 2.87324390196209,
  "avgFeeRate": 3,
  "totalInputs": 8262,
  "totalOutputs": 9632,
  "scrapedAt": "2026-06-04T19:20:00.699Z",
  "error": null
}
```

```json
{
  "height": 952380,
  "hash": "000000000000000000001ad8bd62cc34034703275ac86a2016da31f42d0c09f4",
  "blockUrl": "https://mempool.space/block/000000000000000000001ad8bd62cc34034703275ac86a2016da31f42d0c09f4",
  "timestampIso": "2026-06-04T19:08:46.000Z",
  "txCount": 3713,
  "sizeBytes": 1637466,
  "miningPool": "SpiderPool",
  "coinbaseAddress": "1BM1sAcrfV6d4zPKytzziu4McLQDsFC2Qc",
  "rewardSats": 315762545,
  "totalFeesSats": 3262545,
  "medianFeeRate": 2.991864392919811,
  "avgFeeRate": 3,
  "totalInputs": 7764,
  "totalOutputs": 10359,
  "scrapedAt": "2026-06-04T19:20:00.760Z",
  "error": null
}
```

```json
{
  "height": 952379,
  "hash": "0000000000000000000204c5499e7da1b4add4873d158d43435d9c9a65eef95c",
  "blockUrl": "https://mempool.space/block/0000000000000000000204c5499e7da1b4add4873d158d43435d9c9a65eef95c",
  "timestampIso": "2026-06-04T19:04:32.000Z",
  "txCount": 4209,
  "sizeBytes": 1667631,
  "miningPool": "AntPool",
  "coinbaseAddress": "37jKPSmbEGwgfacCr2nayn1wTaqMAbA94Z",
  "rewardSats": 316654267,
  "totalFeesSats": 4154267,
  "medianFeeRate": 4,
  "avgFeeRate": 4,
  "totalInputs": 8315,
  "totalOutputs": 9300,
  "scrapedAt": "2026-06-04T19:20:00.784Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **No API key, no node.** Reads the public mempool.space API directly.
- **Six datasets in one Actor.** Blocks, fees, mempool, difficulty, address, and transaction lookups.
- **Clean flat records.** Every field is ready for a spreadsheet or a database without wrangling nested objects.
- **Real mining pool attribution.** Each block shows the pool that mined it and the coinbase payout address.
- **Always current.** Values reflect the chain state at the moment of each run.

### 📈 How it compares to alternatives

| | Mempool.space Bitcoin Scraper | Manual API calls | Running a full node |
|---|---|---|---|
| Setup time | Minutes | Hours of glue code | Days plus disk space |
| API key needed | No | No | No |
| Mining pool attribution | Yes | Build it yourself | Build it yourself |
| Address and tx lookups | Yes | Separate endpoints | Separate queries |
| Scheduling and integrations | Built in | Build it yourself | Build it yourself |

### 🚀 How to use

1. **Sign up** for a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Mempool.space Bitcoin Scraper from your Apify Console.
3. Choose a `mode`, or paste an `address` or `txid` to look one up.
4. Click **Start** and watch the run collect records live.
5. Download your results or connect them to another app through the API and integrations.

### 💼 Business use cases

**Trading and fee timing**

| Goal | How this helps |
|---|---|
| Time low-fee windows | Monitor mempool congestion and recommended fee tiers |
| Track confirmation speed | Watch block intervals and difficulty progress |

**Analytics and dashboards**

| Goal | How this helps |
|---|---|
| Build a chain dashboard | Pull blocks, fees, and difficulty into one feed |
| Pool market share | Aggregate `miningPool` across recent blocks |

**Wallet and product teams**

| Goal | How this helps |
|---|---|
| Show address balances | Look up balance and transaction stats by address |
| Verify a payment | Look up a transaction by txid and check confirmation |

**Research and reporting**

| Goal | How this helps |
|---|---|
| Study fee markets | Track median and average fee rates over time |
| Report on network health | Capture difficulty change and block sizes |

### 🔌 Automating Mempool.space Bitcoin Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub Actions, or Google Drive through the Apify API and integrations. Schedule the Actor to run every block interval and push fresh chain metrics into your own systems automatically.

### 🌟 Beyond business use cases

- **Research:** study fee dynamics, pool concentration, and block timing.
- **Personal:** keep a private log of fee tiers before you send a transaction.
- **Non-profit:** power open Bitcoin education dashboards.
- **Experimentation:** prototype chain analytics without standing up infrastructure.

### 🤖 Ask an AI assistant

Paste your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize fee trends, rank mining pools, or flag unusual blocks.

### ❓ Frequently Asked Questions

**Do I need a mempool.space API key?** No. The source API is public and keyless.

**Which network does it cover?** Bitcoin mainnet.

**How many blocks does the blocks mode return?** The most recent 15 blocks provided by the source.

**Can I look up any Bitcoin address?** Yes. Paste an address to get its balance and transaction stats.

**Can I look up a specific transaction?** Yes. Paste a txid to get size, weight, fee, and confirmation status.

**What is the fee unit?** Fee rates are in satoshis per virtual byte (sat/vB).

**Are amounts in BTC or satoshis?** Block rewards and fees are in satoshis. Address balance is provided in both satoshis and BTC.

**How fresh is the data?** Every value reflects the chain state at the moment of the run.

**Is the mining pool always identified?** The pool name comes from the source. Recent blocks reliably include it.

**Can I schedule recurring runs?** Yes, through the Apify scheduler and integrations.

**Is there a free tier?** Yes. Free runs are limited to 10 items as a preview.

**Does it work without running a Bitcoin node?** Yes. No node and no key are required.

### 🔌 Integrate with any app

Trigger runs and pull results through the Apify API, webhooks, or the prebuilt integrations for Make, Zapier, and more.

### 🔗 Recommended Actors

- [OpenChargeMap EV Station Scraper](https://apify.com/parseforge/openchargemap-scraper)
- [Libraries.io Package Scraper](https://apify.com/parseforge/libraries-io-scraper)
- [OpenAQ Air Quality Scraper](https://apify.com/parseforge/openaq-air-quality-scraper)
- [Understat xG Scraper](https://apify.com/parseforge/understat-xg-scraper)
- [Steam Store Scraper](https://apify.com/parseforge/steam-store-scraper)

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

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

> **⚠️ Disclaimer:** independent tool, not affiliated with mempool.space. Only publicly available data is collected.

# Actor input Schema

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

Pick a dataset. Recent blocks is the default. Ignored when an address or transaction ID is supplied below.

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

Optional. A Bitcoin address to look up. When set, returns that address balance and transaction stats and overrides the mode above.

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

Optional. A Bitcoin transaction ID (txid) to look up. When set, returns that transaction and overrides the mode above.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000. Only the recent blocks mode returns multiple rows.

## Actor input object example

```json
{
  "mode": "blocks",
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

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

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

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

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

```

## CLI example

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mempool.space Bitcoin Blocks Scraper",
        "description": "Track the Bitcoin network from mempool.space without an API key. Pull recent blocks with height, mining pool, reward, total fees, and transaction count, plus recommended fee tiers, mempool congestion, difficulty, and address or transaction lookups. Good for fee timing and research.",
        "version": "0.1",
        "x-build-id": "4QV0FEV3NJ3YQBabR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~mempool-bitcoin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-mempool-bitcoin-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~mempool-bitcoin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-mempool-bitcoin-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~mempool-bitcoin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-mempool-bitcoin-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "blocks",
                            "fees",
                            "mempool",
                            "difficulty"
                        ],
                        "type": "string",
                        "description": "Pick a dataset. Recent blocks is the default. Ignored when an address or transaction ID is supplied below.",
                        "default": "blocks"
                    },
                    "address": {
                        "title": "Bitcoin address",
                        "type": "string",
                        "description": "Optional. A Bitcoin address to look up. When set, returns that address balance and transaction stats and overrides the mode above."
                    },
                    "txid": {
                        "title": "Transaction ID",
                        "type": "string",
                        "description": "Optional. A Bitcoin transaction ID (txid) to look up. When set, returns that transaction and overrides the mode above."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000. Only the recent blocks mode returns multiple rows."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```