# CoinGecko Scraper — Crypto Prices, Market Cap & API (`bovi/coingecko-scraper`) Actor

Scrape live cryptocurrency data from CoinGecko via the official public API. No API key required. Supports top-coins by market cap, bulk lookup by coin IDs, and search by keyword. Returns price, market cap, volume, ATH, circulating supply and more. Pay per result.

- **URL**: https://apify.com/bovi/coingecko-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 coin records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## CoinGecko Crypto Scraper — Live Prices, Market Cap & Coin Data | from $0.50/1K

Built for quant analysts, DeFi dashboards, and AI agents that need reliable, schema-stable crypto market data — without maintaining a CoinGecko Pro subscription ($129/mo).

**No API key required.** Official CoinGecko API — zero fragility. Pay only for results: from **$0.50 per 1,000 results** (Pay Per Event). `includeDetail=true` for description + website: $1.50/1,000.

Scrape live cryptocurrency data from CoinGecko via the official public API. No browser, no proxy, no auth required for the Demo tier. Pay only for results.

### What you get per coin

| Field | Description |
|---|---|
| `coin_id` | CoinGecko slug (e.g. `bitcoin`, `ethereum`) |
| `symbol` | Ticker symbol (uppercased: `BTC`, `ETH`) |
| `name` | Display name |
| `current_price_usd` | Live price in your chosen quote currency |
| `market_cap` | Market capitalization |
| `market_cap_rank` | Global rank by market cap |
| `total_volume` | 24h trading volume |
| `price_change_24h_pct` | 24h price change % |
| `circulating_supply` | Circulating supply of coins |
| `ath` | All-time high price |
| `ath_date` | Date of ATH (ISO 8601) |
| `last_updated` | When CoinGecko last updated this coin |
| `image_url` | Coin logo URL |
| `description` | Short description (first 500 chars) — when `includeDetail=true` |
| `website_url` | Official website — when `includeDetail=true` |
| `parse_confidence` | 0.0–1.0 data quality score |
| `warnings` | Machine-readable list of any data-quality issues |

### Modes

- **markets** — Top coins ranked by market cap (default). Returns the top N coins with all price data in a single efficient batch call. Use `order` to sort by volume, gecko score, etc.
- **coinIds** — Fetch specific coins by their CoinGecko ID (e.g. `bitcoin`, `ethereum`, `solana`). Use this when you have a known list of coins to track.
- **search** — Search CoinGecko by keyword. Returns up to 25 matching coin stubs per query. Use `includeDetail=true` to add full price data to each result.

### Input

```json
{
  "mode": "markets",
  "vsCurrency": "usd",
  "maxItems": 100,
  "order": "market_cap_desc"
}
````

```json
{
  "mode": "coinIds",
  "coinIds": ["bitcoin", "ethereum", "solana"],
  "vsCurrency": "eur"
}
```

```json
{
  "mode": "search",
  "searchQueries": ["defi", "layer 2"],
  "includeDetail": true
}
```

### Pricing example

Pay per result (PPE). Charged per coin record pushed:

| Fetch | Records | Cost |
|---|---|---|
| Top 10 coins by market cap | 10 | ~$0.005 |
| Top 100 coins | 100 | ~$0.05 |
| Top 1,000 coins | 1,000 | ~$0.50 |
| 50 coins with `includeDetail=true` | 50 base + 50 detail events | ~$0.10 |

### FAQ

**Do I need a CoinGecko API key or account?**
No. The free Demo API is used by default — no key, no sign-up. Provide a Pro key only if you need higher rate limits (>30 req/min).

**What formats can I export to?**
JSON, CSV, and Excel via the Apify dataset download or the REST API. The structured flat schema works directly in pandas, Google Sheets, or any BI tool.

**Can I schedule this to run automatically?**
Yes. Set up a schedule in Apify Console (e.g. every 5 minutes for a live price feed) or trigger via webhook from n8n / Make.

**What if it returns empty or partial results?**
Empty results mean the search query matched no coins or the API was temporarily rate-limited. The actor logs the reason and pushes nothing — you are not charged for empty runs. Check the `warnings` field and the actor's log for details.

### Rate limits & API key

The public CoinGecko Demo API is free with no API key, but rate-limited to ~30 requests/minute. The actor handles 429 responses with exponential backoff automatically.

For higher throughput, provide a CoinGecko Pro API key via the `apiKey` input (marked secret, not logged). The actor injects it as the `x-cg-pro-api-key` header.

### Competitor comparison

| Scraper | Data source | Price model | parse\_confidence | Notes |
|---|---|---|---|---|
| **This actor** | Official CoinGecko API | PPE $0.50/1K | yes | Stable schema, no proxy |
| coin-data-scraper (DOM) | HTML scraping | rental $15/mo | no | Breaks on redesigns |
| crypto-price-tracker (3rd-party API) | Unofficial endpoint | rental | no | ToS risk |

Official API = zero fragility. The data structure does not change without notice. DOM scrapers break whenever CoinGecko redesigns their website. Every record carries `parse_confidence` (0.0–1.0) — not just on error rows, but on every record — so downstream pipelines can filter low-quality data automatically.

### Integrations

Built for quant analysts and DeFi dashboard builders feeding live crypto prices and market-cap data into models — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Not affiliated with CoinGecko

This actor uses CoinGecko's publicly documented API. It is not affiliated with, endorsed by, or sponsored by CoinGecko or its parent company.

### Use with AI agents (MCP)

This actor is callable as a **tool by AI agents** (Claude Desktop, Cursor, VS Code, n8n, LangGraph, CrewAI, or any MCP-compatible client) via Apify's hosted Model Context Protocol server. An agent uses it to **look up live cryptocurrency prices, market caps, and market data mid-conversation** — e.g. "what is Bitcoin's price right now?", "show me the top 10 coins by market cap", or "get me price and volume for ETH and SOL".

Point your MCP client at this tool:

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

Minimal input an agent can send (keep `maxItems` low for fast, token-lean responses):

```json
{ "mode": "markets", "vsCurrency": "usd", "maxItems": 10 }
```

Fetch specific coins by slug:

```json
{ "mode": "coinIds", "coinIds": ["bitcoin", "ethereum", "solana"], "vsCurrency": "usd" }
```

Returns flat rows the agent can reason over directly:

```json
{ "coin_id": "bitcoin", "symbol": "BTC", "name": "Bitcoin",
  "current_price_usd": 67420.0, "market_cap": 1328000000000,
  "market_cap_rank": 1, "total_volume": 29500000000,
  "price_change_24h_pct": 2.14, "circulating_supply": 19700000,
  "ath": 73738.0, "last_updated": "2026-06-03T10:00:00.000Z",
  "parse_confidence": 1.0, "warnings": [] }
