# CoinMarketCap Crypto Scraper — Ranked Listing (`devilscrapes/coinmarketcap-crypto-scraper`) Actor

Pull CoinMarketCap's ranked cryptocurrency listing — rank, price, market cap, volume, tags, and supply metrics — for the top coins in one run, sorted and filtered your way. We handle retries and proxy routing so the data lands. Keyless, no API key needed.

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

## Pricing

Pay per event

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## CoinMarketCap Crypto Scraper — Ranked Listing

**💰 $3.00 / 1 000 results**  ·  pay only for results  ·  no credit card to try

*We do the dirty work so your dataset stays clean.* 😈

Pull CoinMarketCap's own ranked cryptocurrency listing — rank, price, market cap, volume, tags, and supply metrics — for the top coins in one run, sorted and filtered your way. We handle retries and proxy routing so the data lands. Keyless, no API key needed.

</div>

***

### 🎯 What this scrapes

CoinMarketCap's own frontend calls an internal, keyless JSON endpoint to render its ranked coin table — no account, no API key, no signature. This Actor calls that same endpoint directly and turns the response into typed rows: CMC's own `cmcRank`, its tags taxonomy, supply metrics, and multi-currency price quotes for however many coins you ask for, sorted and filtered the way CMC's own site lets you sort and filter. We absorb retries and route through Apify Proxy so the run finishes clean even when the endpoint hiccups.

### 🔥 Features

- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` and network errors — up to 5 attempts, `Retry-After` honoured.
- 🌐 **Apify Proxy routing** on every request — a fresh session if the endpoint ever throttles a shared range.
- 🧩 **Fault isolation per coin** — one coin with a malformed field is skipped and logged, the rest of your run still lands.
- 🧱 **Fail-loud on schema drift** — if CMC changes this undocumented endpoint's shape, we stop the run and tell you instead of shipping garbage rows.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, currency-keyed quote objects.
- 💰 **One flat rate per coin** — no per-currency multiplication, however many currencies you request in `convert`.

### 💡 Use cases

- **Crypto dashboards** — schedule a run and pipe CMC's own ranked leaderboard into a spreadsheet or BI tool.
- **Market-research pipelines** — track top movers by market cap, volume, or percent change over time.
- **Portfolio and screening tools** — filter by tag (`defi`, `nft`, `metaverse`) or coin type before you build a watchlist.
- **Paired with our CoinGecko Actor** — pull CMC's ranked leaderboard here to build a shortlist, then run [`coingecko-crypto-scraper`](https://apify.com/DevilScrapes/coingecko-crypto-scraper) for deep per-coin detail (ATH/ATL, sentiment, dev stats) on the coins you picked. Different host, different shape, same category — not a duplicate.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Set `limit`, `sortBy`, `convert`, and any filters — most fields have sensible defaults.
3. Click **Start**. Output streams into the run's dataset.
4. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch via the Apify API.

For no-code workflows: install the [Apify node for n8n](https://n8n.io/integrations/apify/) or the [Apify module for Make](https://www.make.com/en/integrations/apify), connect your Apify token, and point it at `DevilScrapes/coinmarketcap-crypto-scraper`.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `limit` | `integer` | no | `100` | Number of ranked coins to return. Max 1000 per run — advance `start` on a later run for more. |
| `start` | `integer` | no | `1` | 1-based rank offset for pagination, e.g. `101` starts at the 101st-ranked coin. |
| `sortBy` | `string` | no | `"market_cap"` | Ranking sort key: `market_cap`, `volume_24h`, `price`, `percent_change_1h/24h/7d/30d`, `name`, `date_added`, `circulating_supply`. |
| `sortType` | `string` | no | `"desc"` | Sort direction: `asc` or `desc`. |
| `convert` | `array` | no | `["USD"]` | Fiat/crypto codes to price each coin in, e.g. `USD`, `EUR`. Max 3 — `USD` is always included. |
| `cryptoType` | `string` | no | `"all"` | Restrict to `coins`, `tokens`, or `all`. |
| `tagSlugs` | `array` | no | — | Optional CMC tag slugs to filter by, e.g. `defi`, `nft`, `metaverse`. Leave empty for no filter. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | We route every request through Apify Proxy. |

#### Example input

```json
{
  "limit": 25,
  "sortBy": "volume_24h",
  "sortType": "desc",
  "convert": ["USD", "EUR"],
  "cryptoType": "all",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### 📤 Output

One flat row per coin — `quotes` is an object keyed by currency code, not a list, so requesting multiple `convert` currencies never multiplies the billed rows for one coin.

| Field | Type | Notes |
|---|---|---|
| `cmcRank` | `integer` | CoinMarketCap's own ranking position for this coin. |
| `coinId` | `integer` | CMC internal numeric coin ID. |
| `name` | `string` | Coin name, e.g. `Bitcoin`. |
| `symbol` | `string` | Ticker symbol, e.g. `BTC`. |
| `slug` | `string` | CMC URL slug, e.g. `bitcoin`. |
| `tags` | `array` | CMC tag taxonomy for this coin, e.g. `mineable`, `defi`, `pow`. |
| `isActive` | `boolean` | Whether CMC lists this coin as active. |
| `dateAdded` | `string` | ISO-8601 — date CMC added this coin. |
| `lastUpdated` | `string` | ISO-8601 — CMC's last update timestamp for this coin. |
| `marketPairCount` | `integer` | Number of trading pairs CMC tracks for this coin. |
| `circulatingSupply` | `number` | Circulating supply. |
| `totalSupply` | `number \| null` | Total supply, when known. |
| `maxSupply` | `number \| null` | Max supply cap, when known. |
| `quotes` | `object` | Per-currency quote data, keyed by requested currency code (e.g. `USD`, `EUR`) — `price`, `volume24h`, `marketCap`, `percentChange1h/24h/7d/30d`, `dominance`. |
| `coinmarketcapUrl` | `string` | Canonical CMC currency page URL, constructed from `slug`. |
| `scrapedAt` | `string` | ISO-8601 UTC timestamp at row creation. |

#### Example output

```json
{
  "cmcRank": 1,
  "coinId": 1,
  "name": "Bitcoin",
  "symbol": "BTC",
  "slug": "bitcoin",
  "tags": ["mineable", "pow", "sha-256", "store-of-value"],
  "isActive": true,
  "dateAdded": "2010-07-13T00:00:00.000Z",
  "lastUpdated": "2026-09-10T08:43:00.000Z",
  "marketPairCount": 12736,
  "circulatingSupply": 20082250.0,
  "totalSupply": 20082250.0,
  "maxSupply": 21000000.0,
  "quotes": {
    "USD": {
      "price": 78046.72,
      "volume24h": 28960995058.07,
      "marketCap": 1567353676607.12,
      "percentChange1h": 0.11,
      "percentChange24h": -2.02,
      "percentChange7d": 0.26,
      "percentChange30d": 21.85,
      "dominance": 59.02
    }
  },
  "coinmarketcapUrl": "https://coinmarketcap.com/currencies/bitcoin/",
  "scrapedAt": "2026-09-10T12:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.20 | One-off warm-up charge per run |
| `coin-result` | $0.003 | Per ranked-coin row written (≈ $3.00 / 1 000) |

Example: 1 000 coin rows at the rate above ≈ **$3.20** including the one-off start fee. No subscription, no minimum, no card to start — Apify gives every new account $5 of free credit.

### 🚧 Limitations

- Ranking/listing snapshot only — no per-coin detail pages, historical OHLCV charts, exchange listings, or news in this version.
- No auto-pagination across multiple `start` pages in one run — one run is one HTTP call, by design, for predictable cost.
- `convert` currency codes are validated for shape only, not against CMC's actual supported-currency list — an unsupported code simply won't appear in `quotes`.
- This is CMC's own undocumented internal endpoint, not the paid `pro-api.coinmarketcap.com` — if CMC changes its shape, the run fails loud rather than shipping bad data.

### ❓ FAQ

**Do I need a CoinMarketCap account or API key?**

No. This Actor calls CMC's own public frontend endpoint — the same one coinmarketcap.com uses to render its ranked table — no account, no key, no signature.

**How is this different from your CoinGecko Actor?**

This Actor pulls CMC's ranked leaderboard (top N coins by market cap/volume/etc., CMC's own `cmcRank` and tags). `coingecko-crypto-scraper` is a per-coin detail lookup for a list you already picked. Use this one to build the list, that one to enrich it.

**Can I get more than 1000 coins in one run?**

Not in a single run — `limit` caps at 1000 to keep payload size and cost predictable. Advance `start` past where the last run left off and run again.

**What happens if my `tagSlugs` filter matches nothing?**

The run finishes successfully with zero rows and a status message stating the filters used — you're never charged the result rate for rows that don't exist.

**Why is `quotes` a per-currency object instead of a list?**

So one coin stays one billed row no matter how many currencies you request in `convert` — requesting 3 currencies doesn't triple your bill for the same coin.

### 💬 Your feedback

Spotted a bug, hit a weird edge case, or need a new field? Open an issue on the Actor's **Issues** tab in Apify Console — we ship fixes weekly and we read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `limit` (type: `integer`):

Number of ranked coins to return. Max 1000 per run — advance <code>start</code> on a later run for more.

## `start` (type: `integer`):

1-based rank offset for pagination, e.g. <code>101</code> starts at the 101st-ranked coin.

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

Ranking sort key.

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

Ascending or descending sort order.

## `convert` (type: `array`):

Fiat/crypto codes to price each coin in, e.g. <code>USD</code>, <code>EUR</code>. Max 3. <code>USD</code> is always included.

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

Restrict to coins, tokens, or both.

## `tagSlugs` (type: `array`):

Optional CMC tag slugs to filter by, e.g. <code>defi</code>, <code>nft</code>, <code>metaverse</code>. Leave empty for no filter.

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

Apify Proxy routing. Leave this on unless you have your own proxy group to route through.

## Actor input object example

```json
{
  "limit": 100,
  "start": 1,
  "sortBy": "market_cap",
  "sortType": "desc",
  "convert": [
    "USD"
  ],
  "cryptoType": "all",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "limit": 100,
    "start": 1,
    "sortBy": "market_cap",
    "sortType": "desc",
    "convert": [
        "USD"
    ],
    "cryptoType": "all",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/coinmarketcap-crypto-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 = {
    "limit": 100,
    "start": 1,
    "sortBy": "market_cap",
    "sortType": "desc",
    "convert": ["USD"],
    "cryptoType": "all",
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "limit": 100,
  "start": 1,
  "sortBy": "market_cap",
  "sortType": "desc",
  "convert": [
    "USD"
  ],
  "cryptoType": "all",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/coinmarketcap-crypto-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,devilscrapes/coinmarketcap-crypto-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/nbEWY7PJb45KnpxX3/builds/UTS9MVcEgFLBpcYqM/openapi.json
