API

Everything on this site comes from these JSON endpoints. No key needed, CORS is open, and responses are cached for 60 seconds. {net} is mainnet or testnet. Amounts are in duffs (1 DASH = 100,000,000 duffs), except Platform amounts, which are in credits (1 DASH = 100,000,000,000 credits); times are unix seconds.

GET /api/v1/status

Our dashd's sync state, the crawler's state and the payment index range, per network.

GET /api/v1/releases

Dash Core's published releases from GitHub, refreshed hourly: releases as [{tag, version, prerelease, published}], newest first. A release candidate's version is the version it reports (v24.0.0-rc.5 is 24.0.0).

GET /api/v1/{net}/summary

The latest finished crawl, the crawl about 24 hours before it, every distribution from the latest crawl (dists[scope][dim] = [[key, count], …], largest first) and networks: per address network (ipv4, ipv6, onion, i2p, cjdns, always in that order), {network, known, tried, reachable, masternodes, crawled, reason}. known counts addresses heard of in the past week; a network we have no route to is crawled: false with a reason, and its addresses never count as unreachable. masternodes counts the registered masternodes reachable on the network, at an address their ProTx lists or at one that proved to be them by MNAUTH (signed with the operator key), so a masternode on Tor, I2P or IPv6 counts there though its ProTx only lists IPv4. Each counts once per network however many addresses answer for it.

Scopes: all (every address that answered), nonmn (those that aren't masternodes'), mn and evo (every enabled masternode or evonode, reachable or not, keyed by the user agent it last announced in the past 7 days, else Unknown).

Dimensions: ua, version, client, protocol, country (ISO 3166), asn, network, reachable, status and type (masternode scopes).

