# Crypto Market Data Scraper (`superslowsloth/crypto-market-data-scraper`) Actor

Live cryptocurrency prices and market data from CoinGecko in any of 65 currencies. Returns price, market cap and rank, 24h high, low and change, trading volume, circulating and total supply, all-time high and low with their dates. Filter to specific coins or a category, no API key needed.

- **URL**: https://apify.com/superslowsloth/crypto-market-data-scraper.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** Business, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.26 / 1,000 coins

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

## Crypto Market Data Scraper

Live market data for any cryptocurrency, taken from CoinGecko's public market
endpoint: price, market capitalisation and rank, fully diluted valuation,
circulating and total supply, 24-hour high, low and change, all-time high and
low with the dates they happened, and the API's own last-updated timestamp for
every row.

Point it at the whole market, at one category, or at an explicit list of coins.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `vsCurrency` | string | `usd` | Currency every monetary field is quoted in. Any code from CoinGecko's supported list — fiat (`usd`, `eur`, `jpy`, `thb`), crypto (`btc`, `eth`, `sol`), or commodity units (`xau`, `xag`). Validated before the run starts. |
| `coinIds` | array | — | Optional. CoinGecko slugs such as `bitcoin`, `ethereum`. A full CoinGecko coin URL is accepted too. Ticker symbols are not — `eth` matches dozens of listings, and guessing would hand you the wrong asset. |
| `category` | string | — | Optional. One CoinGecko category id, e.g. `layer-1`, `meme-token`, `decentralized-finance-defi`. Validated against `/coins/categories/list` before the run starts. |
| `order` | select | `market_cap_desc` | `market_cap_desc`, `market_cap_asc`, `volume_desc`, `volume_asc`, `id_desc`, `id_asc`. |
| `maxItems` | integer | `100` | How many coins to return. Paginated automatically; see throughput below. |
| `priceChangePercentage` | array | `1h, 24h, 7d, 30d` | Extra change windows. Each adds a `price_change_percentage_<window>_in_currency` field. |
| `requestIntervalSecs` | integer | `4` | Pause between paginated requests, to stay inside the free-tier rate limit. |
| `proxyConfiguration` | proxy | residential | Recommended. The rate limit is counted per exit address. |

### Output

One record per coin:

```
id                                    CoinGecko slug, e.g. "bitcoin"
symbol                                e.g. "btc"
name                                  e.g. "Bitcoin"
vs_currency                           the currency the numbers below are in
image                                 coin logo URL
current_price
market_cap
market_cap_rank
fully_diluted_valuation
total_volume                          24h trading volume
high_24h
low_24h
price_change_24h
price_change_percentage_24h
market_cap_change_24h
market_cap_change_percentage_24h
circulating_supply
total_supply
max_supply
ath                                   all-time high
ath_change_percentage
ath_date
atl                                   all-time low
atl_change_percentage
atl_date
roi                                   ICO return, for the few coins that have one
last_updated                          CoinGecko's own timestamp for this row
price_change_percentage_<w>_in_currency   one per window requested
```

#### Nulls are real, and they stay null

CoinGecko returns `null` for a great many of these fields, and this actor
passes that through as `null` rather than substituting `0`.

- `fully_diluted_valuation` is null whenever the total supply is unknown.
- `max_supply` is null for anything uncapped — Ethereum and Tether both are.
- `ath` / `atl` and their dates are null for coins too new to have a history.
- `roi` is null for almost everything; it is a dict for the handful of coins
  CoinGecko tracks an ICO return for.

A zero in a price or valuation field reads as a measurement. Anyone screening
for "FDV under $1M" would otherwise pick up every coin whose FDV is merely
unknown. Null says "not reported", which is the truth.

Ticker symbols, order-book depth, per-exchange prices and historical series are
not available from this endpoint and are not emitted. Coin ids that do not
exist are silently dropped by CoinGecko rather than reported as an error.

### Throughput, honestly

This actor uses CoinGecko's **free public API**, which needs no key and imposes
a hard rate limit: measured on 2026-08-24, roughly **5–15 requests per minute**
from one address, after which it answers HTTP 429 with a rate-limit body.

The actor handles that properly rather than hiding it:

- A page holds at most **250 coins** — that is CoinGecko's real ceiling.
  Asking for more does not error, it silently returns 100, so the actor clamps
  the request instead of trusting the server.
- Pages are spaced `requestIntervalSecs` apart, four seconds by default.
- A fresh proxy address is taken before each page, because the limit is counted
  per address.
