# CoinMarketCap Crypto Prices Scraper (`fetch_cat/coinmarketcap-crypto-prices-scraper`) Actor

Scrape public CoinMarketCap cryptocurrency prices, ranks, market caps, volumes, supply metrics, links, and descriptions.

- **URL**: https://apify.com/fetch\_cat/coinmarketcap-crypto-prices-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 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.
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

## CoinMarketCap Crypto Prices Scraper

Scrape public CoinMarketCap cryptocurrency price and market data from ranking pages or specific coin profiles.

Use this Actor to export crypto prices, ranks, market caps, volume, supply metrics, profile URLs, descriptions, official links, explorer links, source-code links, and tags when CoinMarketCap exposes them in public page data.

### At a glance

- **Best for:** Crypto market snapshots, coin profile enrichment, dashboard feeds, newsletter research, and API data exports.
- **Inputs:** CoinMarketCap URLs, coin slugs or symbols, maximum records, description option, official-link option, and proxy settings.
- **Outputs:** One row per saved coin record with price, rank, market cap, volume, supply metrics, links, tags, and scrape timestamp.
- **Access:** Public CoinMarketCap pages only. No login, cookies, private portfolio data, or paid API access.
- **Cost:** `$0.005` per run plus the `item` event for each saved coin record.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Scrape a custom crypto portfolio watchlist](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper/examples/custom-portfolio-watchlist)**
- **[Track Shiba Inu CoinMarketCap data](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper/examples/shiba-inu-market-tracker)**
- **[Scrape USDC stablecoin market data](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper/examples/usdc-stablecoin-market-data)**
- **[Export Dai stablecoin profile data](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper/examples/dai-stablecoin-profile-data)**
- **[Scrape Optimism token price profile](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper/examples/optimism-token-price-profile)**
- **[Export Arbitrum market data](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper/examples/arbitrum-market-data-export)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/coinmarketcap-crypto-prices-scraper/examples)** (50 examples)

### What can it do?

- **Export CoinMarketCap ranking data:** collect public price, rank, market-cap, volume, and supply metrics from ranking pages.
- **Enrich specific coins:** pass slugs or symbols such as `bitcoin`, `ethereum`, or `SOL` to get focused coin profile records.
- **Collect public coin links:** save official websites, explorer links, source-code links, and tags when CoinMarketCap exposes them.
- **Build repeatable crypto snapshots:** schedule the same inputs and compare saved rows over time.
- **Use as a page-data API alternative:** run from Apify API, export CSV/Excel/JSON, or connect the Actor to an AI agent through Apify MCP.

### Input example

