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.