Solbeat is an open-source, auto-updating dashboard for the state of the Solana network: TPS, slot time, validators, Real Economic Value (REV), TVL, stablecoins, DEX volume, tokenized equities, sentiment and anomaly detection. It uses zero API keys and only the Python standard library.

What does Solbeat cost to run?

Zero dollars per month. GitHub Actions collects data every 30 minutes and GitHub Pages/Vercel serve the site on free tiers; there are no servers or subscriptions and no scheduled maintenance.

What is REV (Real Economic Value) on Solana?

REV is base fees plus priority fees plus Jito MEV tips — the total economic value users pay the Solana network. Solbeat computes it from DeFiLlama chain fees and the Jito Kobe API, following the Blockworks methodology.

What is the difference between Solana TPS and non-vote TPS?

Headline Solana TPS includes validators' consensus vote transactions; non-vote (user) TPS counts only real user transactions and is the honest activity number. Solbeat always shows both side by side.

What is Solana's Nakamoto coefficient?

The minimum number of validators controlling more than one third of total stake — the smallest set that could halt consensus. Solbeat computes it live from getVoteAccounts.

How often does Solbeat update?

Every 30 minutes via GitHub Actions, with a browser-side live layer that re-syncs the slot counter every 10 seconds from a keyless RPC.

Does Solbeat need API keys?

No. All 16 default data sources are public keyless endpoints. Optional env-gated extractors exist for Dune and X/Twitter, both sized to free tiers.

Solbeat documentation

Solbeat is an autonomous, zero-API-key terminal for the state of the Solana network: Python standard library only, no frameworks, no chart libraries, no servers, no secrets. These docs cover how it's collected, analyzed and presented, how to run and deploy your own, and how to contribute.

Quickstart

Requirements: Python 3.9+ and an internet connection. Nothing else — no pip install, no .env, no API keys.

git clone https://github.com/andreolf/solbeat && cd solbeat
python3 solbeat.py run       # one full refresh: collect + render (~30-60s)
python3 solbeat.py verify    # cross-check the numbers against independent sources
python3 solbeat.py serve     # serve docs/ on :8017, auto-refreshing every 30 min

Outputs land in docs/: index.html (dashboard), report.md, data.json, llms.txt, history.json.

Architecture

15 keyless sources→ collectors + provenance→ derived metrics (REV…)→ anomaly engine→ snapshot (data.json)→ HTML · Markdown · JSON · llms.txt

Two files: solbeat.py (collectors, derived metrics, anomaly engine, Markdown/JSON renderers, CLI) and solbeat_html.py (the HTML terminal: server-side SVG charts, world map, live-JS layer). A GitHub Actions cron runs the whole loop every 30 minutes and commits the refreshed docs/; GitHub Pages and Vercel both serve straight from the repo. There is no server-side rendering at view time and no runtime dependency: the published page is a single self-contained HTML file.

Every collector is individually wrapped: a failing source degrades gracefully and is reported honestly in the provenance panel (status, latency, fetch time per source) instead of breaking the report.

How data is collected

Source	Endpoint	Feeds
Solana mainnet RPC	`api.mainnet-beta.solana.com`	`getSlot`, `getBlockTime` (chain clock), `getEpochInfo`, `getRecentPerformanceSamples` (TPS, non-vote TPS, measured slot time), `getVoteAccounts` (validators, stake, commission, delinquency), `getSupply`, `getInflationRate`, `getRecentPrioritizationFees`, `getHealth`, `getVersion`, `getBalance` (exchange reserves), `getSignaturesForAddress` (program pulse)
CoinGecko (free)	`api.coingecko.com`	SOL price, market cap, 24h change, 60-day daily series
DeFiLlama	`api.llama.fi` · `stablecoins.llama.fi`	Chain TVL + history, DEX volumes + venues, chain fees/revenue, stablecoin supply + history, xStocks tokenized-equities TVL
Jito Kobe	`kobe.mainnet.jito.network`	Network MEV tips per epoch (REV input)
Stakewiz	`api.stakewiz.com`	Validator names, geolocation (world map), country stake distribution, BLS-key registration (Alpenglow readiness)
GitHub API	`api.github.com`	Latest Agave release, SIMD-0525 proposal state
solana.com	`solana.com/news/rss.xml`	Official ecosystem news headlines
Solana status page	`status.solana.com`	Operational status, unresolved incidents
Dune (optional)	`api.dune.com`	Any query's latest results (e.g. daily active addresses) — enabled by `DUNE_API_KEY` + `DUNE_QUERY_ID`; off by default to preserve the zero-key design

The browser adds one more live layer at view time: the page polls PublicNode (a keyless, browser-friendly RPC — the official public endpoint rejects browser origins) to re-sync the slot counter every 10s and refresh TPS/slot time every 60s, degrading gracefully to extrapolation.

How data is analyzed

Derived metrics

REV (Real Economic Value), Blockworks methodology: REV(24h) = chain base+priority fees (DeFiLlama dailyFees) + Jito MEV tips. Tips are Kobe's per-epoch total converted to a daily rate using the measured slot time, priced at spot. Labeled "computed" wherever shown.
Average fee per user transaction: chain fees ÷ estimated daily non-vote transactions (vote transactions would dilute it).
Nakamoto coefficient: minimum validators controlling >⅓ of stake, from getVoteAccounts.
Upgrade evidence: measured slot time vs SIMD-0525's 350ms step; BLS-registered stake share as Alpenglow readiness.

Anomaly engine — two layers

Per-metric scoring: z-scores against the best available baseline — TPS/slot time vs the last ~12h of performance samples; price/TVL/stablecoins/DEX vs their 30–90-day daily series (so detection works from the very first run); REV vs the cross-run history. Absolute thresholds cover delinquent stake, slow slots, and >10% daily SOL moves.
Multi-source correlation: co-firing signals are classified into named incidents with plain-language narratives — network incident (throughput + slots/delinquency), consensus stress, market-wide move, liquidity rotation. A TPS drop that coincides with a delinquency spike is a different story than a quiet Sunday, and the report says which.

How data is presented

Output	What it is
index.html	Dark terminal dashboard: live slot counter (real RPC re-sync + LIVE badge), REV clock, ticking lifetime-tx counter, sparklines, status-page-style anomaly strips (every tick click-inspectable with date · value · change), validator world map (1,200 geolocated nodes, dot size = stake, click any dot), named validator table, program activity pulse, exchange reserves, the Almanac (commentary + upgrade cards + news), and a provenance chip for every source.
report.md	The full report as Markdown tables plus a generated analyst commentary.
data.json	Schema-versioned structured snapshot: every metric, anomaly findings, incidents, and per-source provenance. All three formats render from the same snapshot in the same run, so they can never disagree.
llms.txt	Agent manifest (llmstxt.org), regenerated each refresh with current headline numbers and machine-readable pointers.

Configuration

Knob	Where	Effect
`SOLBEAT_REFRESH`	env var	Refresh interval in seconds for `serve` mode (default 1800)
cron line	`.github/workflows/solbeat.yml`	Hosted refresh cadence (default every 30 min)
`DUNE_API_KEY` + `DUNE_QUERY_ID`	env vars / repo secret + variable	Enables the optional Dune extractor (daily active addresses tile)
`X_BEARER_TOKEN` + `X_HANDLES`	env vars / repo secret	Enables the optional X/Twitter extractor — latest posts from key ecosystem accounts (default @solana, @mert), sized to fit X's free API tier
`CONFIG`, `ANOMALY_THRESHOLDS`, `WHALE_WALLETS`, `PROGRAMS`	top of `solbeat.py`	RPC URL, history window, z-score/delinquency/slot-time thresholds, tracked exchange wallets and programs

Self-audit — trust the numbers

python3 solbeat.py verify cross-checks the latest snapshot against independent sources and internal arithmetic:

SOL price (CoinGecko) vs Binance's public ticker
Market cap vs RPC circulating supply × price
Reported slot time vs a live 5-second slot-advance measurement
TVL vs DeFiLlama's separate /v2/chains endpoint
REV arithmetic, top-10 stake share sums, epoch progress math

Exit code is non-zero on any failure, so it can gate CI. A typical run passes 7/7 with cross-venue price agreement around 0.3%.

Deploy your own

Fork the repo on GitHub.
Enable Actions (Actions tab → enable workflows). The 30-minute cron starts collecting and committing on its own.
Enable Pages: Settings → Pages → deploy from branch main, folder /docs. Your dashboard is live at <you>.github.io/solbeat.
Optional: import the repo into Vercel (the included vercel.json serves docs/ statically) for a custom domain and analytics.

