# CoinMarketCap Crypto Prices & Market Data Scraper (`parseforge/coinmarketcap-scraper`) Actor

Scrape real-time prices, market caps, volumes, supply, and 24h/7d/30d changes for 10,000+ cryptocurrencies from CoinMarketCap. No API key required.

- **URL**: https://apify.com/parseforge/coinmarketcap-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.25 / 1,000 result items

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

## 🪙 CoinMarketCap Scraper

> 🚀 **Export live crypto market data in seconds.** Pull prices, market caps, volumes, supply data and dominance rankings for 8,400+ cryptocurrencies - no API key required.

> 🕒 **Last updated:** 2026-05-21 · **📊 19 fields** per record · **8,400+ coins** · **Global coverage**

The CoinMarketCap Scraper extracts real-time cryptocurrency data directly from CoinMarketCap's live data feed - the world's most-referenced crypto market data platform. Every record includes price, market cap, 24h volume, percent changes across multiple timeframes, supply data, and market dominance, all structured and ready to download as CSV, JSON, Excel, or XML.

Data is sourced from CoinMarketCap's public data layer and reflects live market conditions updated every minute. No CoinMarketCap API key required.

**Coverage:** 8,400+ cryptocurrencies across all categories - coins, tokens, DeFi protocols, NFT assets, stablecoins, and metaverse tokens. Supports sorting by market cap, price, volume, percent change, and more. Filterable by crypto type. Prices convertible to any major currency.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Crypto traders and investors | Portfolio tracking and price monitoring |
| Quantitative analysts | Backtesting, signal generation, market analysis |
| DeFi researchers | Protocol TVL and token performance research |
| Financial data teams | Building crypto dashboards and data pipelines |
| Journalists and media | Real-time market reporting and trend coverage |
| Academic researchers | Cryptocurrency market studies and datasets |

### 📋 What the CoinMarketCap Scraper does

- Fetches live cryptocurrency listings sorted by market cap, price, volume, or percent change
- Filters by crypto category: all, coins, tokens, DeFi, NFT, stablecoin, or metaverse
- Extracts 19 structured fields per record including price, market cap, supply data, and dominance
- Converts prices to any supported currency (USD, BTC, ETH, and more)
- Supports pagination to collect any number of coins up to 8,400+
- Outputs image URLs for every coin's logo

> 💡 **Why it matters:** CoinMarketCap is the most-visited crypto data source in the world. Getting structured, machine-readable data from it unlocks trading signals, market monitoring, research, and automation - without screen-scraping fragile HTML.

### 🎬 Full Demo

_🚧 Coming soon_

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | Integer | 10 | Maximum number of records to return (1-1,000,000) |
| `sortBy` | Select | `market_cap` | Sort field: market_cap, rank, price, volume_24h, percent_change_24h, etc. |
| `sortOrder` | Select | `desc` | Sort direction: descending or ascending |
| `cryptoType` | Select | `all` | Category filter: all, coins, tokens, defi, nft, stablecoin, metaverse |
| `convertCurrency` | Text | `USD` | Currency for prices (USD, BTC, ETH, etc.) |

