© 2026 Della Group. All Rights Reserved.
Here's the deal: You're hyped about tracking Solana's TPS live, seeing that 646 TPS spike or whatever it's hitting right now, and you want a no BS guide to monitor it yourself. Cool. I got you. This isn't some fancy dashboard tutorial-it's hands on stuff so you can watch non vote transactions fly by in real time, without waiting for someone else's site to load. Solana's beastly fast, theoretically up to 65,000 TPS, but real world? It's more like 400-2,000 non vote TPS on busy days, spiking to 646 or higher during memecoin madness. Why track it? Traders spot congestion before it tanks their swaps. Devs debug why their dApp's lagging. Stakers check if validators are slacking on those 400ms blocks.
Okay, before we build anything, hit these sites. They're live, free, and update every few seconds. SolanaCompass is my go to-shows raw TPS, non vote TPS (the real deal, ignoring validator votes), vote TPS, blocks per second, and block time. Right now, non vote might be chilling at 500ish, but watch it climb.
Pro move: Open SolanaCompass in one tab, Solscan in another. Compare non vote TPS-disagrees sometimes 'cause of how they filter votes. If TPS dips below 200 non vote, network's quiet. Above 1,000? Congestion incoming, fees might jump to 0.00001 SOL.
The thing is, dashboards lag 5-10 seconds sometimes during surges. High TPS chains like Solana need real time data or you miss trades. In my experience, building a simple one teaches you the blockchain guts-plus it's free forever.
We'll use Rust 'cause Solana's SDK shines there. No coding? Skip to dashboards. But if you're game, you'll pull live blocks, filter out vote txs (they're 70-80% of total), and calc TPS over 60 seconds. Hits 646? You'll see it first.
rustup --version. Nope? Grab from rust lang.org-takes 2 mins.https://solana api.projectserum.com or https://api.mainnet beta.solana.com. Rate limited? Get a paid one from Helius or QuickNode (~$9/mo, unlimited calls).Look, this is based on a dead simple Rust script I tweaked from open repos. It grabs recent blocks, counts user txs (non votes), times the period, spits TPS. Run it every 10 seconds for "live" monitoring. Outputs like: "Non vote TPS over 60s: 646.23".
First, make the project.
cargo new solana tps tracker. Cd into it: cd solana tps tracker.solana client = "1.14.6"
solana sdk = "1.14.6"
solana transaction status = "1.14.6"
chrono = "0.4"
log = "0.4.17"
env_logger = "0.9.1"
dotenv = "0.15.0"RPC_URL=https://solana api.projectserum.com. Swap for your endpoint.use dotenv::dotenv;
use solanaclient::{rpcclient::RpcClient, rpc_config::RpcBlockConfig};
use solanatransactionstatus::{EncodedConfirmedBlock, UiTransactionEncoding};
use solanasdk::vote::program::id as voteprogram_id;
use chrono::{DateTime, NaiveDateTime, Utc};
use log::{info, debug};
use std::env; #[tokio::main]
async fn main() { dotenv().ok(); envlogger::init(); info!("🚀 Solana Live TPS Tracker starting.."); let rpcurl = env::var("RPCURL").unwraporelse(|| "https://solana api.projectserum.com".tostring()); let client = RpcClient::new(rpcurl); loop { let tps = calculatetps(&client, 60).await; // 60 seconds window info!("Live Non Vote TPS: {:.2}", tps); tokio::time::sleep(tokio::time::Duration::fromsecs(10)).await; // Update every 10s }
} async fn getblock(client: &RpcClient, slot: u64) -> EncodedConfirmedBlock { let config = RpcBlockConfig { encoding: Some(UiTransactionEncoding::Base64), maxsupportedtransactionversion: Some(0), .RpcBlockConfig::default() }; client.getblockwith_config(slot, config).unwrap()
} fn countusertxs(block: &EncodedConfirmedBlock) -> u64 { let mut usertxs = 0; for txstatus in &block.transactions { if let Ok(transaction) = txstatus.transaction.decode() { let accountkeys = transaction.message.staticaccountkeys(); let instructions = transaction.message.instructions(); let votecount = instructions.iter().filter(|ix| { let progidindex = ix.programidindex; accountkeys.get(usize::from(progidindex)) == Some(&voteprogramid()) }).count(); if votecount != instructions.len() { usertxs += 1; } } } user_txs
} async fn calculatetps(client: &RpcClient, thresholdsecs: u64) -> f64 { let start = Utc::now(); let latestslot = client.getslot().unwrap(); let mut currentslot = latestslot; let mut totalusertxs: u64 = 0; let mut oldesttime = None; let timestampthreshold = start.timestamp() as i64 - thresholdsecs as i64; while let Some(blocktime) = client.getblocktime(currentslot).ok().flatten() { if blocktime <= timestampthreshold { oldesttime = Some(blocktime); break; } let block = getblock(client, currentslot).await; totalusertxs += countusertxs(&block); currentslot = block.parentslot.unwrapor(0); if currentslot == 0 { break; } debug!("Processed slot {}: {} user txs", currentslot, countusertxs(&block)); } let newesttime = Utc::now().timestamp() as i64; let timediff = if let Some(old) = oldesttime { (newesttime - old) as f64 } else { 1.0 }; let tps = totalusertxs as f64 / timediff; if tps.isnan() || tps.is_infinite() { 0.0 } else { tps }
}
Wait, what's this do? Grabs latest slot (block number). Loops back ~60s worth of blocks (15-20 blocks at 400ms each). For each, decodes txs, skips pure vote ones (program ID check: Vote111111111111111111111111111111111111111). Sums user txs, divides by seconds. Loops forever, updates every 10s. Boom-your terminal's a live tracker.
Run it: cargo add tokio --features full first (for async). Then cargo run. First run takes 30s to fetch history. Outputs: "Live Non Vote TPS: 646.42". Scale threshold_secs to 300 for 5-min average.
Stuck? Common crap.
| Issue | Why? | Fix |
|---|---|---|
| RPC errors / timeout | Free endpoint rate limit (100 calls/min) | Switch to Helius free tier or add sleep(1s) between blocks. |
| TPS shows 0 or NaN | No blocktime or quiet period | Check latestslot manually: client.get_slot(). Fallback to 1s diff. |
| High CPU / slow | Fetching 100+ blocks | Lower threshold_secs to 30. Use faster RPC. |
| Vote txs sneaking in | Versioned txs (v0) | Config has maxsupportedtransaction_version: Some(0). Bump to 1 if needed. |
| Cargo build fails | Wrong solana version | Match to 1.18.x latest: check solana.com/docs. |
In my experience, public RPCs crap out at 1,000+ TPS surges-validators skip slots, block time hits 600ms. Solution? Paid RPC with archival data. Costs ~0.3% of what you'd lose missing a trade.
Terminal cool, but want Slack pings at 646 TPS? Add this to main after calc:
if tps > 600.0 { // Use reqwest crate for webhook info!("🚨 TPS spike: {}! Check memecoins.", tps);
}Add reqwest = { version = "0.11", features = ["json"] } to Cargo.toml. Send to Discord webhook. Or pipe output to Grafana-free localhost dashboard.
What's next? Tie to wallets. Use Solscan API (free tier) for wallet TPS contrib. Paste your addr, see if you're 0.01% of network load. Devs: Hook this into your bot for auto swap when TPS <300 (low fees).
Don't just TPS. Watch these together:
SolanaCompass graphs all this. Screenshot spikes, share on Twitter. "Solana at 646 non vote TPS-bullish?"
Morning check: Load Compass, note baseline (200-400 TPS quiet). Midday: Run your Rust script during launches. Evening: Solscan for fee trends-predict tomorrow's gas.
Potential pitfall: Testnet vs Mainnet. Explorers default Mainnet (real SOL). Devnet's fake, TPS lower. Always double check cluster dropdown.
Honestly, once you run that script, you'll never trust dashboards again. They're 5s behind. Customize: Add block/skipped slot count. Threshold for "network healthy" (TPS>500, time<500ms).
Want web UI? Use Tauri + this Rust core. Live chart with 646 TPS peaking. Or Python port with solana py-slower but easier plots via matplotlib.
Monitor specific dApps? Filter txs by program ID (Raydium: 675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8). Calc "Raydium TPS" subset.
Fees deep dive: Total daily SOL burned. Your tx: base 5k compute units * ~0.000005 SOL/kCU. Priority fee? Add 0.001 SOL to jump queue.
Sound familiar? That's Solana-fast, cheap, but vote txs fake the hype. Your tracker cuts through it. Run it now, watch 646 happen live. Hit snags? Tweak the code, it's yours.
© 2026 Della Group. All Rights Reserved.