- HTTP 429 is treated as *transient*: the request backs off and retries on a
  different address. HTTP 400 (bad currency) and 404 (bad category) are treated
  as permanent and are not retried, because retrying them would only burn your
  money.

Practical consequence: **100 coins is a single request and finishes in
seconds. 250 coins is still one request. 1,000 coins is four pages and takes
roughly 15–30 seconds of deliberate waiting**, more if the proxy pool runs into
429s anyway. There is no way around this on the free tier; a run asking for the
entire market of ~17,000 coins would take several minutes and is not what this
actor is tuned for.

### This data is time-sensitive

Every record carries CoinGecko's own `last_updated` timestamp, unmodified — not
the time this actor happened to fetch it. Use that field, not your run's start
time, when you reason about freshness.

**Free-tier CoinGecko data lags the exchanges, typically by a minute or two,
and CoinGecko's own aggregation adds further smoothing on thinly traded pairs.**
That is fine for dashboards, research, portfolio snapshots, screening and
alerting on meaningful moves. It is **not** suitable as a trading feed: if you
are making execution decisions on a timescale where seconds matter, this actor
is the wrong instrument and you want a direct exchange websocket instead.

### Billing

One `item-scraped` event per coin actually delivered, charged **after** the
record is written, and coins are de-duplicated by `id` before charging — a coin
that CoinGecko repeats across pages is paid for once. A run that legitimately
matches nothing charges only the `actor-start` fee.

### Source

`https://api.coingecko.com/api/v3/coins/markets` — verified working
unauthenticated on 2026-08-24.

# Actor input Schema

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

The currency every price, market cap and volume is quoted in. Must be one of the codes CoinGecko publishes at /simple/supported\_vs\_currencies - that list holds fiat (usd, eur, jpy, thb, ...), crypto (btc, eth, sol, ...) and commodity units (xau, xag). An unsupported code fails the run immediately instead of returning wrong numbers.

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

Optional. Restrict the run to these coins, given as CoinGecko slugs such as bitcoin, ethereum, solana. A full CoinGecko coin URL works too. Ticker symbols are deliberately not accepted, because a symbol like eth matches dozens of listings and guessing would return the wrong asset. Leave empty to scrape the whole market in the chosen order.

## `category` (type: `string`):

Optional. Restrict the run to one CoinGecko category id, for example layer-1, meme-token, decentralized-finance-defi or smart-contract-platform. Ids come from CoinGecko's /coins/categories/list endpoint and are validated before the run starts, so a typo is reported rather than silently returning nothing.

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

How CoinGecko sorts the market before it is paginated. Market cap descending gives the familiar top-coins ranking; the volume orders surface what is actually trading today.

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

How many coins to return. CoinGecko serves at most 250 per request, so larger numbers are paginated automatically. Note that the free public API allows only about 5-15 requests per minute, so every extra page of 250 adds a few seconds of deliberate waiting to the run.

## `priceChangePercentage` (type: `array`):

Optional. Extra price-change windows to request. Each one selected adds a price\_change\_percentage\_<window>\_in\_currency field to every coin. The 24h change is always included regardless of what is chosen here.

## `requestIntervalSecs` (type: `integer`):

How long to wait between paginated requests. CoinGecko's free public API answers HTTP 429 when pushed, and the run retries on a rotated proxy address when that happens, so lowering this trades wall-clock time for retries. Four seconds keeps a multi-page run comfortably inside the free limit.

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

Recommended. CoinGecko counts its rate limit per exit address, so a rotating proxy is what makes multi-page runs finish without a long wait. A fresh address is taken before each page and again before each retry.

## Actor input object example

```json
{
  "vsCurrency": "usd",
  "coinIds": [
    "bitcoin",
    "ethereum"
  ],
  "order": "market_cap_desc",
  "maxItems": 100,
  "priceChangePercentage": [
    "1h",
    "24h",
    "7d",
    "30d"
  ],
  "requestIntervalSecs": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `coins` (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 = {
    "vsCurrency": "usd",
    "coinIds": [
        "bitcoin",
        "ethereum"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/crypto-market-data-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 = {
    "vsCurrency": "usd",
    "coinIds": [
        "bitcoin",
        "ethereum",
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/crypto-market-data-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 '{
  "vsCurrency": "usd",
  "coinIds": [
    "bitcoin",
    "ethereum"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call superslowsloth/crypto-market-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/crypto-market-data-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/v8wG88kuR3SrSKdhR/builds/OZnyjSMGO45DdEo3F/openapi.json