# Crypto Price Tracker — Multi-Source Watchlist & Market API (`khadinakbar/crypto-price-tracker`) Actor

Fetch real-time prices, market cap, 24h/7d/30d changes, ATH/ATL, supply, dominance, and computed analytics for a watchlist of coins (BTC, ETH, SOL...) or the top N by market cap. Multi-source: CoinGecko primary, Binance fallback. PPE: $0.003/coin.

- **URL**: https://apify.com/khadinakbar/crypto-price-tracker.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Developer tools, AI, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 coin trackeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 🪙 Crypto Price Tracker — Multi-Source Watchlist & Market API

Real-time cryptocurrency price tracker that fetches **prices, market cap, 24h/7d/30d changes, ATH/ATL, supply, and dominance** for a watchlist of specific coins (BTC, ETH, SOL...) **or** the top N coins by market cap. Multi-source: **CoinGecko** primary, with optional **Binance** fallback for fresher tick data and resilience to rate limits.

Built MCP-first for AI trading agents, portfolio bots, and crypto research. Cheap targeted runs (5-coin watchlist ≈ $0.015) or full market sweeps (top 100 ≈ $0.30).

### What you get

| Field | Type | Notes |
|---|---|---|
| `symbol` | string | Uppercase ticker (BTC, ETH, …) |
| `name` | string | "Bitcoin", "Ethereum" |
| `coingeckoId` | string | Stable slug (e.g. `bitcoin`) |
| `quoteCurrency` | string | `usd`, `eur`, `gbp`, `jpy`, `cny`, `btc`, or `eth` |
| `price` | number | Current price in `quoteCurrency` |
| `marketCap` | number | Market capitalization in `quoteCurrency` |
| `volume24h` | number | 24h trading volume in `quoteCurrency` |
| `change1h` / `change24h` / `change7d` / `change30d` | number | Percentage changes |
| `ath` / `athDate` / `athChangePct` | number/string | All-time high data |
| `atl` / `atlDate` | number/string | All-time low data |
| `circulatingSupply` / `totalSupply` / `maxSupply` | number | Supply metrics |
| `marketCapRank` | number | 1 = highest |
| `dominancePct` | number | Share of total crypto market cap (market mode) |
| `binancePriceUsd` / `binanceVolume24hUsd` | number | Binance USDT fallback ticker (always USD) |
| `priceSource` | string | `coingecko` or `binance` |
| `lastUpdated` | string | ISO 8601 |
| `coingeckoUrl` | string | Public CoinGecko page |
| `scrapedAt` | string | ISO 8601 |

### Why use this

Most crypto scrapers on Apify dump the entire CoinGecko/CoinMarketCap database on every run — paying for thousands of coins you don't care about. This actor gives you a **watchlist mode** so you only pay for the 5–20 coins you actually track, and a **market mode** for the top N when you need a broader sweep.

- **Watchlist mode** — track BTC, ETH, SOL, your portfolio. 5 coins = $0.015.
- **Market mode** — top 100 by market cap = $0.30. Top 1000 = $3.00.
- **Multi-source resilience** — CoinGecko gets rate-limited at 30 req/min; Binance fallback keeps fresh prices flowing.
- **AI-agent friendly** — flat schema, stable keys, optional `concise` response format for LLM context.
- **No API keys** — uses free public endpoints with smart rate-limit handling.

### Pricing — Pay Per Event

| Event | Price |
|---|---|
| Actor Start (per GB-RAM) | $0.00005 |
| Coin Tracked | **$0.003** per coin |

Plus standard Apify platform usage (proxy, compute, storage) — billed against your Apify plan. The actor uses 512 MB and pure HTTP (no browser), so a typical 100-coin run uses < 0.0002 compute units.

#### Cost examples

- 5-coin watchlist (BTC, ETH, SOL, XRP, DOGE): **$0.015** + ~$0.00005 start
- 25-coin watchlist: **$0.075** + start
- Top 100 market sweep: **$0.30** + start
- Top 1000 market sweep: **$3.00** + start

