How to Check If Your Node Is Synced

How to Check If Your Node Is Synced

Published
AuthorDevansh

You started the node, the logs are moving, and now comes the first real question: is it actually synced? A node that is still syncing serves stale data. An RPC endpoint behind the chain tip returns old balances, an explorer shows old blocks, and a validator that thinks it is synced when it is not misses attestations. Checking sync properly takes two minutes, and it is worth doing properly, because the quick check has a trap: it can tell you the node is synced when it is really just stuck. This post covers the quick check, the reliable check, and the per-chain commands for Ethereum, Solana, and Cosmos.

If you have not set up the node itself yet, start with our validator on Ubuntu guide or our testnet setup guide. This post assumes the node is running and answers one question: how do you know it has caught up with the chain?

What synced actually means

Synced means three things at once, and all three have to be true. First, your node has downloaded the blocks up to the current chain tip. Second, it has executed the transactions in those blocks, so it holds the current state: balances, contract storage, and nonces. A node can have the blocks and still be behind on state, which is why block count alone is not the whole story. Third, it is keeping up: new blocks arrive and are processed within seconds, so the gap never grows again. On Ethereum this also means two clients agree: the execution client and the consensus client both have to be synced, and a healthy execution client with a stalled consensus client is still an unsynced node. Our RPC explainer covers why this matters for anything that reads from the node.

The quick check: eth_syncing

On any Ethereum-compatible chain, the fastest check is the eth_syncing JSON-RPC method. If the node is still syncing, it returns an object with startingBlock, currentBlock, and highestBlock. If it is fully synced, it returns false. From the server, with the RPC port reachable only locally:

curl -X POST http://localhost:8545   -H "Content-Type: application/json"   -d '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}'

A syncing node answers with a progress object, for example currentBlock well below highestBlock. A synced node answers with result: false. The same call works in the Geth console as eth.syncing. But here is the trap: eth_syncing returns false in two opposite situations. It returns false when the node is fully synced, and it also returns false when the node is not syncing at all - freshly started, stalled, or waiting on its consensus client, with nothing to report. A node stuck at a block from last week, its execution head frozen, can happily return false. So eth_syncing tells you whether a sync is in progress, not whether you are at the tip. Never treat false as proof on its own.

The reliable check: compare against a reference

The check that actually proves sync is a comparison against an independent reference. Ask your node for its latest block number, then ask a second source - a public RPC endpoint, a block explorer, or a second node you run - for the same number. If they match, you are at the tip. If yours is behind, you are still syncing or stuck, whatever eth_syncing said.

curl -X POST http://localhost:8545   -H "Content-Type: application/json"   -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Convert the hex result to a number and compare it with the explorer. A second, independent check is the timestamp of your latest block: if the newest block your node holds is minutes or hours old while the chain produces a block every 12 seconds, your node is not keeping up. Repeat the check a minute later. A synced node advances with the chain; a stuck node shows the same block number twice. This pair - block height against a reference, plus a fresh timestamp - is the check to build into monitoring. Our Grafana monitoring guide shows how to turn it into an alert that pages a human before users notice.

The same check on Solana and Cosmos

Every chain has its own version of the same idea. On Solana, the solana catchup command shows how many slots behind the network your validator is, and the slot distance should fall steadily toward zero. A validator whose slot distance is not shrinking is not syncing, it is stuck, and the fix is usually peers, disk, or a snapshot. On Cosmos chains, the node status command reports a SyncInfo block with a catching_up field: false means the node believes it is caught up, and the latest block height and time in the same output tell you whether that belief is right. The pattern is identical on every chain: ask the node where it thinks it is, ask the network where the tip is, and trust the comparison, not the single number.

When sync is stuck: the usual suspects

If the gap is not shrinking, work through the list in order. First, peers: a node with zero or one peer cannot learn about new blocks, so check the peer count and add bootnodes or persistent peers from the chain docs if it is empty. Second, disk: a full or nearly full disk stops sync silently, and chain data grows every day, so check free space before anything else. Third, the consensus client on Ethereum: an execution client cannot finish syncing if its consensus client is behind, so check both. Fourth, clock skew: a server clock minutes off wall time confuses peer connections, so confirm NTP is running. Fifth, logs: search for repeated errors about bad peers, corrupt data, or failed state downloads, and read the actual error instead of restarting blindly. If the node is far behind and the gap is not moving, a snapshot sync from a trusted snapshot is usually faster than waiting for a stalled sync to recover. Our snapshot sync guide covers when to use one and how to verify it. Do not delete the database and start over as a first step: a resync from genesis takes far longer than a repair, and it is the last resort, not the first.

Make the check automatic

A sync check you run by hand once is a habit. A sync check that runs every minute is monitoring. Put the block-height comparison into a script or a Prometheus check: query your node and a reference endpoint, compute the gap, and alert when the gap grows past a threshold you set per chain, for example more than a few blocks behind for more than a few minutes. Alert on the gap, not on eth_syncing alone, because of the false trap above. Record the sync history too, so when a node falls behind you can see whether it has been drifting for an hour or just had one slow minute. And after any restart, upgrade, or snapshot restore, run the manual check before you declare the node healthy: the restart is not done when the process starts, it is done when the node is back at the tip and staying there.

Synced is not a feeling, it is a measurement: your latest block against the network latest block, checked twice, a minute apart. The quick RPC call is a useful first look, and the comparison is the proof. If you want that check built into your node, RPC, or validator setup, or an alert that fires before a stale node becomes an incident, book a free infra audit with DevOpsBY. We run nodes, RPC, and validator infrastructure for Web3 teams, and a sync check that actually proves the node is at the tip is one of the first things we wire up.

Disclaimer: This post is educational only, not financial advice. Figures are listing or project data as of 2026-11-11 and may change - always confirm version numbers, requirements, and dates in the official docs before acting on them.

Related Articles

DevOps & Infrastructure Services

Need hands-on help? We build and manage the infrastructure behind the concepts covered in this article.

DevOpsBy Assistant

How can we help?

Select a topic to get started: