# monerometrics — full reference for language models

> monerometrics is a free, reorg-aware observatory of the Monero (XMR) network.
> It runs its own Monero node, indexes every block from the genesis block to the
> current tip, and exposes chain reorganizations, orphan blocks, network hashrate,
> block time, mempool state, block emission and mining-pool distribution through a
> public read-only API and an interactive dashboard. No account, no API key, no
> rate-limit tiers, no tracking, no ads.

- Website: https://monerometrics.net/
- API base: https://api.monerometrics.net/
- OpenAPI schema: https://api.monerometrics.net/openapi.json
- Source code (MIT): https://github.com/nowi333/monerometrics
- Tor hidden service: 6wbhchvavey26lbtscl6w6qg76balycixtsklcggrsslyk4xah6sbbad.onion

## What it does

monerometrics answers one question that most explorers ignore: how healthy and how
decentralized is the Monero network right now, and how has it behaved over time. It
focuses on chain stability (reorganizations and orphan blocks) and on mining
centralization, rather than on individual transactions (which on Monero are private
by design and cannot be inspected).

Everything is measured from a self-hosted Monero node, not scraped from third-party
explorers. Historical series are stored so they can be queried over windows from one
hour to five years.

## Key definitions

- Chain reorganization (reorg): the network replaces one or more recent blocks with
  a competing branch that becomes the canonical chain. A reorg of depth N means N
  blocks were rolled back. Reorgs are normal at depth 1 but deeper or frequent reorgs
  can signal instability or an attack.
- Orphan block: a valid block that was mined but is not part of the final canonical
  chain, because a competing block at the same height won. Orphans are kept in history
  and shown next to the canonical chain.
- Fork point: the height of the first block that was replaced. The branches share every
  block below it; a reorg of depth N rewrote the heights from the fork point to the fork
  point plus N minus one.
- Nakamoto coefficient: the minimum number of mining pools that together produce more
  than 50% of blocks over a window. Lower means more centralized.
- Largest-pool share: the percentage of blocks produced by the single biggest pool
  over a window.
- Merge mining: Monero blocks can carry an auxiliary-chain tag (for chains merge-mined
  with Monero). monerometrics records whether a block is merge-mined.
- Coinbase: the first transaction of a block, which pays the block reward to the miner.
  It is the only part of a Monero block whose recipient can be checked, and only when
  the pool has published the matching wallet view key.

## How reorg and orphan detection works

Two passes run on every poll (every 30 seconds).

- Reorgs: the indexer re-checks a rolling window of the last 60 blocks against the node.
  When a block it had already indexed at a given height has been replaced by a different
  hash, the old block is recorded as an orphan and a reorg event is written with its fork
  point, depth and the number of affected transactions.
- Orphans: most competing blocks are settled within seconds, before the next poll, so the
  rescan alone would miss them. The indexer therefore also reads the node's own
  alternative chains and records every competing block the node has seen as an orphan,
  including those that never became canonical. The node keeps these blocks across
  restarts and accepts inbound peers, which widens what it sees.

Both only work in real time: reorgs and orphans are captured from the moment live
indexing began, and cannot be reconstructed for the distant past, since the network only
retains the winning chain. Orphan counts reflect what one node observed; another node may
have seen a few competing blocks this one did not.

## How mining-pool attribution works

Attribution is verified, not guessed. In order of strength:

1. View-key proof (cryptographic): some pools publish the wallet view key for their
   payout address. For those, monerometrics derives the one-time output key of the
   block's coinbase and checks whether it belongs to the pool's address. A match is
   mathematical proof that the pool mined the block, verifiable by anyone with the
   pool's public address and view key. This works retroactively for as long as the
   pool used that address.
2. Public pool block lists (self-reported): many pools expose an API listing the
   blocks they found (height and hash). monerometrics cross-references these. This is
   trustworthy to the extent the pool's own API is honest, and ranks below view-key
   proof.
3. p2pool detection (structural): p2pool pays all its miners directly in the coinbase,
   so a p2pool block has many coinbase outputs instead of one. That structure is a
   reliable fingerprint for p2pool blocks after its launch.

Blocks that match none of the above are reported as unknown, never guessed. Solo
miners and pools without a public key or block list legitimately stay unknown. Deep
historical blocks (before pools existed or before they published keys) are shown as
header-only history: real height, hash and timestamp, but no pool attribution and no
past-fork data.

Each attributed block carries a source tag: viewkey_proof, pool_api,
pool_api_unproven, or coinbase_heuristic, so the strength of every attribution is
transparent.

## How the peer-to-peer market is measured

Alongside the chain itself, monerometrics tracks the Haveno (RetoSwap) XMR/USD market,
the largest non-KYC venue for Monero against fiat, and prices it against centralized
spot from CoinGecko with Kraken as fallback.

Both sides of the order book are measured. Sell offers ("asks") are what it costs to
buy XMR; buy offers ("bids") are what you are paid when you sell. For each side we
report the best offer and the amount-weighted average of every offer, weighted by
offer size so that a tiny offer at an unrealistic price does not move the average the
way a large one does. Cumulative depth at a given price is the sum of every offer at
least that good, which is what the order-book panel draws as a staircase.

round_trip_cost_pct is the average ask divided by the average bid, minus one: the cost
of buying XMR and selling it straight back with the price unmoved. It runs at roughly
three times the headline premium, because the two sides of this book are not
symmetrical. It is deliberately built from the averages rather than the best offer on
each side, so it should be read as an upper bound: a small trade that never leaves the
first price level does better, a trade that walks the book does not.

Executed trades are also grouped by payment method. The premium tracks reversibility
and convenience rather than privacy: rails that let a buyer claw funds back after the
Monero is released (PayPal, Wise, Cash App, Venmo) carry the largest premiums, while
irreversible rails (Zelle, cash by mail) sit near or below spot. Every one of those
trades is equally non-KYC, so the spread between them is not the price of privacy.
The reversible flag is our own classification, not a Haveno field.

Limits: only the USD pair carries meaningful volume; Haveno offers are advertisements
with differing payment methods rather than a matched order book, so nothing executes
automatically and the best bid can sit at or above the best ask; each offer carries a
minimum size, so a deep price level is not necessarily reachable in small amounts; and
the premium history starts on 24 August 2026, when recording began, because no
historical series is published upstream and it cannot be backfilled.

## Chain fork visualizer

An interactive visualizer renders the canonical chain and competing orphan branches.
It covers the whole chain: you can search any block height or 64-character block hash
and jump straight to it, all the way down to the genesis block (height 0). Loading is
lazy and viewport-bounded, so it stays fast regardless of how far back you go. Each
block shows its height, short hash, mining pool, attribution-evidence dot and a
merge-mining marker. The "Recent orphan blocks" table links each orphan to its position
in the visualizer.

## Public API

Base URL: https://api.monerometrics.net/ — free, public, read-only, JSON. Full
machine-readable description at /openapi.json.

- GET /health — service liveness.
- GET /network/info — current height, difficulty, hashrate, mempool size.
- GET /network/hashrate?window=1h|24h|7d|30d|90d|1y|5y — network hashrate time series.
- GET /network/blocktime?window=... — block-time variance time series.
- GET /network/mempool?window=... — mempool size time series.
- GET /network/emission?window=... — block reward / emission time series.
- GET /price — centralized spot (CoinGecko, Kraken fallback) plus both sides of the Haveno XMR/USD book: best and amount-weighted average offer on each side, resting depth, offer counts and round_trip_cost_pct.
- GET /price/spread?window=24h|7d|30d|90d|1y — the same both-sided premium over time, sampled every 10 minutes.
- GET /haveno/book — the live Haveno XMR/USD order book, both sides, as price levels with cumulative depth, offer count, payment methods and a reversible flag, each priced against spot.
- GET /haveno/methods?window=&currency= — executed Haveno trades grouped by payment method, with average, median and standard deviation of the premium.
- GET /haveno/liquidity?window=&currency= — XMR resting in open Haveno offers, hourly, back to November 2024.
- GET /haveno/trades?limit=&currency= — recent executed Haveno trades with payment method, price and premium.
- GET /network/fees — current Monero fee tiers; /network/fees/history?window= for the time series.
- GET /reorgs — detected chain reorganizations.
- GET /reorgs/stats — reorg counts, depth and affected transactions over windows.
- GET /orphans/recent?window=24h|48h|7d|30d|90d|180d|1y|all&limit= — orphan blocks over a window (default 30d, newest first, limit up to 500), each with its canonical counterpart at the same height.
- GET /chain/window?from=&to= — canonical blocks in a height range.
- GET /chain/fork-window?limit=&to= — canonical chain plus competing orphans around a height; `to` selects the window, enabling browsing down to the genesis block.
- GET /chain/block/{hash} — full detail for one block (height, prev hash, size, difficulty, reward, coinbase, tx list, merge-mining tags).
- GET /chain/provenance?window= — how attribution was established over a window (share proven by view key, by pool API, etc.).
- GET /pools/distribution?window=1h|6h|24h|48h|7d — mining-pool block shares, largest-pool share and Nakamoto coefficient.
- GET /pools/sources — reachability of each pool API used for attribution.

## FAQ

Q: What is monerometrics?
A: A free, reorg-aware observatory of the Monero (XMR) network, run from a self-hosted
node, with a public read-only API and no tracking.

Q: Does it show individual Monero transactions?
A: No. Monero transactions are private by design. monerometrics measures network-level
health and mining decentralization, plus the coinbase (miner reward) where a pool has
published its view key.

Q: Can I explore old blocks?
A: Yes. The fork visualizer lets you search any height or hash and jump to it, down to
the genesis block, with lazy loading.

Q: How reliable is the pool attribution?
A: View-key attributions are cryptographic proof. Pool-API attributions are the pool's
own claim. Anything unmatched is reported as unknown, never guessed.

Q: Is it really free?
A: Yes: no account, no API key, no rate-limit tiers, no tracking, no ads. Source code
is MIT-licensed.