```

Reliability for agents: data comes from CoinGecko's **official public API** (not HTML scraping), so rows don't break on site redesigns. Every row includes `parse_confidence` (0.0–1.0) and a machine-readable `warnings` list for agent-side quality checks. The free Demo API tier (~30 req/min) is sufficient for most agent calls — no API key required inside the tool, only your Apify token in the client config above.

### Also in this finance family

- [Yahoo Finance Scraper](https://apify.com/bovi/yahoo-finance-scraper) — stocks, ETFs, crypto, indices, forex
- [Binance Scraper](https://apify.com/bovi/binance-scraper) — spot prices + OHLCV klines for 3,500+ pairs
- [Dexscreener Scraper](https://apify.com/bovi/dexscreener-scraper) — DEX pairs, on-chain token prices across 50+ chains
- [DefiLlama Scraper](https://apify.com/bovi/defillama-scraper) — DeFi protocol TVL + yield pool APY
- [ECB Exchange Rates Scraper](https://apify.com/bovi/exchange-rates-scraper) — historical FX rates back to 1999

# Actor input Schema

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

Fetch strategy. 'markets': top coins ranked by market cap — use this for broad market overviews or when you don't know the exact coin IDs. 'coinIds': fetch specific coins by their CoinGecko slug (bitcoin, ethereum, solana) — use this when you have a known list. 'search': find coins matching a keyword — use this when you have a coin name but not its slug.

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

Currency for prices and market caps. Default 'usd'. Other valid values: 'eur', 'gbp', 'jpy', 'btc', 'eth'. All numeric price fields are denominated in this currency.

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

Maximum coins in the output. For agents, keep this low (10–50) to avoid large responses. 0 = no limit (up to 250 per page for markets; 1000 for search). Default 100.

## `coinIds` (type: `array`):

List of CoinGecko coin slugs to fetch (only used when mode='coinIds'). Use lowercase slugs: 'bitcoin', 'ethereum', 'solana', 'cardano', 'dogecoin'. Example: \["bitcoin", "ethereum", "solana"].

## `searchQueries` (type: `array`):

Keywords to search for coins (only used when mode='search'). Each query returns up to 25 matching coin stubs from CoinGecko. Example: \["defi", "layer 2"]. Use includeDetail=true to add price data to search results.

## `order` (type: `string`):

How to sort results in markets mode. 'market\_cap\_desc' returns the largest coins first (default). 'volume\_desc' returns the most actively traded first. 'gecko\_desc' uses CoinGecko's own trending score.

## `includeDetail` (type: `boolean`):

When true, makes an extra API call per coin to add description and website\_url. Significantly slower and uses more API quota. Recommended: false (default) for agent calls — use true only when you specifically need descriptions or website links.

## `apiKey` (type: `string`):

Optional CoinGecko Pro API key (x-cg-pro-api-key header). Without a key, the free Demo API is used (~30 req/min, sufficient for most agent calls). Provide a Pro key for higher throughput or access to Pro-only endpoints.

## Actor input object example

```json
{
  "mode": "markets",
  "vsCurrency": "usd",
  "maxItems": 100,
  "coinIds": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "searchQueries": [
    "defi",
    "layer 2"
  ],
  "order": "market_cap_desc",
  "includeDetail": false
}
```

# 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": "markets",
    "vsCurrency": "usd",
    "maxItems": 100,
    "coinIds": [
        "bitcoin",
        "ethereum",
        "solana"
    ],
    "searchQueries": [
        "defi",
        "layer 2"
    ],
    "order": "market_cap_desc",
    "includeDetail": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/coingecko-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": "markets",
    "vsCurrency": "usd",
    "maxItems": 100,
    "coinIds": [
        "bitcoin",
        "ethereum",
        "solana",
    ],
    "searchQueries": [
        "defi",
        "layer 2",
    ],
    "order": "market_cap_desc",
    "includeDetail": False,
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/coingecko-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": "markets",
  "vsCurrency": "usd",
  "maxItems": 100,
  "coinIds": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "searchQueries": [
    "defi",
    "layer 2"
  ],
  "order": "market_cap_desc",
  "includeDetail": false
}' |
apify call bovi/coingecko-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinGecko Scraper — Crypto Prices, Market Cap & API",
        "description": "Scrape live cryptocurrency data from CoinGecko via the official public API. No API key required. Supports top-coins by market cap, bulk lookup by coin IDs, and search by keyword. Returns price, market cap, volume, ATH, circulating supply and more. Pay per result.",
        "version": "0.1",
        "x-build-id": "fiCxe2WHRh5ncV5nb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~coingecko-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-coingecko-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/bovi~coingecko-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-coingecko-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/bovi~coingecko-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-coingecko-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": "Mode",
                        "enum": [
                            "markets",
                            "coinIds",
                            "search"
                        ],
                        "type": "string",
                        "description": "Fetch strategy. 'markets': top coins ranked by market cap — use this for broad market overviews or when you don't know the exact coin IDs. 'coinIds': fetch specific coins by their CoinGecko slug (bitcoin, ethereum, solana) — use this when you have a known list. 'search': find coins matching a keyword — use this when you have a coin name but not its slug."
                    },
                    "vsCurrency": {
                        "title": "Quote currency",
                        "type": "string",
                        "description": "Currency for prices and market caps. Default 'usd'. Other valid values: 'eur', 'gbp', 'jpy', 'btc', 'eth'. All numeric price fields are denominated in this currency.",
                        "default": "usd"
                    },
                    "maxItems": {
                        "title": "Max coins to return",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum coins in the output. For agents, keep this low (10–50) to avoid large responses. 0 = no limit (up to 250 per page for markets; 1000 for search). Default 100.",
                        "default": 100
                    },
                    "coinIds": {
                        "title": "Coin IDs (for mode=coinIds)",
                        "type": "array",
                        "description": "List of CoinGecko coin slugs to fetch (only used when mode='coinIds'). Use lowercase slugs: 'bitcoin', 'ethereum', 'solana', 'cardano', 'dogecoin'. Example: [\"bitcoin\", \"ethereum\", \"solana\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries (for mode=search)",
                        "type": "array",
                        "description": "Keywords to search for coins (only used when mode='search'). Each query returns up to 25 matching coin stubs from CoinGecko. Example: [\"defi\", \"layer 2\"]. Use includeDetail=true to add price data to search results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "order": {
                        "title": "Market sort order (for mode=markets)",
                        "enum": [
                            "market_cap_desc",
                            "market_cap_asc",
                            "volume_desc",
                            "volume_asc",
                            "gecko_desc",
                            "gecko_asc",
                            "id_asc",
                            "id_desc"
                        ],
                        "type": "string",
                        "description": "How to sort results in markets mode. 'market_cap_desc' returns the largest coins first (default). 'volume_desc' returns the most actively traded first. 'gecko_desc' uses CoinGecko's own trending score.",
                        "default": "market_cap_desc"
                    },
                    "includeDetail": {
                        "title": "Fetch full coin detail",
                        "type": "boolean",
                        "description": "When true, makes an extra API call per coin to add description and website_url. Significantly slower and uses more API quota. Recommended: false (default) for agent calls — use true only when you specifically need descriptions or website links.",
                        "default": false
                    },
                    "apiKey": {
                        "title": "CoinGecko Pro API key (optional)",
                        "type": "string",
                        "description": "Optional CoinGecko Pro API key (x-cg-pro-api-key header). Without a key, the free Demo API is used (~30 req/min, sufficient for most agent calls). Provide a Pro key for higher throughput or access to Pro-only endpoints."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
