The same once-per-asset counting the site is built on, as JSON. No signup, no key, no query language — one static file per thing.
curl https://coin-spectrum.com/api/v1/assets/xrp.jsonOne API, every plan: the market, asset and mining endpoints are the same files on each.
Free is live and needs no key. Paid tiers serve the same paths from
api.coin-spectrum.com/v1/ with a key, and add higher throughput, historical
snapshots, webhooks and per-key identification; prices are quoted in USD and paid in
cryptocurrency, with the quote locked for fifteen minutes.
$0 / mo
no key, no sign-up
$5 / mo
annual $50 · 2 months free
$29 / mo
annual $290 · 2 months free
Base URL
https://coin-spectrum.com/api/v1/Every cryptocurrency, stablecoin, token and memecoin
curl https://coin-spectrum.com/api/v1/assets.jsonOne asset (swap bitcoin for any slug)
curl https://coin-spectrum.com/api/v1/assets/bitcoin.jsonMining profitability, every proof-of-work coin
curl https://coin-spectrum.com/api/v1/mining.jsonMining pools, from the blocks of every proof-of-work coin
curl https://coin-spectrum.com/api/v1/mining-pools.jsonMining hardware, every ASIC, GPU and CPU on file
curl https://coin-spectrum.com/api/v1/mining-hardware.jsonOne machine and what it earns on every coin
curl https://coin-spectrum.com/api/v1/mining-hardware/nvidia-geforce-rtx-4090.jsonIn JavaScript
const mining = await fetch('https://coin-spectrum.com/api/v1/mining.json').then((r) => r.json());60 requests a minute per IP, CC BY 4.0 with attribution. Every endpoint is listed below; a paid key raises the limits on the same paths.
Pay with Bitcoin Cash, Litecoin, Monero, DigiByte or Siacoin. No card processor, no chargebacks, no KYC — one on-chain transaction, and the API key activates on the first confirmation.
Every endpoint is a plain JSON file. There are no query parameters and no auth on the free tier. Download the file, filter in the client. That is deliberate: it keeps the free tier truly free, and it keeps the surface small enough that a version bump is a real event.
https://coin-spectrum.com/api/v1/One version is served, and it is always the current one. When a field, a category or a
shape changes, the files change in place, schema_version in meta.json
goes up, and the change is described under Changes. No older copy is kept.
Schema version, counts, license, endpoint list. A one-shot health check for a consumer starting up.
Total market cap, per-category counts, chains, and the fiat exchange rates the site uses for currency conversion.
Every asset in one file — around 1.3 MB. Pull once, filter in memory; cheaper than one call per asset.
A single asset by its CoinSpectrum slug — e.g.
bitcoin, xrp, digibyte.
The slug matches the page URL at /assets/{slug}/.
The ranking — assets with their own blockchain and their own consensus mechanism. Nothing else.
Every token: everything issued on another chain rather than its own, whatever it stands for. The six lists below are its parts, and every token is in exactly one of them.
Tokens pegged to a currency: fiat (reserves held by
an issuer) and cdp (minted against collateral).
Wrapped and staked coins: claims on a cryptocurrency that is already counted.
Metal-backed tokens, each a claim on vaulted metal, by metal:
gold, silver.
Tokenised securities, by what they are: stock,
etf, treasury (government debt), mmf (money-market
fund), credit and fund.
Memecoins. Same shape, kept separate because they deserve their own bucket and their own explanation.
Every other token, by sector: dex, defi,
ai, oracle, depin, l2, gaming,
storage, compute, other.
Slug + market cap only, pre-sorted descending. Small enough to be the ranking's cheapest paint.
Updated every 60 s. Per-coin aggregated USD
price — the median of every exchange in the 24-venue panel that quoted the coin
within the 0.25×..4× anchor band. Each asset carries every confirming venue
(sources_consulted), the venue count, the 6-hour snapshot anchor
(snapshot_usd) and picked_single for consumers that want
a single-venue read. The industry-standard pattern (CoinGecko, CoinPaprika and
CryptoCompare's CCIX all compute some flavour of outlier-filtered-then-averaged),
done on the box so a consumer doesn't have to re-run the picker.
Updated every 60 s. Compact companion to
/live.json: a single assets map of symbol →
[price_usd_now, price_usd_24h_ago]. Nothing else — no venue list, no
snapshot anchor, no volume — so a ticker tape, a widget or a browser price row can
decide what to show from two numbers per asset. Around 60 KB over the wire; the same
generated_at as /live.json, so a client that reads both
sees them agree. Powers CoinSpectrum's own
embeddable live tiles.
Updated every 60 s. Rolling 1,440-sample price
buffer for every quoted coin — one array per symbol, oldest at
[0], newest at [length-1], one slot per minute of the past
24 hours. Missing-tick slots are null (venue outage, briefly outside
the band) so a chart renders a line gap rather than a fake interpolation. Around 16
MB; cache it.
Mining profitability for every proof-of-work chain the site measures, read
from each chain's own explorer or node: hashrate, block reward with fees split out, blocks
and coins a day, dollars paid to miners a day and per unit of hashrate, the last block's
time, a day's coins against 24-hour volume, and a reference machine's revenue and
breakeven electricity price (reference, with the machines in
hardware). The same rows as the mining page; rebuilt
every six hours, at /api/v1/mining.json (CC BY 4.0, no key).
reference also carries the machine's
efficiency_j_per_unit (watts over hashrate, in joules per H, Sol or graph),
its stock status and list price_usd at the maker (null where not
stated), payback_days (list price over a day's profit at
rules.payback_power_usd_kwh and no pool fee; null without a price or a profit),
solo_block_days (the expected days between blocks for one machine mining
alone), and usd_day_with_merge_mined beside
usd_day_with_merge_mined_7d_ago, the same machine's revenue on
rules.change_compared_day from that day's snapshot (null until a snapshot
from that day has the coin). next_halving gives the height,
blocks_to_go, days and projected date of the next halving on
chains that halve on a fixed schedule; null on every other chain.
Each coin links to its pages: coin_page (its mining page,
/mining/{slug}/) and asset_page (its asset page); reference.machine_page
and each hardware row's page link the machine's page under
/mining/hardware/. related lists the mining page, calculator, hardware list, the
hardware and pools endpoints and the daily history.
For a machine of your own: a day's revenue is
paid_to_miners_usd_day × hs / (hashrate + hs), about
usd_per_unit_day × hs for anything small next to the network, with
hs in the coin's hashrate_unit; take off the pool fee, then
watts × 24 / 1000 × your power price for profit. The file spells this out in
own_machine. Dollar figures are in USD; global.json carries the fiat
rates for any other currency. For a machine on file, its own file below has the sums done.
One copy of mining.json a day (the last build of the day),
kept from 4 November 2026 on, outside /api/v1/. index.json lists
the days. For looking up what mining paid on a past day instead of estimating it.
Every mining machine on the hardware pages:
maker, kind (ASIC, GPU or CPU), availability, list price_usd where the maker
states one (with price_checked, and price_source where the price
comes from another page than the figures), and per algorithm the hashrate and power at
the wall, each with the maker's page or open benchmark it came from. reference
names the machine the mining page uses for each algorithm. Together with
mining.json it is everything the calculator
reads.
One machine, a few KB: its modes (hashrate, power, efficiency and the source of
each, with the clocks and power limit the benchmark ran at in detail where the source
states them) and what it earns today on every coin it can mine, one row a coin and mode in
earnings: usd_day, merge-mined coins paid on top, power a day,
profit_usd_day at rules.power_usd_kwh with no pool fee,
breakeven_usd_kwh and the machine's network_share, best first.
best is the most profitable coin a machine can sell into (not a quiet chain, not more
than rules.best_max_network_share of its network), with payback_days
from the list price. The same table as the machine's page under
/mining/hardware/. /mining-hardware/index.json lists every
machine (slug, kind, algorithms, best coin and profit today, and its file's url), so a
caller looking for one GPU or ASIC reads the index, then one file. Rebuilt every six hours (CC BY 4.0,
no key).
Who finds each proof-of-work chain's blocks, attributed from the blocks
themselves: each recent block's coinbase matched to a pool by the tag the pool writes into it
and the address it pays, as mempool.space does for Bitcoin, and never from pools' own hashrate
claims. Per coin: the window read (window: blocks, heights, first and last block
time; stride where every n-th height was sampled, batches where the
chain was read as runs of consecutive blocks across a day, as Kaspa is), every pool or unnamed miner with its blocks, share and how it was identified
(identified_by), the largest, top3_share,
nakamoto (how many together found more than half) and the unknown
share. Where a pool's own pages state them, its fee, payout method and minimum payout for that
coin, with the page and the date checked (terms). A chain whose blocks hide their
finder has status: "opaque" and a reason; one with no public source
for its blocks, "no-source" and a reason; one not read yet,
"unread". A chain read with a caveat has a note. The same data as the pools section of each
mining page; rebuilt every six hours (CC BY 4.0, no key).
Reachable full nodes of every chain the site crawls itself, over the chain's
own peer-to-peer protocol: nodes counts distinct IP addresses that complete the
handshake and report a block height within 0.5% of the tip (tip_height), and
clients names the node software they run with a count per version, read from
each node's user agent. Crawled weekly (crawled_at); IPv4 and IPv6, so a chain
with many onion nodes is undercounted. The counts behind the grade's nodes and clients checks.
Active addresses a day, counted by the site from each Bitcoin-family chain's own
blocks: for every month, the distinct addresses that received or spent coins on each UTC day
(days) and the month's median, with the blocks, transactions and inputs read and the
inputs whose sender a spend does not reveal (inputs_unresolved, Taproot and P2PK).
Updated once a month; how it is counted.
Chain jq for a pure Bash pipeline that names every
SHA-256 chain in the ranking:
curl -s https://coin-spectrum.com/api/v1/categories/cryptocurrencies.json \
| jq -r '.assets[] | select(.consensus == "SHA-256") | .name'Every asset is in one of two classes. A cryptocurrency runs its own blockchain
and its own consensus. A token is issued on another chain, and each token is in
one category with a subcategory that says exactly what it is or what
backs it:
| category | subcategory |
|---|---|
stablecoin | fiat, cdp |
wrapped | crypto |
metal | gold, silver, platinum, palladium |
security | stock, etf, treasury, mmf, credit, fund |
memecoin | meme |
utility | dex, defi, ai, oracle, depin, l2, gaming, storage, compute, other |
The tree is also in meta.json under taxonomy. Every asset appears once:
counts.cryptocurrencies plus counts.tokens is counts.total,
and the six category counts add up to counts.tokens. global.json gives the
total market cap and its parts by class and category. There is no "real-world asset" category:
a gold token and a tokenised fund share are filed apart, each by what it holds. The site's tabs
group tokens for reading; the API reports the tree as it is.
Schema 3 (9 November 2026) brought in class and subcategory, the
metal, security and utility categories and their lists,
and listed every asset once. Until then the token list repeated every stablecoin, wrapped coin
and memecoin, so the total market cap counted about $410 billion twice; a utility token's
category was token, and tokenised money-market funds were filed as
stablecoins.
Every asset — cryptocurrency or token, in any category — uses the same shape. Fields that
don't apply stay null, never omitted.
{
"slug": "bitcoin",
"symbol": "BTC",
"name": "Bitcoin",
"class": "cryptocurrency",
"category": "cryptocurrency",
"subcategory": null,
"consensus": "SHA-256",
"hashrate": 8.9e20,
"price_usd": 81449.12,
"price_source": {
"method": "exchange",
"aggregation": "median",
"confirmed_by": ["Binance","Bybit","OKX","Kraken","Bitstamp", /* ...22 total... */],
"count": 22,
"picked_single": { "venue": "Binance", "price_usd": 81445.52 },
"live_url": "/api/v1/live.json"
},
"change_pct_24h": null,
"volume_24h_usd": 37424313548,
"market_cap_usd": 1553734997147,
"rank": 1,
"supply": { "circulating": 20076428, "max": 21000000 },
"ledger": "overlay",
"nature": "commodity",
"nature_basis": "Named a digital commodity in the joint SEC-CFTC interpretation.",
"nature_tags": ["commodity"],
"chains": null,
"image": "https://..."
}price_source.method is "exchange" when at least one
exchange in the 24-venue panel quoted the coin within the 0.25×..4× anchor band
at the build; "snapshot" when none did (long-tail coin, newly listed,
CMC-only — the second-hand price in price_usd comes from the
6-hourly aggregated snapshot). About 38% of assets are exchange-sourced and 62%
are snapshot-only at any given build. change_pct_24h stays
null until the provider pipeline carries 24h change through — the field
is in the shape so adding the data later doesn't break clients.
Two cadences, two publishers:
/api/v1/* files — every 6 hours. The
heavy pipeline runs build-data.mjs + pages.mjs + api.mjs
to rebuild the whole tree. Carries supply, classification, hashrate, nature, DEX
volume and the snapshot price. meta.json's
update_cadence_minutes: 360 is this cadence./api/v1/live.json
and /api/v1/spark.json are rebuilt by
coinspectrum-live.service on a 60-second timer, writing a
median-aggregated price per coin and appending to a 24-hour sparkline buffer.
For comparison, CoinGecko caches most public endpoints for one to five minutes and its
paid price endpoint for 20 to 30 seconds; exchanges themselves stream in real time.Every response includes a generated_at ISO-8601 timestamp; a caller
who wants the freshest reading should read that field rather than trust HTTP dates.
For near-real-time price in the per-asset shape, pull the asset's
price_source.live_url once per minute instead of refetching the 6-hourly
file.
The free tier needs no key and allows 60 requests a minute per IP; a paid key raises the limit on the same paths. Every response is a static file. Please cache. Aggressive polling of a file that only changes every 60 s (live overlay) or every 6 h (snapshot) is wasteful for both sides.
Licensed under
CC BY 4.0.
Use the data anywhere, commercial use included. In return, please link
back to coin-spectrum.com — a footer credit or a note in
your project's README is enough. The API exists to be reused; a link
is how it stays sustainable.
The data is derived from public sources — see methodology. It is provided as-is, without warranty of any kind. If you use it to decide whether to spend money, that is entirely your call and entirely your risk.
Questions, bug reports, or a request for an endpoint that isn't here
yet: open an issue or write to api@coin-spectrum.com.
The /api/v1/ tier is free: no signup, no key, 60 requests a minute per IP.
Paid tiers — higher throughput, historical endpoints and per-key
limits, priced in USD and paid in crypto — serve the same endpoints with a key from
api.coin-spectrum.com/v1/; see Plans.
Not for /api/v1/. Files are served without authentication, up to 60 requests
a minute per IP. Paid tiers issue a key for the proxy endpoint and raise the limit.
Two cadences. Live prices — /api/v1/live.json and /live.json —
every 60 seconds. The structured files — rank, family, supply, classification, grades —
every six hours (update_cadence_minutes: 360 in meta.json). Every
response carries a generated_at ISO-8601 timestamp so a consumer can decide
whether to re-fetch. Use the live feed for prices and the structured files for everything
else.
Use the data anywhere — a chart, a screener, an app, a research paper, a commercial
product. The only requirement is credit somewhere reasonable: a byline, a data-source
line, or a link to coin-spectrum.com. Commercial use is included.
/api/v1/assets/xrp.json and /assets/xrp/?Same data, two consumers. The JSON is for machines; the HTML page is for readers. Both use the same canonical slug so the two URLs shape-match — one can be derived from the other with a trivial string replacement.
Only the current version is served. A change lands in the same files,
schema_version in meta.json goes up, and the
Changes list says what moved. No older copy is kept, so a consumer
that relies on category or subcategory should check
schema_version.