### How to use it

#### Inputs

| Field | Required | Default | Notes |
|---|---|---|---|
| `mode` | yes | `watchlist` | `watchlist` or `market` |
| `symbols` | conditional | `["BTC","ETH","SOL","XRP","DOGE"]` | Required when `mode=watchlist`. Up to 100 |
| `topN` | no | 100 | Used in `market` mode. 10–1000 |
| `vsCurrency` | no | `usd` | usd, eur, gbp, jpy, cny, btc, eth |
| `useBinanceFallback` | no | `true` | Adds Binance ticker data |
| `responseFormat` | no | `detailed` | `detailed` (all fields) or `concise` (LLM-friendly) |

#### Watchlist example (JavaScript)

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/crypto-price-tracker').call({
    mode: 'watchlist',
    symbols: ['BTC', 'ETH', 'SOL', 'XRP', 'DOGE'],
    vsCurrency: 'usd',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((c) => console.log(`${c.symbol}: $${c.price} (${c.change24h?.toFixed(2)}%)`));
````

#### Market sweep example (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("khadinakbar/crypto-price-tracker").call(run_input={
    "mode": "market",
    "topN": 250,
    "vsCurrency": "usd",
    "responseFormat": "detailed",
})

for coin in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"#{coin['marketCapRank']} {coin['symbol']}: ${coin['price']} ({coin['change24h']:.2f}%)")
```

#### MCP / AI-Agent usage

This actor is registered with Apify MCP as `apify--crypto-price-tracker`. From any Claude Desktop / Cursor / GPT setup with Apify MCP enabled:

```
"Get me current prices and 24h changes for BTC, ETH, and SOL"
"What are the top 50 coins by market cap right now?"
"How far is each of these coins from its all-time high: BTC, ETH, SOL, AVAX, MATIC?"
```

The agent will call this actor, get a flat JSON response, and reason directly over price + change + ATH data.

### Two modes explained

#### Watchlist mode

Provide a list of tickers. The actor:

1. Loads CoinGecko's full coin list (cached 24h in KV store).
2. Resolves each symbol → CoinGecko ID using a curated preference map for top-50 coins (avoids ambiguity for tickers like `UNI` which 8+ coins claim).
3. Fetches `/coins/markets` with the resolved IDs in one call (up to 250).
4. Optionally enriches with Binance USDT-pair tickers.
5. Pushes one record per coin to the dataset.

#### Market mode

Sweeps the top N coins by market cap:

1. Pages through `/coins/markets` (250 per page).
2. Computes `dominancePct` from `/global` for each coin.
3. Same enrichment + output as watchlist mode.

### Reliability

- **Retry with backoff** — 4 retries with exponential backoff (1.5s → 24s) on 5xx errors.
- **Rate-limit aware** — 429 triggers `Retry-After`-aware backoff, 30s minimum.
- **Multi-source fallback** — when CoinGecko's price is null (rare but happens during cache misses), Binance USDT ticker fills in.
- **Coin-list cache** — the 17K-coin list is cached 24h in the actor's KV store, so repeat runs skip the heavy enumeration.
- **Per-page failure tolerance** — market mode tolerates a single page failure and continues with what it has.
- **PPE limit aware** — gracefully exits when the user-set per-run PPE cap is reached.

### FAQ

**Q: How fresh is the data?**
CoinGecko refreshes every 1–5 minutes per coin. Binance fallback is sub-second. The `lastUpdated` field tells you exactly when each coin was last refreshed upstream.

**Q: Why am I getting fewer coins than I requested?**
Some tickers (like obscure altcoins) may not exist on CoinGecko, or there are multiple coins with the same ticker. Check the `summary_run` key in the run's KV store for the `unresolvedSymbols` list.

**Q: Can I track tokens not on CoinGecko?**
This actor uses CoinGecko as its source of truth for IDs. For DEX tokens not on CoinGecko, see the DexScreener actor instead.

**Q: How do I avoid duplicates across runs?**
Each run produces its own dataset by default. Use the same `defaultDatasetId` on subsequent runs (Apify SDK option) to append, or filter by `scrapedAt`.

**Q: Is this real-time?**
This is on-demand polling, not WebSocket streaming. For real-time tick data, run this actor on a schedule (every 1–5 min) using Apify Schedules.

### Legal

This actor uses CoinGecko's free public API and Binance's free public ticker API. Both APIs explicitly allow non-commercial polling at reasonable rates. This actor respects rate limits and adds smart back-off on 429 responses.

The data returned is the property of CoinGecko / Binance respectively. Cryptocurrency prices change constantly — data may be 1–5 minutes stale. **Not financial advice.** Trading cryptocurrencies involves substantial risk; do your own research.

### Support

- 📧 Issues: open one on the actor's [Issues tab](https://apify.com/khadinakbar/crypto-price-tracker/issues)
- 🐦 X: [@khadinakbar](https://x.com/khadinakbar)
- 💬 Other actors: [browse my store](https://apify.com/khadinakbar)

Related actors:

- [google-finance-stock-news-scraper](https://apify.com/khadinakbar/google-finance-stock-news-scraper) — same idea, but for stocks
- [google-news-scraper](https://apify.com/khadinakbar/google-news-scraper) — pair with crypto news monitoring
- [ai-search-brand-monitor](https://apify.com/khadinakbar/ai-search-brand-monitor) — track how AI search engines describe crypto projects

# Actor input Schema

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

Choose 'watchlist' to track a specific list of coins by symbol (e.g. BTC, ETH, SOL) or 'market' to sweep the top N coins by market cap. Watchlist is cheaper for targeted tracking; market is best for portfolio-style scans of the broader market. Defaults to 'watchlist'.

## `symbols` (type: `array`):

List of coin tickers to fetch when mode='watchlist'. Case-insensitive (BTC, btc, Btc all work). Common tickers: BTC, ETH, SOL, USDC, USDT, XRP, BNB, ADA, DOGE, AVAX, LINK, MATIC, DOT, SHIB, LTC. Up to 100 symbols. Required when mode='watchlist'; ignored otherwise.

## `topN` (type: `integer`):

How many coins to fetch when mode='market', sorted by market cap descending. Page size is 250 (CoinGecko max), so 250 returns 1 API call; 1000 returns 4 calls. Default 100. Hard max 1000. Ignored when mode='watchlist'.

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

Fiat or crypto to quote prices in. Most users want 'usd'. Other supported: eur, gbp, jpy, cny, btc, eth. ISO 4217 lowercase. Defaults to 'usd'.

## `useBinanceFallback` (type: `boolean`):

When true, supplements CoinGecko data with Binance public ticker for fresher 24h price action on USDT pairs. Adds resiliency if CoinGecko rate-limits. Adds ~0 cost (no extra event charged). Default true. Set false for CoinGecko-only output.

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

'detailed' returns all fields including ATH/ATL/supply/dominance (~300 tokens/item). 'concise' drops ATH/ATL/supply for compact agent output (~150 tokens/item). Use concise when feeding many coins into an LLM context. Defaults to 'detailed'.

## Actor input object example

```json
{
  "mode": "watchlist",
  "symbols": [
    "BTC",
    "ETH",
    "SOL",
    "XRP",
    "DOGE"
  ],
  "topN": 100,
  "vsCurrency": "usd",
  "useBinanceFallback": true,
  "responseFormat": "detailed"
}
```

# Actor output Schema

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

Dataset of crypto market records. Each item is one unique coin with full price + market metadata. Use the 'Watchlist Overview' view for quick scans, 'ATH Analysis' to find dip opportunities, and 'Supply Metrics' for tokenomics research.

# 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": "watchlist",
    "symbols": [
        "BTC",
        "ETH",
        "SOL",
        "XRP",
        "DOGE"
    ],
    "topN": 100,
    "vsCurrency": "usd",
    "useBinanceFallback": true,
    "responseFormat": "detailed"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/crypto-price-tracker").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": "watchlist",
    "symbols": [
        "BTC",
        "ETH",
        "SOL",
        "XRP",
        "DOGE",
    ],
    "topN": 100,
    "vsCurrency": "usd",
    "useBinanceFallback": True,
    "responseFormat": "detailed",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/crypto-price-tracker").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": "watchlist",
  "symbols": [
    "BTC",
    "ETH",
    "SOL",
    "XRP",
    "DOGE"
  ],
  "topN": 100,
  "vsCurrency": "usd",
  "useBinanceFallback": true,
  "responseFormat": "detailed"
}' |
apify call khadinakbar/crypto-price-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crypto Price Tracker — Multi-Source Watchlist & Market API",
        "description": "Fetch real-time prices, market cap, 24h/7d/30d changes, ATH/ATL, supply, dominance, and computed analytics for a watchlist of coins (BTC, ETH, SOL...) or the top N by market cap. Multi-source: CoinGecko primary, Binance fallback. PPE: $0.003/coin.",
        "version": "1.0",
        "x-build-id": "W94j9RfHm9PgAHRHT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~crypto-price-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-crypto-price-tracker",
                "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/khadinakbar~crypto-price-tracker/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-crypto-price-tracker",
                "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/khadinakbar~crypto-price-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-crypto-price-tracker",
                "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": [
                            "watchlist",
                            "market"
                        ],
                        "type": "string",
                        "description": "Choose 'watchlist' to track a specific list of coins by symbol (e.g. BTC, ETH, SOL) or 'market' to sweep the top N coins by market cap. Watchlist is cheaper for targeted tracking; market is best for portfolio-style scans of the broader market. Defaults to 'watchlist'.",
                        "default": "watchlist"
                    },
                    "symbols": {
                        "title": "Watchlist Symbols",
                        "minItems": 0,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of coin tickers to fetch when mode='watchlist'. Case-insensitive (BTC, btc, Btc all work). Common tickers: BTC, ETH, SOL, USDC, USDT, XRP, BNB, ADA, DOGE, AVAX, LINK, MATIC, DOT, SHIB, LTC. Up to 100 symbols. Required when mode='watchlist'; ignored otherwise.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "topN": {
                        "title": "Top N Coins (Market Mode)",
                        "minimum": 10,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many coins to fetch when mode='market', sorted by market cap descending. Page size is 250 (CoinGecko max), so 250 returns 1 API call; 1000 returns 4 calls. Default 100. Hard max 1000. Ignored when mode='watchlist'.",
                        "default": 100
                    },
                    "vsCurrency": {
                        "title": "Quote Currency",
                        "enum": [
                            "usd",
                            "eur",
                            "gbp",
                            "jpy",
                            "cny",
                            "btc",
                            "eth"
                        ],
                        "type": "string",
                        "description": "Fiat or crypto to quote prices in. Most users want 'usd'. Other supported: eur, gbp, jpy, cny, btc, eth. ISO 4217 lowercase. Defaults to 'usd'.",
                        "default": "usd"
                    },
                    "useBinanceFallback": {
                        "title": "Use Binance Fallback",
                        "type": "boolean",
                        "description": "When true, supplements CoinGecko data with Binance public ticker for fresher 24h price action on USDT pairs. Adds resiliency if CoinGecko rate-limits. Adds ~0 cost (no extra event charged). Default true. Set false for CoinGecko-only output.",
                        "default": true
                    },
                    "responseFormat": {
                        "title": "Response Format",
                        "enum": [
                            "detailed",
                            "concise"
                        ],
                        "type": "string",
                        "description": "'detailed' returns all fields including ATH/ATL/supply/dominance (~300 tokens/item). 'concise' drops ATH/ATL/supply for compact agent output (~150 tokens/item). Use concise when feeding many coins into an LLM context. Defaults to 'detailed'.",
                        "default": "detailed"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