Also returns (the median annualized yield of enabled regular masternodes and evonodes over the last 90 days, on their 1,000 and 4,000 DASH collateral, from core-chain payments, which since MN_RR leave out the 37.5% of the masternode subsidy share that goes to Platform's credit pool; for evonodes also median_platform_yield from Platform rewards, median_total_yield of the two together and platform_span_days, the finished epochs those cover) and platform (evonode Platform health from the latest checks: checked, healthy, https_ok, p2p_ok, cert_expiring_3d, max_height and the drive, tenderdash and dapi versions as [[version, count], …]).

dkg_readiness counts enabled masternodes by whether quorum members would vote them a bad connection in DKGs under the rules of the Core release in rules.release: overall and per check in checks (protocol, relay, filters, reachable, platform_ban for evonodes), each {pass, fail, unknown}; version_only (failing the version and passing every other check); beyond_version (failing a check other than the version); and rules (the release, min_protocol, compact_filters_bit, reach_failures (port checks missed in a row before reachability fails), core_max_failed_outbound, core_commit (the Dash Core tag or commit they come from) and protocol_check). It's an estimate from the handshake each masternode sends our crawler. When rules.protocol_check is false (as it was until Dash Core 24 was released) the protocol check doesn't count: it's left out of each masternode's result and of overall, and version_only is 0.

curl https://radar.dashhq.org/api/v1/mainnet/summary | jq '.dists.mn.version'

GET /api/v1/{net}/history?scope=mn&dim=version&days=30&top=8

A time series of one distribution: {resolution, t: [...], series: [{key, values}]}. Up to 14 days back it has one point per crawl; past that, daily averages. Keys outside the top top (by total over the window) fold into Other. dim=totals returns reachable_nodes, masternodes (enabled) and masternodes_reachable instead. reachable_nodes counts addresses that answered, not nodes: a node doesn't tell peers its addresses on other networks, so one reachable on IPv4 and Tor counts twice (scope=all&dim=network breaks it down by network). The masternode counts are of masternodes, each once. days is one of 1, 7, 14, 30, 90 and 365 (default 30); top is 1 to 20 (default 8).

GET /api/v1/{net}/geo

Every IP address that answered the latest crawl, counted per city without the addresses themselves: {crawl_id, points: [{lat, lon, city, country, nodes, masternodes}], unlocated}. Onion and I2P nodes have no location and only count in unlocated.

GET /api/v1/{net}/masternodes

Every registered masternode with its latest port check (reachable is null when the latest crawl didn't check it), announced user agent, geolocation and 7- and 30-day port-check uptime. Geolocation is country (ISO 3166), continent (two-letter code), city, city-level lat/lon, asn and as_org; network is the service address's network. dkg_readiness is {overall, checks}, each pass, fail or unknown (see summary), or null for a removed masternode. Evonodes have platform: {last_epoch, d30, epoch_blocks, next, in_sets}, the credits they earned in the last finished epoch and over 30 days, the blocks they proposed so far this epoch and when their next turn to propose is due (unix time, an estimate; null when they're in no validator set that takes turns, or when in_sets, whether they are, is null too: the validator sets haven't been read lately). The map page is drawn from this endpoint.

GET /api/v1/{net}/masternodes/{protx}

One masternode: everything from the list plus collateral and keys, every registered Core address (core_p2p: [{address, network}]), version history, 90 days of daily uptime, its 25 latest payments, returns (paid in the last 30, 90 and 365 days, in duffs, and annual_yield on its collateral over the last 90 days or since registration), its 50 latest registration changes, and for evonodes platform (the latest Platform check and 30 days of daily results, with drive_protocol.next_epoch, the protocol Drive runs from the next epoch) and platform_rewards. Here dkg_readiness also carries its rules, next to the handshake's services and relay flag and our dashd's platform_banned.

platform_rewards (evonodes, in credits): epochs, newest first from the first it was paid for, up to 120: {epoch, start, end, blocks, credits, share, rank, of} (share of the epoch's blocks, and its rank by credits among the of evonodes that proposed); totals (last_epoch and its last_epoch_index, d30, d90, d365 by when each epoch was paid out, lifetime since first_epoch, epochs_paid); since (registration time) and history_days; d30_percentile (the share of the d30_of enabled evonodes that earned less over 30 days, null under 30 days); monthly (at its pace over monthly_basis_days: the last six epochs, or from monthly_since for a newer node, null before its first finished epoch) and annual_yield on 4,000 DASH over the same window as returns; current (this epoch: blocks of blocks_total, rank, pool_so_far from Core block rewards, accrued, its share of that, and turns); watched (finished epochs we sampled the validator sets in: expected blocks for the sets it was in, actual, turns seen, missed and the sampling coverage); turns_30d; next ({slots, eta, sampled}: blocks until its turn and when that's due); balance ({credits, ts}, its masternode identity's balance, what it can withdraw) and balance_history (every change we saw); vote (the protocol version its blocks this epoch voted for); and explorer, Platform Explorer's lifetime total_reward (third party, unverified; before_ours is what it counts beyond our epochs).

GET /api/v1/{net}/masternodes/{protx}/payments?before={height}&limit=100

Older payments, newest first. Page with before set to the last height you got.

POST /api/v1/{net}/masternodes/{protx}/check

Checks a registered masternode now: a P2P version handshake with its registered Core address from the Cloudflare location serving you. Returns ok, connect_ms, handshake_ms, user_agent, protocol, height or an error, and from. Five checks a minute per client; a masternode checked in the last minute gets that result again (cached: true).

GET /api/v1/{net}/platform

Evonodes' Platform rewards, in credits. Each finished epoch's pool (Core block rewards paid into Platform, plus fees) goes to the evonodes that proposed its blocks, pro rata by blocks, in Drive's integer arithmetic. We read Drive's record of every finished epoch, from epoch 34 on mainnet (getFinalizedEpochInfos), and the live state every 15 minutes, over gRPC-web from evonodes, using an answer only when two of them agree.

now: the current epoch, its start, estimated ends (from the epoch_secs of recent epochs), Platform height, blocks and proposers so far, pool_so_far (Core block rewards so far, fees not counted) and protocol_version. upgrade: the current protocol, the candidate with the most votes above it, its votes (evonodes whose blocks this epoch voted for it), required (1 + required_pct% of enabled_evonodes, rounded down; required_pct is Drive's share for the protocol that judges the votes, 67 since protocol 3), versions as [[version, votes], …], phase (active, voting or locked_in, when evonodes report a higher next_epoch protocol) and next_epoch_reported_by. returns: the median_monthly evonode Platform reward at the pace of the last six epochs (over the evonodes_paid evonodes registered before those six epochs started and paid in them) and the median_platform_yield on 4,000 DASH over the last 90 days. epochs, newest first, up to 120: {epoch, start, end, duration, first_height, blocks, proposers, pool, core_rewards, fees, per_block, protocol_version, blocks_spread, credits_spread}, the spreads as {p10, p50, p90, min, max} over the evonodes that proposed. schedule: who proposes next, from validator sets sampled every 90 seconds ({ts, height, epoch, block_secs, next: [{protx, slots, eta}]}, an estimate; null when none could be read for 5 minutes). evonodes: every registered evonode as {protx, service, status, drive, supports, vote, epoch_blocks, last_blocks, last_epoch, d30, monthly, monthly_since, balance, next} (supports is the newest protocol its Drive supports; monthly is as on its masternode page: the last six epochs' pace, or for an evonode registered since they started its own pace from monthly_since, and null before its first finished epoch; balance its masternode identity's credits).

curl https://radar.dashhq.org/api/v1/mainnet/platform | jq '.upgrade'

GET /api/v1/{net}/activation

Core's version-bits deployments (Dash Core 24's v24, and evo_shares), read from our dashd every 30 seconds and republished every minute; /v24 shows it. tip (height, time, mediantime), updated, dashd, block_seconds (the average over the last pace_blocks blocks, for estimates), error ({message, since} while reads fail; the rest is then the last good reading). Per deployment in deployments: params (as released: bit, start_time, timeout, window, threshold_start, threshold_min, falloff_coeff), signed (whether Dash Core 24 signs its masternode signal), state and since for the next block, worked out from every block header with Core's rules, rpc (our dashd's getdeploymentinfo entry), consistent and mismatches (the two compared), ehf (height of the mined masternode signal, and until then gate: the quorums that would sign it, with how many valid members announced protocol 70242+ to our crawler), window (the window the next block belongs to: start, end, mined, count, attempt, threshold, needed, possible and signalling, a # or - per block), windows (the ones that counted, and the latest), recent (signals in the last 576 blocks), schedule (the threshold per attempt) and outlook (the next milestones). Heights come with a time and estimated: true for blocks not mined yet, at block_seconds each.

curl https://radar.dashhq.org/api/v1/mainnet/activation | jq '.deployments[0].outlook'

GET /api/v1/{net}/changes

The 300 latest registration changes, newest first, in changes: {ts, height, protx, type, field, old, new}, and since, when recording started. field is registered, removed, pose (enabled or banned at a height) or the changed field (service, payout_address, pubkey_operator, …). Recorded since 30 Oct 2026.

GET /api/v1/health

200 while every network's data is fresh (crawled and read from the chain within 45 minutes) and its snapshots are saved; 503 with what's wrong otherwise. For uptime checks.

How the data is collected

Every 15 minutes the crawler opens a P2P connection to every registered masternode's Core address, to every node that answered in the past week, and to new addresses learned from our dashd and from other nodes' getaddr replies (in addrv2, so including Tor, I2P and CJDNS addresses). Onion peers are reached through Tor, I2P peers through I2P and CJDNS peers through a cjdns node; IPv6 only when our host has an IPv6 route. It completes the version handshake and disconnects, after reading a masternode's MNAUTH answer to the challenge in our version, which says on any network which masternode it is. It announces itself as /dash-nodes:…(radar.dashhq.org)/, doesn't relay transactions and keeps nothing but what the node announces. Masternode registration data and payments come from our own dashd; Platform data from evonodes' DAPI (unproved gRPC-web, each answer confirmed by a second evonode), and an evonode's page checks its own numbers against Platform's proofs in your browser. Reachability is measured from one vantage point, so a node that blocks or rate-limits us shows as unreachable even when others can reach it.

Non-masternode IP addresses are never published, only counted.

This site and API are served by Cloudflare from documents the crawler publishes after each crawl, so they stay up when the crawler doesn't; the header says when the last crawl finished.