```json
{
  "slugs": ["bitcoin", "ethereum", "solana"],
  "maxItems": 3,
  "includeDescription": true,
  "includeOfficialLinks": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Output example

```json
{
  "url": "https://coinmarketcap.com/currencies/bitcoin/",
  "coinId": 1,
  "slug": "bitcoin",
  "name": "Bitcoin",
  "symbol": "BTC",
  "rank": 1,
  "price": 65000.12,
  "marketCap": 1280000000000,
  "volume24h": 32000000000,
  "circulatingSupply": 19700000,
  "totalSupply": 19700000,
  "maxSupply": 21000000,
  "percentChange1h": 0.1,
  "percentChange24h": -1.2,
  "percentChange7d": 4.5,
  "lastUpdated": "2026-07-03T10:00:00.000Z",
  "dateAdded": "2010-07-13T00:00:00.000Z",
  "ath": 73750.07,
  "atl": 0.04865,
  "high24h": 66000.0,
  "low24h": 64000.0,
  "marketPairCount": 12000,
  "profileDescription": "Bitcoin is a decentralized cryptocurrency...",
  "officialLinks": ["https://bitcoin.org/"],
  "explorerLinks": ["https://blockchain.info/"],
  "sourceCodeLinks": ["https://github.com/bitcoin/bitcoin"],
  "tags": ["mineable", "pow"],
  "scrapedAt": "2026-07-03T10:00:05.000Z"
}
```

### Input configuration

| Setting | JSON key | What it does |
| --- | --- | --- |
| Start URLs | `startUrls` | CoinMarketCap homepage/ranking URLs or coin profile URLs. |
| Coin slugs or symbols | `slugs` | CoinMarketCap slugs or common symbols, such as `bitcoin`, `ethereum`, `BTC`, or `ETH`. |
| Maximum coin records | `maxItems` | Caps saved coin records. The Actor enforces a maximum of 1,000. |
| Include descriptions | `includeDescription` | Saves profile descriptions when available in public page data. |
| Include official links | `includeOfficialLinks` | Saves websites, explorers, and source-code links when CoinMarketCap exposes them. |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy or custom proxy settings for throttled runs. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `url` | string | CoinMarketCap currency profile URL. |
| `coinId` | integer or null | CoinMarketCap internal ID when available. |
| `slug` | string | CoinMarketCap currency slug. |
| `name` | string | Cryptocurrency name. |
| `symbol` | string | Ticker symbol. |
| `rank` | integer or null | CoinMarketCap rank. |
| `price` | number or null | Latest USD price available in page data. |
| `marketCap` | number or null | USD market capitalization. |
| `volume24h` | number or null | Reported 24-hour volume. |
| `circulatingSupply` | number or null | Circulating supply. |
| `totalSupply` | number or null | Total supply. |
| `maxSupply` | number or null | Maximum supply when available. |
| `percentChange1h` | number or null | One-hour price change percentage. |
| `percentChange24h` | number or null | Twenty-four-hour price change percentage. |
| `percentChange7d` | number or null | Seven-day price change percentage. |
| `lastUpdated` | string or null | Quote update timestamp from CoinMarketCap. |
| `dateAdded` | string or null | CoinMarketCap date-added value. |
| `ath`, `atl` | number or null | All-time high and low values when present. |
| `high24h`, `low24h` | number or null | Twenty-four-hour high and low values when present. |
| `marketPairCount` | integer or null | Market-pair count when available. |
| `profileDescription` | string or null | Profile description when available and enabled. |
| `officialLinks` | array | Official website links. |
| `explorerLinks` | array | Blockchain explorer links. |
| `sourceCodeLinks` | array | Source-code repository links. |
| `tags` | array | CoinMarketCap tags. |
| `scrapedAt` | string | ISO timestamp when the row was saved. |

### Pricing

| Charge event | Exact price | Charged when |
| --- | ---: | --- |
| `start` | `$0.005` | Once when the run starts. |
| `item` | `$0.0001` at BRONZE tier | For each cryptocurrency record saved to the dataset. |

At the BRONZE tier, the saved-record charge is `$0.10` per 1,000 saved coin records, plus the run start fee. The code saves the record and then charges the `item` event.

### Common workflows

- **Market snapshot export:** Pull the current ranking page into a dashboard or spreadsheet.
- **Coin profile enrichment:** Enrich symbols or slugs with profile URLs, descriptions, tags, and official links.
- **Newsletter research:** Export price, rank, percent-change, and volume fields for editorial planning.
- **API alternative:** Use Apify API or datasets when you need public CoinMarketCap page data in JSON, CSV, Excel, or API form.

### Tips

- **Use slugs for exact coins:** `bitcoin`, `ethereum`, and `solana` are more precise than relying only on ranking pages.
- **Disable extras for speed:** Turn off descriptions and official links for lightweight market snapshots.
- **Keep first runs small:** Use `maxItems: 25` before scaling ranking-page exports.
- **Use proxy only when needed:** Small runs often work without proxy; enable Apify Proxy if CoinMarketCap throttles a run.

### Limits and caveats

- **Public page data only:** This is not the official CoinMarketCap API and does not access private or paid API data.
- **Fields can be null:** CoinMarketCap does not expose every metric on every page or in every embedded record.
- **Ranking pages and profile pages differ:** Descriptions and official links are most reliable on profile pages.
- **Prices can change quickly:** Treat output as a snapshot taken when the run scraped the page.

### API usage

Run through the Apify API with the same JSON keys as the input schema:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~coinmarketcap-crypto-prices-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"slugs":["bitcoin","ethereum"],"maxItems":2,"includeDescription":true,"includeOfficialLinks":true}'
```

### MCP and AI agents

For AI agents, use the official Apify MCP server. A focused single-Actor server URL is:

```text
https://mcp.apify.com?tools=fetch_cat/coinmarketcap-crypto-prices-scraper
```

Example agent prompt: "Run CoinMarketCap Crypto Prices Scraper for bitcoin and ethereum, then summarize price, rank, market cap, 24-hour volume, and official links."

### FAQ

**Can I export CoinMarketCap data to CSV or Excel?**
Yes. Apify datasets can be downloaded as CSV, Excel, JSON, JSONL, XML, RSS, or accessed through the API.