Total infrastructure cost: $0. Total secrets: 0.

Contributing

Contributions are welcome — see CONTRIBUTING.md. The short version:

Ground rules: Python stdlib only; every data source must be public and keyless (optional key-gated extractors are fine if off by default); the published HTML must stay a single self-contained file.
Good first contributions: new keyless sources, new derived metrics, better anomaly heuristics/correlation classes, additional exchange wallets or program IDs (with attribution evidence), accessibility and mobile polish.
Workflow: open an issue describing the metric/source, then a PR. Run python3 solbeat.py run && python3 solbeat.py verify before submitting — verify must pass 7/7.

Glossary

Plain-language definitions for every metric on the dashboard.

Term	Meaning
TPS (vote vs non-vote)	Transactions per second. Solana validators vote on-chain, so headline TPS includes consensus votes; non-vote ("user") TPS counts only real user transactions. Solbeat always shows both.
Slot / slot time	Solana's basic unit of block production (~one block per slot). Historic target 400ms; SIMD-0525 is stepping it down to 200ms — Solbeat measures the live value from performance samples.
Epoch	~432,000 slots (about 1.6-2 days). Stake activations and validator rewards settle per epoch.
REV (Real Economic Value)	Base fees + priority fees + Jito MEV tips — the total users actually pay the network per day. Coined by Blockworks; Solbeat computes it from DeFiLlama fees + the Jito Kobe API.
Priority fee	Optional fee (micro-lamports per compute unit) paid to prioritize a transaction. Median near zero means an uncongested network.
Jito tips / MEV	Payments to validators through Jito's block engine for transaction ordering (Maximal Extractable Value). A large share of validator income.
Nakamoto coefficient	The minimum number of validators that together control >⅓ of stake — enough to halt consensus. Higher is more decentralized.
Delinquent validator	A validator that has stopped voting on recent slots. Solbeat tracks delinquent count and delinquent stake share, with alerts.
Stake / commission	SOL delegated to a validator; commission is the validator's cut of staking rewards.
Alpenglow (SIMD-0236)	Solana's largest consensus upgrade: Votor + Rotor replace TowerBFT/PoH voting, targeting ~150ms finality. Validators must register BLS keys — Solbeat measures registration live.
SIMD-0525	Proposal reducing slot time 400→200ms in four feature-gated steps. Step one (350ms) is active on mainnet — Solbeat's measured slot time is live proof.
BLS keys	New cryptographic keys validators register for Alpenglow's vote aggregation. Registration share = upgrade readiness.
TVL	Total Value Locked — capital deposited in the chain's DeFi protocols.
xStocks	Tokenized equities (real-world stocks) issued on Solana; Solbeat tracks their TVL as the bounty's "tokenized asset volumes" metric.

FAQ

What does it cost to run?

$0/month. GitHub Actions (free tier) collects and commits; GitHub Pages or Vercel (free tier) serves. There are no servers, databases, or subscriptions, and nothing scheduled for a human to maintain. Enabling the optional Dune and X extractors keeps total cost between $0 and ~$5/month.

How often does the data refresh?

Every 30 minutes end-to-end (configurable via one cron line or SOLBEAT_REFRESH). Between refreshes, the browser itself polls a keyless RPC so the slot counter, TPS and slot time stay live.

Can I run or self-host it?

Yes — git clone, then python3 solbeat.py run. Python 3.9+ is the only requirement. See Deploy your own for the zero-cost hosted setup.

Is Solbeat affiliated with the Solana Foundation?

No — it's an independent, MIT-licensed community project. For the network's official status page see status.solana.com.

Why zero API keys?

Every unified Solana dashboard so far has died or gone behind API keys — keys are the industry's revenue model, and key-dependent projects rot when tiers change. Zero keys means nothing to revoke, reprice, or expire.

Why is Dune optional instead of built-in?

Every Dune access path requires an API key, which conflicts with the zero-key default. The extractor ships env-gated: automated for anyone with a key, invisible without one.

Where are daily active addresses?

No keyless source exists (Solscan, Dune and Blockworks all gate it). Non-vote TPS is shown as the transparent, labeled activity proxy — or enable the Dune extractor for a first-class DAA tile.

Why no X/Twitter feed?

X's keyless endpoints (syndication CDN, nitter) are dead in 2026. Official announcements come from solana.com's news RSS, GitHub releases/SIMD state, and the status page instead.