# CoinMarketCap Scraper - Crypto Prices, Market Cap & Exchanges (`scrapesage/coinmarketcap-scraper`) Actor

Scrape CoinMarketCap data: live prices, market cap & rank, 24h volume, 1h–1y change, supply, ATH/ATL, full coin profiles, historical OHLCV, exchanges, market pairs, trending/gainers/losers and the Fear & Greed index. Keyless, no browser. Monitoring mode. JSON, CSV, Excel.

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

## Pricing

from $2.00 / 1,000 coin / price 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

## CoinMarketCap Scraper — Crypto Prices, Market Cap, Exchanges & Fear & Greed

Extract **complete CoinMarketCap data** — live prices, market cap & CMC rank, 24h volume, 1h-to-1y price changes, circulating/total/max supply, ATH/ATL, full project profiles, historical OHLCV candles, exchanges, market pairs, trending/gainers/losers and the **Crypto Fear & Greed Index** — all from CoinMarketCap's own web back-end.

**No API key, no login, no browser** — fast JSON extraction straight from `coinmarketcap.com`'s data API, with a built-in **monitoring mode** for price & rank alerts.

### Why this CoinMarketCap scraper?

Most crypto scrapers return a thin price row and nothing else. This actor ships the **richest dataset in the category** — every field CoinMarketCap shows, plus enrichment and change-tracking other scrapers skip:

| Data | Typical scrapers | This actor |
|---|---|---|
| Live price, market cap, CMC rank | ✅ | ✅ |
| 1h / 24h / 7d / 30d / 60d / 90d / 1y % change | partial | ✅ all |
| Circulating / total / max supply + dominance | partial | ✅ |
| ATH / ATL with dates + % from ATH | ❌ | ✅ |
| Full project profile (description, contracts, links, audits) | ❌ | ✅ opt-in |
| Historical OHLCV candles (open/high/low/close/volume/mcap) | ❌ | ✅ |
| Exchanges (volume, score, fees, fiats, on/off-ramps) | ❌ | ✅ |
| Market pairs per coin (price, volume, liquidity, depth) | ❌ | ✅ |
| Trending / gainers / losers / most-searched | ❌ | ✅ |
| Crypto Fear & Greed Index + history | ❌ | ✅ |
| Global market overview (BTC dominance, DeFi, gas) | ❌ | ✅ |
| Price / rank / volume **change monitoring** | ❌ | ✅ |
| Quote in any of 25+ fiat/crypto currencies | partial | ✅ |

### Use cases

- **Portfolio & price dashboards** — pull live prices, market caps and 1h–1y changes for any set of coins in your chosen currency, on a schedule.
- **Price & rank alerts** — turn on monitoring mode to capture only coins whose price, rank or volume changed since the last run — perfect for Slack/email alerts and trading triggers.
- **New-listing & meme hunting** — sort by date added, or use the Spotlight mode (trending, gainers, recently added, most searched) to spot momentum early.
- **Backtesting & research** — export historical OHLCV candles for any coin in any currency to feed quant models and TradingView-style analysis.
- **Market intelligence** — track exchange volumes, market-share, maker/taker fees and a coin's liquidity across every venue it trades on.
- **Sentiment timing** — read the Crypto Fear & Greed Index and global market overview (BTC/ETH dominance, DeFi & stablecoin caps, ETH gas) into your models.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **CoinMarketCap Scraper**, pick a **mode**, enter coins/queries (or leave empty for the top list), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "listing",
    "vsCurrency": "usd",
    "sortBy": "market_cap",
    "tag": "artificial-intelligence",
    "enrichCoinDetails": true,
    "maxResults": 100,
    "monitorMode": false
}
````