**Example - Top 100 by market cap:**
```json
{
  "maxItems": 100,
  "sortBy": "market_cap",
  "sortOrder": "desc",
  "cryptoType": "all",
  "convertCurrency": "USD"
}
````

**Example - Top 50 DeFi tokens by 24h volume:**

```json
{
  "maxItems": 50,
  "sortBy": "volume_24h",
  "sortOrder": "desc",
  "cryptoType": "defi",
  "convertCurrency": "USD"
}
```

> ⚠️ **Good to Know:** Free users are automatically limited to 10 records. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock more. Paid users can retrieve up to 1,000,000 items. Prices reflect live market data updated approximately every minute.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | String | URL to the coin's 64x64 logo image |
| 📛 `name` | String | Full cryptocurrency name |
| 🔤 `symbol` | String | Ticker symbol (BTC, ETH, etc.) |
| 🔗 `slug` | String | URL slug identifier |
| 🌐 `url` | String | Link to CoinMarketCap detail page |
| 🏆 `rank` | Integer | CoinMarketCap rank by market cap |
| 💵 `price` | Number | Current price in selected currency |
| 📊 `marketCap` | Number | Total market capitalization |
| 📈 `volume24h` | Number | 24-hour trading volume |
| ⏱️ `percentChange1h` | Number | Price % change over last 1 hour |
| 📅 `percentChange24h` | Number | Price % change over last 24 hours |
| 📆 `percentChange7d` | Number | Price % change over last 7 days |
| 🔄 `circulatingSupply` | Number | Coins currently in circulation |
| 💰 `totalSupply` | Number | Total coins created |
| 🔒 `maxSupply` | Number | Maximum possible supply (null if infinite) |
| 💹 `fullyDilutedMarketCap` | Number | Market cap if all coins were in circulation |
| 🥧 `dominance` | Number | % share of total crypto market cap |
| 🏷️ `category` | String | Primary category tag (layer-1, defi, stablecoin, etc.) |
| 🕐 `scrapedAt` | String | ISO timestamp when the record was collected |
| ❌ `error` | String/null | Error message if extraction failed (null on success) |

**Sample records (real data from cloud run):**

```json
[
  {
    "imageUrl": "https://s2.coinmarketcap.com/static/img/coins/64x64/1.png",
    "name": "Bitcoin",
    "symbol": "BTC",
    "slug": "bitcoin",
    "url": "https://coinmarketcap.com/currencies/bitcoin/",
    "rank": 1,
    "price": 77376.26518033707,
    "marketCap": 1550045525939.9302,
    "volume24h": 26749415961.828968,
    "percentChange1h": -0.34135762,
    "percentChange24h": -0.35996603,
    "percentChange7d": -4.86124807,
    "circulatingSupply": 20032571,
    "totalSupply": 20032571,
    "maxSupply": 21000000,
    "fullyDilutedMarketCap": 1624901568787.08,
    "dominance": 59.9382,
    "category": "layer-1",
    "scrapedAt": "2026-05-22T00:46:05.049Z",
    "error": null
  },
  {
    "imageUrl": "https://s2.coinmarketcap.com/static/img/coins/64x64/1027.png",
    "name": "Ethereum",
    "symbol": "ETH",
    "slug": "ethereum",
    "url": "https://coinmarketcap.com/currencies/ethereum/",
    "rank": 2,
    "price": 2129.3392498721187,
    "marketCap": 256980624365.22137,
    "volume24h": 14229538906.013819,
    "percentChange1h": -0.21997766,
    "percentChange24h": -0.2447157,
    "percentChange7d": -6.895643,
    "circulatingSupply": 120685618.49909769,
    "totalSupply": 120685618.49909769,
    "maxSupply": null,
    "fullyDilutedMarketCap": 256980624365.22,
    "dominance": 9.9371,
    "category": "layer-1",
    "scrapedAt": "2026-05-22T00:46:05.049Z",
    "error": null
  },
  {
    "imageUrl": "https://s2.coinmarketcap.com/static/img/coins/64x64/825.png",
    "name": "Tether USDt",
    "symbol": "USDT",
    "slug": "tether",
    "url": "https://coinmarketcap.com/currencies/tether/",
    "rank": 3,
    "price": 0.9991249750705524,
    "marketCap": 189686733785.81485,
    "volume24h": 67129213284.08087,
    "percentChange1h": 0.00324619,
    "percentChange24h": 0.01052668,
    "percentChange7d": -0.06660311,
    "circulatingSupply": 189852859771.04144,
    "totalSupply": 193191351061.2063,
    "maxSupply": null,
    "fullyDilutedMarketCap": 193022303812.87,
    "dominance": 7.3349,
    "category": "stablecoin",
    "scrapedAt": "2026-05-22T00:46:05.049Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| No API key required | Works immediately, no CoinMarketCap account needed |
| Real-time data | Prices updated every ~60 seconds from CoinMarketCap's live feed |
| 8,400+ coins | Full market coverage, not just top-100 |
| Category filtering | Isolate DeFi, NFTs, stablecoins, or metaverse tokens instantly |
| 19 structured fields | Everything from price to dominance and logo URLs in one record |
| Multi-currency support | Convert prices to USD, BTC, ETH, or any supported currency |
| Flexible sorting | Sort by market cap, price, volume, or percent change |
| Image URLs included | Ready for dashboards and visual applications |

### 📈 How it compares to alternatives

| | This Actor | CoinMarketCap API (Pro) | Manual export | Other scrapers |
|---|---|---|---|---|
| Price | Free (10 items) / Pay-per-use | $79-$699/mo | Manual only | Variable |
| Setup time | 30 seconds | Days (approval required) | N/A | Variable |
| Records per run | Up to 1,000,000 | 300-10,000/call (plan dependent) | Limited by UI | Variable |
| Real-time data | Yes | Yes | No | Often stale |
| Category filter | Yes | Yes | No | Rarely |
| CSV/JSON/Excel | Yes (auto) | Manual | Manual | Sometimes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the CoinMarketCap Scraper actor page
3. Set your desired `maxItems`, `sortBy`, `cryptoType`, and `convertCurrency`
4. Click **Save & Run**
5. Download results as JSON, CSV, Excel, or XML from the dataset tab

### 💼 Business use cases

#### Trading and Investment Research

Build automated watchlists, track percent changes across your portfolio, and generate alerts when coins cross price or volume thresholds. Combine with scheduling to run every hour for real-time monitoring.

#### Market Intelligence Dashboards

Feed live coin data into Tableau, Power BI, Google Sheets, or custom dashboards. The structured 19-field output is ready for visualization - no data cleaning required.

#### DeFi and NFT Analytics

Filter to `cryptoType: defi` or `cryptoType: nft` to build sector-specific reports. Track TVL-adjacent metrics, dominance shifts, and volume trends within specific sub-markets.

#### Academic and Journalistic Research

Pull historical snapshots for research papers, news articles, or regulatory filings. Export directly to Excel for analysis. Run repeatedly to build a time-series dataset of market conditions.

### 🔌 Automating CoinMarketCap Scraper

**Make (Integromat):** Connect to Google Sheets, Slack, or any 1,000+ apps. Schedule the actor, then pipe new records into a spreadsheet row or send a Slack alert when BTC drops below a threshold.

**Zapier:** Trigger downstream workflows on every new dataset run. Email reports, update Notion databases, or post to Telegram channels - all without code.

**Apify Scheduler:** Use the built-in scheduler to run the actor every hour, day, or week and always have fresh crypto data on hand.

**REST API:** Call the Apify API directly to trigger runs and retrieve dataset items programmatically from any language or platform.

### 🌟 Beyond business use cases

#### Academic Research

Track market microstructure, liquidity, and volatility patterns across crypto categories. Build longitudinal datasets by scheduling repeated runs.

#### Creative Projects

Visualize crypto market landscapes with treemaps or network graphs using the dominance and category fields. Build art installations driven by live BTC price data.

#### Non-profit and Open Data

Publish structured crypto market snapshots as open datasets for researchers and journalists who lack API access.

#### Personal Experimentation

Build a personal crypto tracker, backtest simple trading strategies with historical snapshots, or learn data engineering with a real-world dataset.

### 🤖 Ask an AI assistant about this scraper

> "I have a JSON dataset from the CoinMarketCap Scraper with fields: imageUrl, name, symbol, slug, url, rank, price, marketCap, volume24h, percentChange1h, percentChange24h, percentChange7d, circulatingSupply, totalSupply, maxSupply, fullyDilutedMarketCap, dominance, category, scrapedAt. How do I find all DeFi tokens with positive 7-day returns sorted by market cap?"

Paste the above into ChatGPT, Claude, or any AI assistant to get instant help analyzing your dataset.

### ❓ Frequently Asked Questions

**Does this require a CoinMarketCap API key?**
No. This actor uses CoinMarketCap's public data feed and requires no API key or account.

**How current is the data?**
CoinMarketCap updates prices approximately every 60 seconds. The actor fetches live data at run time.

**How many coins can I retrieve?**
Paid users can retrieve up to 1,000,000 records. CoinMarketCap tracks approximately 8,400 active coins. Free users are limited to 10 records.

**Can I filter by category?**
Yes. Use the `cryptoType` input to filter by: all, coins, tokens, defi, nft, stablecoin, or metaverse.

**What currencies are supported?**
The `convertCurrency` field accepts USD, BTC, ETH, and other currencies supported by CoinMarketCap's API.

**Why is `maxSupply` null for some coins?**
Coins like Ethereum have no hard cap, so `maxSupply` is null. Bitcoin's max supply is 21,000,000.

**Can I sort by percent change?**
Yes. Set `sortBy` to `percent_change_1h`, `percent_change_24h`, or `percent_change_7d`.

**How often should I run this for real-time tracking?**
For price monitoring, schedule runs every 5-15 minutes. For daily market reports, once per day is sufficient.

**What does the `dominance` field represent?**
Dominance is the coin's percentage share of the total cryptocurrency market capitalization. Bitcoin dominance of 59.9% means BTC represents 59.9% of all crypto market cap.

**Can I use this for automated trading signals?**
Yes. Many users combine this actor with Make or Zapier to trigger alerts when a coin's price or percent change crosses a threshold.

**What is the `category` field?**
It's derived from the coin's primary tag on CoinMarketCap (e.g., layer-1, stablecoin, defi, nft). Some coins may show other tags if no category tag is present.

**Are historical prices available?**
This actor returns current live prices. For historical data, consider scheduling repeated runs to build your own time series.

### 🔌 Integrate with any app

Export data directly to: Google Sheets, Excel, CSV, JSON, XML, Airtable, Notion, Slack, Make, Zapier, Power BI, Tableau, BigQuery, PostgreSQL, MongoDB, S3, and any app with a REST API or webhook.

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database - 28 fields per airport, 74,000+ records |
| [CoinGecko Scraper](https://apify.com/parseforge) | Alternative crypto market data source |
| [Stock Market Scraper](https://apify.com/parseforge) | Public equity market data and financials |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data tools across finance, real estate, travel, and more.

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

> **Disclaimer:** This is an independent tool and is not affiliated with, endorsed by, or connected to CoinMarketCap or its parent company Binance. Only publicly available data is collected. Use responsibly and in accordance with CoinMarketCap's terms of service.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `sortBy` (type: `string`):

Field to sort results by.

## `sortOrder` (type: `string`):

Sort direction.

## `cryptoType` (type: `string`):

Filter by cryptocurrency category.

## `convertCurrency` (type: `string`):

Currency to convert prices to (e.g. USD, BTC, ETH).

## Actor input object example

```json
{
  "maxItems": 10,
  "sortBy": "market_cap",
  "sortOrder": "desc",
  "cryptoType": "all",
  "convertCurrency": "USD"
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 10,
    "sortBy": "market_cap",
    "sortOrder": "desc",
    "cryptoType": "all",
    "convertCurrency": "USD"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "sortBy": "market_cap",
    "sortOrder": "desc",
    "cryptoType": "all",
    "convertCurrency": "USD",
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "sortBy": "market_cap",
  "sortOrder": "desc",
  "cryptoType": "all",
  "convertCurrency": "USD"
}' |
apify call parseforge/coinmarketcap-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinMarketCap Crypto Prices & Market Data Scraper",
        "description": "Scrape real-time prices, market caps, volumes, supply, and 24h/7d/30d changes for 10,000+ cryptocurrencies from CoinMarketCap. No API key required.",
        "version": "0.1",
        "x-build-id": "c1XAvt6vaapZ8oZlK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~coinmarketcap-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-coinmarketcap-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~coinmarketcap-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-coinmarketcap-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~coinmarketcap-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-coinmarketcap-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "market_cap",
                            "rank",
                            "name",
                            "symbol",
                            "price",
                            "volume_24h",
                            "percent_change_1h",
                            "percent_change_24h",
                            "percent_change_7d"
                        ],
                        "type": "string",
                        "description": "Field to sort results by.",
                        "default": "market_cap"
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Sort direction.",
                        "default": "desc"
                    },
                    "cryptoType": {
                        "title": "Cryptocurrency Type",
                        "enum": [
                            "all",
                            "coins",
                            "tokens",
                            "defi",
                            "nft",
                            "stablecoin",
                            "metaverse"
                        ],
                        "type": "string",
                        "description": "Filter by cryptocurrency category.",
                        "default": "all"
                    },
                    "convertCurrency": {
                        "title": "Convert Currency",
                        "type": "string",
                        "description": "Currency to convert prices to (e.g. USD, BTC, ETH).",
                        "default": "USD"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