**Does it require CoinMarketCap API credentials?**
No. It reads public CoinMarketCap pages and does not use the official CoinMarketCap API.

**Why are descriptions or links empty?**
Those fields depend on profile-page data and the `includeDescription` / `includeOfficialLinks` settings.

**Can I schedule crypto price monitoring?**
Yes. Use an Apify schedule with a small `maxItems` value or a fixed slug list for repeatable snapshots.

**Is this real-time market data?**
No. It is a scrape-time snapshot of public page data. For trading or compliance-critical use, verify against authoritative market feeds.

### Related actors

- [Yahoo Finance Stock Data Scraper](https://apify.com/fetch_cat/yahoo-finance-stock-data-scraper)
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper)
- [Google Trending Searches Scraper](https://apify.com/fetch_cat/google-trending-searches-scraper)
- [RSS Feed Reader](https://apify.com/fetch_cat/rss-feed-reader)

### Changelog

#### 0.1

- Initial public release with ranking-page and coin-profile inputs, optional descriptions, optional official links, pricing events, and dataset schema.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

# Actor input Schema

## `startUrls` (type: `array`):

CoinMarketCap homepage/ranking URLs or coin profile URLs such as https://coinmarketcap.com/currencies/bitcoin/.

## `slugs` (type: `array`):

Optional CoinMarketCap slugs or common symbols, for example bitcoin, ethereum, BTC, ETH. These are converted to coin profile URLs.

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

Maximum number of cryptocurrency records to save.

## `includeDescription` (type: `boolean`):

Include CoinMarketCap profile descriptions when available on coin detail pages.

## `includeOfficialLinks` (type: `boolean`):

Include websites, explorers, and source-code links when CoinMarketCap exposes them.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. The actor works without proxies for many small runs; enable Apify Proxy if your run is throttled.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://coinmarketcap.com/"
    },
    {
      "url": "https://coinmarketcap.com/currencies/bitcoin/"
    }
  ],
  "slugs": [
    "bitcoin",
    "ethereum"
  ],
  "maxItems": 20,
  "includeDescription": true,
  "includeOfficialLinks": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://coinmarketcap.com/"
        },
        {
            "url": "https://coinmarketcap.com/currencies/bitcoin/"
        }
    ],
    "slugs": [
        "bitcoin",
        "ethereum"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/coinmarketcap-crypto-prices-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 = {
    "startUrls": [
        { "url": "https://coinmarketcap.com/" },
        { "url": "https://coinmarketcap.com/currencies/bitcoin/" },
    ],
    "slugs": [
        "bitcoin",
        "ethereum",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/coinmarketcap-crypto-prices-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 '{
  "startUrls": [
    {
      "url": "https://coinmarketcap.com/"
    },
    {
      "url": "https://coinmarketcap.com/currencies/bitcoin/"
    }
  ],
  "slugs": [
    "bitcoin",
    "ethereum"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/coinmarketcap-crypto-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinMarketCap Crypto Prices Scraper",
        "description": "Scrape public CoinMarketCap cryptocurrency prices, ranks, market caps, volumes, supply metrics, links, and descriptions.",
        "version": "0.1",
        "x-build-id": "CIm8S3xakmeX0OTMX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~coinmarketcap-crypto-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-coinmarketcap-crypto-prices-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/fetch_cat~coinmarketcap-crypto-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-coinmarketcap-crypto-prices-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/fetch_cat~coinmarketcap-crypto-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-coinmarketcap-crypto-prices-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "CoinMarketCap homepage/ranking URLs or coin profile URLs such as https://coinmarketcap.com/currencies/bitcoin/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "slugs": {
                        "title": "Coin slugs or symbols",
                        "type": "array",
                        "description": "Optional CoinMarketCap slugs or common symbols, for example bitcoin, ethereum, BTC, ETH. These are converted to coin profile URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum coin records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of cryptocurrency records to save.",
                        "default": 20
                    },
                    "includeDescription": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Include CoinMarketCap profile descriptions when available on coin detail pages.",
                        "default": true
                    },
                    "includeOfficialLinks": {
                        "title": "Include official links",
                        "type": "boolean",
                        "description": "Include websites, explorers, and source-code links when CoinMarketCap exposes them.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. The actor works without proxies for many small runs; enable Apify Proxy if your run is throttled."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
