Quick answer: A missing trie node error on Core means you asked a node for state (a balance, contract storage, code or an eth_call result) at a block it no longer keeps state for. The default public endpoint https://rpc.coredao.org only kept state for the last 127 blocks in our tests, which is about six minutes on Core. To fix it, query "latest" or a very recent block, or send historical queries to Core’s archive endpoint https://rpcar.coredao.org.
The error looks scary because it prints a long hash, but nothing is wrong with your wallet, your funds or the chain. Here’s what the message means, how we reproduced it on Core mainnet (chain ID 1116), and the fixes for scripts, dashboards and tax tools.
What the error looks like
Here’s a typical JSON-RPC response from a Core full node:
{"jsonrpc":"2.0","id":1,"error":{"code":-32000,
"message":"missing trie node d2f7d056...21ae4 (path ) state 0xd2f7d056...21ae4 is not available, not found"}}
Libraries like ethers.js and web3.py usually wrap this in a generic “server error” or “could not coalesce error” exception, so search the raw message for the words missing trie node. The same family of errors includes required historical state unavailable, which tracing methods return for the same reason.
Why it happens: full nodes vs archive nodes
Core’s node software is a fork of Geth (the public RPC reported Geth/v1.0.27 when we checked on 16 November 2026). An EVM node stores two quite different kinds of data:
- Chain history: blocks, transactions, receipts and logs. Full nodes keep all of this.
- State: the balance, nonce, code and storage of every account at a given block, stored in a Merkle Patricia “trie”. A normal full node keeps only a short sliding window of recent states and prunes older ones.
The Core-Geth archive node guide explains that a node on default settings keeps the state of its 128 most recent blocks. If you ask about an older block, it returns exactly the missing trie node ... is not available, not found message above. Chainstack’s troubleshooting note lists the calls that are affected: eth_getBalance, eth_getStorageAt, eth_call, eth_getCode and traces.
An archive node keeps every state since genesis. Core’s own node overview says archive nodes “store the entire history of the blockchain, including all states and transactions since the genesis block”, and the archive node setup page recommends at least a 4 TB SSD, an 8-core CPU and 32 GB of RAM for mainnet. That cost is why most public endpoints are full nodes.
What we measured on Core’s public RPC
On 16 November 2026 we sent read-only JSON-RPC requests with curl. We used no keys and sent no transactions. We asked for the CORE balance of a system contract address at different depths below the chain head (block ~40,495,000 at the time):
| Query | rpc.coredao.org | rpcar.coredao.org (archive) |
|---|---|---|
eth_getBalance at head − 127 blocks | Balance returned | Balance returned |
eth_getBalance at head − 128 blocks or older | missing trie node | Balance returned |
eth_call / eth_getCode at block 16,777,216 | missing trie node | Works |
eth_getLogs / eth_getBlockReceipts at block 16,777,216 | Works | Works |
eth_getTransactionReceipt by hash, tx older than ~2.35M blocks | Returns null | Receipt returned |
Recent Core blocks were about 3 seconds apart in our sample, so a 128-block window covers only about 6–7 minutes. The ZAN endpoint listed in Core’s docs gave the same error for old blocks. The Ankr and dRPC public endpoints returned historical balances, but third-party behaviour and rate limits can change without notice.
The last row is a separate quirk that’s easy to confuse with this error. Geth’s default transaction index (--history.transactions) covers the most recent 2,350,000 blocks. On the regular endpoint, a lookup by hash for an older transaction quietly returns null instead of an error, and the cut-off we measured matched that default. The block and its receipts are still there; only the hash-to-block index is gone.

How to fix “missing trie node” on Core
1. Use “latest” if you don’t actually need history
Many scripts pass a hard-coded or cached block number by accident. If you just want a current balance, use the "latest" tag, or "finalized" if you want a block that can’t be reorganised (see our Core finality explainer). Both worked on rpc.coredao.org in our test.
curl -s -X POST https://rpc.coredao.org \
-H 'Content-Type: application/json' \
--data '{"jsonrpc":"2.0","id":1,"method":"eth_getBalance",
"params":["0xYourAddress","latest"]}'
2. Send historical state queries to the archive endpoint
Core’s official RPC list includes https://rpcar.coredao.org “(For Archive Node)” for mainnet and https://rpcar.test2.btcs.network for Testnet2 (chain ID 1114). Swap the URL only for calls that need old state, such as a balance on 31 December for a year-end report. Keep normal traffic, and especially transaction sending, on your usual endpoint.
curl -s -X POST https://rpcar.coredao.org \
-H 'Content-Type: application/json' \
--data '{"jsonrpc":"2.0","id":1,"method":"eth_getBalance",
"params":["0xYourAddress","0x1000000"]}'
3. Rebuild history from logs and receipts
If you’re tracking token transfers, you often don’t need old state at all. eth_getLogs and receipts are chain history, and they worked for old blocks even on the full node. Add up the Transfer events to rebuild a balance timeline. For personal records, it’s usually simpler to export your activity from Core Scan, as we show in how to export Core transaction history to CSV.
4. Pin multi-step jobs to a recent block
A slow script can fetch a block number, do some work, and then query state at that block after it has fallen out of the 128-block window. Re-read the block number right before each batch, or retry once with a fresh block number when you see this error. Don’t retry forever against the same old block, because the state won’t come back.
5. Run your own archive node (only for heavy use)
Analytics teams that need large volumes of historical reads can run a node with --gcmode=archive --syncmode=full, as described in Core’s archive node docs. The Core-Geth guide warns that a node switched to archive mode after a snap sync still has no state from before its sync pivot. You need a full sync from genesis or Core’s archive snapshot. For most individuals this is overkill.
Is my money at risk?
No. This is a read-only data-availability error on the server side. It doesn’t mean a transaction failed or that funds have moved. If a wallet or dApp shows it, the app is querying old state from a pruned node. Check your balance directly on Core Scan (our Core Scan guide shows how) and report the bug to the app. If you’re debugging contract calls, a real revert shows a different message, which we cover in “execution reverted” explained.
FAQ
Does “missing trie node” mean my node is corrupted?
Usually not. On a healthy full node it simply means the block is outside the retained state window. It points to a real problem only if you get it for "latest" on a node you run yourself, for example during an unfinished sync.
How far back can I query state on rpc.coredao.org?
In our 16 November 2026 test, 127 blocks back worked and 128 blocks back failed, which is roughly six minutes. The operator can change this at any time, so don’t hard-code the number.
Why does eth_getTransactionReceipt return null for an old Core transaction?
That’s the transaction index limit (about 2.35 million blocks by default), not state pruning. Use the archive endpoint, or look up the block and call eth_getBlockReceipts.
Is the archive endpoint free and unlimited?
Core lists it publicly, but we found no published rate limits. Treat it as a shared resource: cache results and avoid hammering it in loops.
Disclaimer: This article is for general educational purposes only and is not financial, tax or investment advice. RPC behaviour was tested on 16 November 2026 and may change; always verify against official Core documentation.