- **mode** — what to scrape: `listing` (top coins, the default), `coin` (deep profiles), `historical` (OHLCV), `exchanges`, `marketPairs`, `spotlight` (trending/gainers/losers), `fearGreed` (sentiment + global market).
- **searchQueries** — coins by name, symbol or slug (`bitcoin`, `BTC`, `pepe`, `SOL`). Used by Coin, Historical and Market-pairs modes. Ambiguous tickers resolve to the highest-ranked coin (so `BTC` → Bitcoin, never a copycat).
- **coinIds** — exact CMC numeric ids (`1` = Bitcoin) or slugs for precise targeting.
- **startUrls** — paste CoinMarketCap URLs: `/currencies/<slug>/`, `/currencies/<slug>/markets/` or `/exchanges/<slug>/`.
- **vsCurrency** — quote currency (`usd`, `eur`, `gbp`, `jpy`, `inr`, `brl`, `btc`, `eth`, …).
- **sortBy / sortType / cryptoType / tag** — order and filter the Coins list (e.g. `date_added` for newest, `tag: "memes"` for a sector).
- **priceMin/Max, marketCapMin/Max, volume24hMin/Max, percentChange24hMin/Max** — numeric filters for Coins mode.
- **historyDays / dateFrom / dateTo** — window for Historical & Fear & Greed modes (daily candles, trimmed to your window).
- **spotlightLists** — which Spotlight lists to include (trending, gainers, losers, mostVisited, recentlyAdded, upcoming, mostSearched).
- **enrichCoinDetails / enrichExchangeDetails** — fetch full profiles (one extra call per item).
- **monitorMode / monitorKey** — emit only new/changed records across scheduled runs (see [Monitoring](#monitoring-only-new--changed-records)).

### Output

One record per coin (`type: "coin"`), plus `coinHistory`, `exchange`, `marketPair`, `fearGreed` and `global` records depending on mode. Example coin record:

```json
{
    "type": "coin",
    "id": 1,
    "cmcRank": 1,
    "name": "Bitcoin",
    "symbol": "BTC",
    "slug": "bitcoin",
    "url": "https://coinmarketcap.com/currencies/bitcoin/",
    "currency": "USD",
    "price": 63152.61,
    "marketCap": 1265894565682,
    "fullyDilutedMarketCap": 1326204935001,
    "dominance": 58.26,
    "volume24h": 25691944751,
    "percentChange1h": -0.14,
    "percentChange24h": 0.77,
    "percentChange7d": -0.88,
    "percentChange30d": -18.48,
    "percentChange1y": -39.46,
    "circulatingSupply": 20045006,
    "totalSupply": 20045006,
    "maxSupply": 21000000,
    "allTimeHigh": 126198.06,
    "allTimeHighDate": "2025-10-06T00:00:00.000Z",
    "watchCount": 6355946,
    "tags": ["mineable", "pow", "store-of-value", "layer-1"],
    "website": "https://bitcoin.org/",
    "whitepaper": "https://bitcoin.org/bitcoin.pdf",
    "sourceCode": "https://github.com/bitcoin/bitcoin",
    "twitter": "bitcoin",
    "reddit": "https://reddit.com/r/bitcoin",
    "contracts": [],
    "dateAdded": "2010-07-13T00:00:00.000Z",
    "scrapedAt": "2026-06-19T16:00:00.000Z"
}
```

#### Modes at a glance

| Mode | Returns |
|---|---|
| `listing` | Top coins (or a filtered/sorted slice) with full market data |
| `coin` | Deep project profiles: description, supply, ATH/ATL, contracts, links, audits |
| `historical` | Daily OHLCV candles (open/high/low/close/volume/market cap) per coin |
| `exchanges` | Spot/derivatives/DEX venues: volume, score, fees, fiats, on/off-ramps |
| `marketPairs` | A coin's trading pairs across exchanges: price, volume, liquidity, depth |
| `spotlight` | Trending, gainers, losers, most-visited, recently-added, most-searched |
| `fearGreed` | Crypto Fear & Greed Index history + the global market overview |

### Monitoring — only new & changed records

Turn on **monitorMode** to remember each record's price, rank and volume in a named key-value store and emit **only what is new or changed** since the last run — every changed record is tagged with a `monitorEvent` (`new`, `price_up`, `price_down`, `rank_change`, `updated`) and carries `previousPrice` / `previousRank`.

This is **orthogonal to [Apify Schedules](https://docs.apify.com/platform/schedules)**: the schedule decides *when* the actor runs; monitoring decides *what's new* between runs. Combine them to power price alerts and new-listing feeds. Use a distinct `monitorKey` per saved watch so independent monitors don't share state.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it every minute/hour/day to track prices, ranks and new listings; pair with monitoring mode for clean alerts.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM, Slack, trade bot) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/coinmarketcap-scraper').call({
    mode: 'listing',
    sortBy: 'percent_change_24h',
    vsCurrency: 'usd',
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} coins`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push price moves straight into your tools.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored coin moves.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "get the top 20 coins by 24h gain and the current Fear & Greed score" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **crypto & finance data stack**:

- **[CoinGecko Scraper](https://apify.com/scrapesage/coingecko-crypto-scraper)** — the CoinGecko side: coins, NFTs, exchanges, derivatives & treasuries.
- **[DEX Token Scraper](https://apify.com/scrapesage/dex-token-scraper)** — on-chain DEX pairs & new launches across 190+ chains (DexScreener + GeckoTerminal).
- **[DeFiLlama Scraper](https://apify.com/scrapesage/defillama-scraper)** — protocol TVL, yields, fees & revenue.
- **[Crypto Wallet Scraper](https://apify.com/scrapesage/crypto-wallet-scraper)** — on-chain wallet balances & transactions across EVM chains + Bitcoin.
- **[Prediction Markets Scraper](https://apify.com/scrapesage/prediction-markets-scraper)** — Polymarket & Kalshi markets, odds & arbitrage.
- **[TradingView Scraper](https://apify.com/scrapesage/tradingview-scraper)** — technicals, screeners, ideas & news.
- **[Yahoo Finance Scraper](https://apify.com/scrapesage/yahoo-finance-scraper)** — stocks, quotes, fundamentals & news.
- **[Finviz Scraper](https://apify.com/scrapesage/finviz-scraper)** — stock screener, insider trades & analyst ratings.
- **[SEC EDGAR Scraper](https://apify.com/scrapesage/sec-edgar-scraper)** — US filings & XBRL financials.

### Tips

- **Top coins fast**: leave queries empty in Coins mode to get the top market-cap list; raise `maxResults` (paginated 100/page).
- **Gainers / losers / newest**: set `sortBy` to `percent_change_24h` (+ `sortType`), or `date_added` for the freshest listings.
- **Exact coins**: prefer `coinIds` (numeric id or slug) over `searchQueries` for zero ambiguity.
- **Custom history window**: set `dateFrom`/`dateTo` — daily candles are trimmed to your range (CoinMarketCap serves up to ~400 daily candles per coin).
- **Currency**: set `vsCurrency` to price everything (incl. history) in EUR, GBP, BTC, ETH and 20+ others.
- **Cost control**: enrichment (`enrichCoinDetails` / `enrichExchangeDetails`) adds one API call per item — turn it off for large, lightweight pulls.

### FAQ

**Do I need a CoinMarketCap API key?** No. This actor reads CoinMarketCap's own public web data API — no key, no login, no browser. It complements the official API by returning richer page-level fields (ATH/ATL dates, watch counts, liquidity, tags, links, audits) in one clean dataset.

**How do I get historical prices?** Use `historical` mode with `searchQueries`/`coinIds` and a `historyDays` window (or explicit `dateFrom`/`dateTo`). Each coin returns one record with an OHLCV `quotes` array (open/high/low/close/volume/market cap per day) plus summary stats.

**Can I monitor prices and get only changes?** Yes — enable `monitorMode`. Subsequent scheduled runs emit only coins whose price/rank/volume changed, tagged with `monitorEvent`. See [Monitoring](#monitoring-only-new--changed-records).

**Which currencies are supported?** USD, EUR, GBP, JPY, AUD, CAD, CHF, CNY, KRW, INR, BRL, RUB, TRY, MXN, IDR, NGN, ZAR, HKD, SGD, AED and crypto units BTC, ETH, BNB, USDT, SOL.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**Is scraping CoinMarketCap legal?** This actor collects publicly available market data only. You are responsible for using the data in compliance with applicable laws and CoinMarketCap's terms. Crypto data is informational, not financial advice.

**A field is null — why?** Some coins genuinely don't publish a max supply, a website, or contract addresses. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

<b>Coins & prices</b> = live market data for the top coins or any coins you choose (the default). <b>Coin profiles</b> = deep profile for specific coins (description, supply, ATH/ATL, links, contracts, audits). <b>Historical OHLCV</b> = candles + volume history for specific coins. <b>Exchanges</b> = trading venues with volume, score & fees. <b>Market pairs</b> = a coin's trading pairs across exchanges. <b>Spotlight</b> = trending / gainers / losers / most-visited / recently-added / most-searched. <b>Fear & Greed</b> = the sentiment index + global market overview.

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

Coins to target by name, symbol or slug, e.g. <code>bitcoin</code>, <code>BTC</code>, <code>Ethereum</code>, <code>pepe</code>, <code>SOL</code>. Used by <b>Coin profiles</b>, <b>Historical</b> and <b>Market pairs</b> modes (and as a filter in <b>Coins</b> mode). Resolved against CoinMarketCap's full coin map; for ambiguous symbols the highest-ranked coin wins.

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

Exact CoinMarketCap numeric ids (e.g. <code>1</code> = Bitcoin, <code>1027</code> = Ethereum) or url slugs (e.g. <code>matic-network</code>). Faster and more precise than queries.

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

Direct CoinMarketCap URLs: coins (<code>coinmarketcap.com/currencies/bitcoin/</code>), markets (<code>/currencies/bitcoin/markets/</code>) or exchanges (<code>/exchanges/binance/</code>). Routed automatically by type.

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

Currency to price everything in, e.g. <code>usd</code>, <code>eur</code>, <code>gbp</code>, <code>jpy</code>, <code>inr</code>, <code>brl</code>, <code>btc</code>, <code>eth</code>. Defaults to USD.

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

How to order the top-coins list. Use <b>Date added</b> for newest listings or a <b>% change</b> sort for gainers/losers.

## `sortType` (type: `string`):

Whether the Coins list is ordered high-to-low or low-to-high by the chosen sort field.

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

Limit to coins (own chain) or tokens (issued on another chain), or include all.

## `tag` (type: `string`):

Limit Coins mode to one CoinMarketCap tag slug, e.g. <code>defi</code>, <code>memes</code>, <code>artificial-intelligence</code>, <code>real-world-assets</code>, <code>gaming</code>, <code>solana-ecosystem</code>. Leave blank for all.

## `priceMin` (type: `integer`):

Coins mode filter: minimum price in the quote currency.

## `priceMax` (type: `integer`):

Coins mode filter: maximum price.

## `marketCapMin` (type: `integer`):

Coins mode filter: minimum market cap.

## `marketCapMax` (type: `integer`):

Coins mode filter: maximum market cap.

## `volume24hMin` (type: `integer`):

Coins mode filter: minimum 24h volume.

## `volume24hMax` (type: `integer`):

Coins mode filter: maximum 24h volume.

## `percentChange24hMin` (type: `integer`):

Coins mode filter: minimum 24h price change %.

## `percentChange24hMax` (type: `integer`):

Coins mode filter: maximum 24h price change %.

## `exchangeCategory` (type: `string`):

Which kind of trading venue to list.

## `pairCategory` (type: `string`):

Which market-pair category to return for each coin.

## `historyDays` (type: `string`):

How far back to fetch OHLCV candles (ignored if you set explicit From/To dates below). CoinMarketCap returns up to ~400 candles fitted to the window, so a shorter window gives finer resolution; each record reports the actual <code>approxIntervalHours</code>. Used by Historical and Fear & Greed modes.

## `dateFrom` (type: `string`):

Explicit start date, e.g. <code>2024-01-01</code>. Overrides History window.

## `dateTo` (type: `string`):

Explicit end date, e.g. <code>2024-12-31</code>. Defaults to now.

## `spotlightLists` (type: `array`):

Which Spotlight lists to include.

## `enrichCoinDetails` (type: `boolean`):

In Coins mode, fetch each coin's full profile: description, ATH/ATL, contract addresses across chains, project links (website, whitepaper, GitHub, Twitter/X, Telegram, Reddit), audits and watchlist count. Adds one API call per coin.

## `enrichExchangeDetails` (type: `boolean`):

In Exchanges mode, fetch each exchange's full profile: description, website, socials, tags and proof-of-reserves net worth. Adds one API call per exchange.

## `maxResults` (type: `integer`):

Maximum number of records to scrape in this run.

## `deduplicateResults` (type: `boolean`):

Skip records already emitted in this run (recommended).

## `monitorMode` (type: `boolean`):

Remember each record's price/rank/volume across runs in a named key-value store and emit ONLY records that are new or have changed since the last run — tagged with <code>monitorEvent</code> (new, price\_up, price\_down, rank\_change, updated). Perfect for price alerts and new-listing watches. Works with Apify Schedules.

## `monitorKey` (type: `string`):

Names the memory used by monitoring mode. Use a distinct key per saved watch so different monitors don't share state.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. The actor rotates a fresh proxy IP per request; 4–8 is a good range.

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

Proxy settings. CoinMarketCap's web API is datacenter-friendly; the default Apify Proxy rotates IPs to spread rate limits.

## Actor input object example

```json
{
  "mode": "listing",
  "searchQueries": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "vsCurrency": "usd",
  "sortBy": "market_cap",
  "sortType": "desc",
  "cryptoType": "all",
  "exchangeCategory": "spot",
  "pairCategory": "all",
  "historyDays": "90",
  "spotlightLists": [
    "trending",
    "gainers",
    "losers",
    "mostVisited",
    "recentlyAdded"
  ],
  "enrichCoinDetails": false,
  "enrichExchangeDetails": false,
  "maxResults": 100,
  "deduplicateResults": true,
  "monitorMode": false,
  "monitorKey": "default",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records as JSON items in the default dataset.

# 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 = {
    "searchQueries": [
        "bitcoin",
        "ethereum",
        "solana"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = {
    "searchQueries": [
        "bitcoin",
        "ethereum",
        "solana",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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 '{
  "searchQueries": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/coinmarketcap-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinMarketCap Scraper - Crypto Prices, Market Cap & Exchanges",
        "description": "Scrape CoinMarketCap data: live prices, market cap & rank, 24h volume, 1h–1y change, supply, ATH/ATL, full coin profiles, historical OHLCV, exchanges, market pairs, trending/gainers/losers and the Fear & Greed index. Keyless, no browser. Monitoring mode. JSON, CSV, Excel.",
        "version": "0.1",
        "x-build-id": "VQHhyzufpGAaiQHKo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~coinmarketcap-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-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/scrapesage~coinmarketcap-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-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/scrapesage~coinmarketcap-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-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": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "listing",
                            "coin",
                            "historical",
                            "exchanges",
                            "marketPairs",
                            "spotlight",
                            "fearGreed"
                        ],
                        "type": "string",
                        "description": "<b>Coins & prices</b> = live market data for the top coins or any coins you choose (the default). <b>Coin profiles</b> = deep profile for specific coins (description, supply, ATH/ATL, links, contracts, audits). <b>Historical OHLCV</b> = candles + volume history for specific coins. <b>Exchanges</b> = trading venues with volume, score & fees. <b>Market pairs</b> = a coin's trading pairs across exchanges. <b>Spotlight</b> = trending / gainers / losers / most-visited / recently-added / most-searched. <b>Fear & Greed</b> = the sentiment index + global market overview.",
                        "default": "listing"
                    },
                    "searchQueries": {
                        "title": "Coin queries (name, symbol or slug)",
                        "type": "array",
                        "description": "Coins to target by name, symbol or slug, e.g. <code>bitcoin</code>, <code>BTC</code>, <code>Ethereum</code>, <code>pepe</code>, <code>SOL</code>. Used by <b>Coin profiles</b>, <b>Historical</b> and <b>Market pairs</b> modes (and as a filter in <b>Coins</b> mode). Resolved against CoinMarketCap's full coin map; for ambiguous symbols the highest-ranked coin wins.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "coinIds": {
                        "title": "Coin IDs or slugs (exact)",
                        "type": "array",
                        "description": "Exact CoinMarketCap numeric ids (e.g. <code>1</code> = Bitcoin, <code>1027</code> = Ethereum) or url slugs (e.g. <code>matic-network</code>). Faster and more precise than queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct CoinMarketCap URLs: coins (<code>coinmarketcap.com/currencies/bitcoin/</code>), markets (<code>/currencies/bitcoin/markets/</code>) or exchanges (<code>/exchanges/binance/</code>). Routed automatically by type.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "vsCurrency": {
                        "title": "Quote currency",
                        "type": "string",
                        "description": "Currency to price everything in, e.g. <code>usd</code>, <code>eur</code>, <code>gbp</code>, <code>jpy</code>, <code>inr</code>, <code>brl</code>, <code>btc</code>, <code>eth</code>. Defaults to USD.",
                        "default": "usd"
                    },
                    "sortBy": {
                        "title": "Sort by (Coins mode)",
                        "enum": [
                            "market_cap",
                            "volume_24h",
                            "price",
                            "percent_change_1h",
                            "percent_change_24h",
                            "percent_change_7d",
                            "date_added",
                            "circulating_supply"
                        ],
                        "type": "string",
                        "description": "How to order the top-coins list. Use <b>Date added</b> for newest listings or a <b>% change</b> sort for gainers/losers.",
                        "default": "market_cap"
                    },
                    "sortType": {
                        "title": "Sort direction (Coins mode)",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Whether the Coins list is ordered high-to-low or low-to-high by the chosen sort field.",
                        "default": "desc"
                    },
                    "cryptoType": {
                        "title": "Coin type (Coins mode)",
                        "enum": [
                            "all",
                            "coins",
                            "tokens"
                        ],
                        "type": "string",
                        "description": "Limit to coins (own chain) or tokens (issued on another chain), or include all.",
                        "default": "all"
                    },
                    "tag": {
                        "title": "Category / tag filter (Coins mode)",
                        "type": "string",
                        "description": "Limit Coins mode to one CoinMarketCap tag slug, e.g. <code>defi</code>, <code>memes</code>, <code>artificial-intelligence</code>, <code>real-world-assets</code>, <code>gaming</code>, <code>solana-ecosystem</code>. Leave blank for all."
                    },
                    "priceMin": {
                        "title": "Min price",
                        "type": "integer",
                        "description": "Coins mode filter: minimum price in the quote currency."
                    },
                    "priceMax": {
                        "title": "Max price",
                        "type": "integer",
                        "description": "Coins mode filter: maximum price."
                    },
                    "marketCapMin": {
                        "title": "Min market cap",
                        "type": "integer",
                        "description": "Coins mode filter: minimum market cap."
                    },
                    "marketCapMax": {
                        "title": "Max market cap",
                        "type": "integer",
                        "description": "Coins mode filter: maximum market cap."
                    },
                    "volume24hMin": {
                        "title": "Min 24h volume",
                        "type": "integer",
                        "description": "Coins mode filter: minimum 24h volume."
                    },
                    "volume24hMax": {
                        "title": "Max 24h volume",
                        "type": "integer",
                        "description": "Coins mode filter: maximum 24h volume."
                    },
                    "percentChange24hMin": {
                        "title": "Min 24h % change",
                        "type": "integer",
                        "description": "Coins mode filter: minimum 24h price change %."
                    },
                    "percentChange24hMax": {
                        "title": "Max 24h % change",
                        "type": "integer",
                        "description": "Coins mode filter: maximum 24h price change %."
                    },
                    "exchangeCategory": {
                        "title": "Exchange type (Exchanges mode)",
                        "enum": [
                            "spot",
                            "derivatives",
                            "dex"
                        ],
                        "type": "string",
                        "description": "Which kind of trading venue to list.",
                        "default": "spot"
                    },
                    "pairCategory": {
                        "title": "Pair type (Market pairs mode)",
                        "enum": [
                            "all",
                            "spot",
                            "perpetual",
                            "futures"
                        ],
                        "type": "string",
                        "description": "Which market-pair category to return for each coin.",
                        "default": "all"
                    },
                    "historyDays": {
                        "title": "History window",
                        "enum": [
                            "1",
                            "7",
                            "14",
                            "30",
                            "90",
                            "180",
                            "365",
                            "max"
                        ],
                        "type": "string",
                        "description": "How far back to fetch OHLCV candles (ignored if you set explicit From/To dates below). CoinMarketCap returns up to ~400 candles fitted to the window, so a shorter window gives finer resolution; each record reports the actual <code>approxIntervalHours</code>. Used by Historical and Fear & Greed modes.",
                        "default": "90"
                    },
                    "dateFrom": {
                        "title": "From date (optional)",
                        "type": "string",
                        "description": "Explicit start date, e.g. <code>2024-01-01</code>. Overrides History window."
                    },
                    "dateTo": {
                        "title": "To date (optional)",
                        "type": "string",
                        "description": "Explicit end date, e.g. <code>2024-12-31</code>. Defaults to now."
                    },
                    "spotlightLists": {
                        "title": "Spotlight lists",
                        "type": "array",
                        "description": "Which Spotlight lists to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "trending",
                                "gainers",
                                "losers",
                                "mostVisited",
                                "recentlyAdded",
                                "upcoming",
                                "mostSearched"
                            ],
                            "enumTitles": [
                                "Trending",
                                "Top gainers",
                                "Top losers",
                                "Most visited",
                                "Recently added",
                                "Upcoming",
                                "Most searched"
                            ]
                        },
                        "default": [
                            "trending",
                            "gainers",
                            "losers",
                            "mostVisited",
                            "recentlyAdded"
                        ]
                    },
                    "enrichCoinDetails": {
                        "title": "Fetch full coin profiles (Coins mode)",
                        "type": "boolean",
                        "description": "In Coins mode, fetch each coin's full profile: description, ATH/ATL, contract addresses across chains, project links (website, whitepaper, GitHub, Twitter/X, Telegram, Reddit), audits and watchlist count. Adds one API call per coin.",
                        "default": false
                    },
                    "enrichExchangeDetails": {
                        "title": "Fetch full exchange profiles (Exchanges mode)",
                        "type": "boolean",
                        "description": "In Exchanges mode, fetch each exchange's full profile: description, website, socials, tags and proof-of-reserves net worth. Adds one API call per exchange.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to scrape in this run.",
                        "default": 100
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate within a run",
                        "type": "boolean",
                        "description": "Skip records already emitted in this run (recommended).",
                        "default": true
                    },
                    "monitorMode": {
                        "title": "Monitoring mode — only new or changed records",
                        "type": "boolean",
                        "description": "Remember each record's price/rank/volume across runs in a named key-value store and emit ONLY records that are new or have changed since the last run — tagged with <code>monitorEvent</code> (new, price_up, price_down, rank_change, updated). Perfect for price alerts and new-listing watches. Works with Apify Schedules.",
                        "default": false
                    },
                    "monitorKey": {
                        "title": "Monitor key",
                        "type": "string",
                        "description": "Names the memory used by monitoring mode. Use a distinct key per saved watch so different monitors don't share state.",
                        "default": "default"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Maximum parallel requests. The actor rotates a fresh proxy IP per request; 4–8 is a good range.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. CoinMarketCap's web API is datacenter-friendly; the default Apify Proxy rotates IPs to spread rate limits.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
