Full Node vs Archive Node: What's the Difference?

If you've ever tried querying a wallet's balance from two years ago and received an error like "missing trie node", you've hit the invisible wall separating full nodes from archive nodes.

It's one of those things that catches developers off guard. Your code works perfectly for the current data, then you add a historical block parameter, and everything breaks. The node isn't malfunctioning; it's simply not designed to remember that far back.

Understanding this distinction isn't just academic. Choosing the wrong node type can mean wasted hours debugging errors that aren't bugs, or spending thousands on infrastructure you don't actually need.

In this guide, you'll learn the real difference between full nodes and archive nodes, when you genuinely need archive access, and how to get it without running expensive infrastructure yourself.

What's a Full Node?

A full node is a complete participant in the blockchain network. It validates every transaction, enforces consensus rules, and maintains enough state to verify new blocks. But here's the key detail: it doesn't keep everything forever.

How it works behind the scenes

When a full node syncs, it downloads and verifies the entire blockchain history: every block, every transaction. But once verified, it prunes old state data to save disk space. On Ethereum, this means keeping only the last ~128 blocks of complete state.

Think of it like a live news archive. A news channel records and broadcasts everything in real-time, but only keeps the last few days of footage readily accessible. If you want last night's broadcast? Easy. If you want something from three years ago? That's in deep storage; if it exists at all.

The full node remembers that a transaction happened (it's in the blockchain), but not necessarily what the state looked like at that exact moment.

Who it's best for

Most dApp developers (current state is what matters)
Wallet applications checking balances
Smart contract interactions and deployments
Transaction broadcasting and confirmations
Event subscriptions and real-time monitoring

What's an Archive Node?

An archive node is a full node that refuses to forget. It maintains complete historical state at every block height since genesis. Every balance, every contract storage slot, every intermediate state, preserved and queryable.

How it works behind the scenes

Instead of pruning old state, an archive node keeps every "snapshot" of the blockchain. When you query eth_getBalance at block 15,000,000, it doesn't need to replay transactions from that point; it has the answer stored directly.

This is a vault with every document ever filed. Every version of every contract. Every balance at every moment. Nothing gets shredded.

The tradeoff? Storage. A full Ethereum node requires about 1 TB of storage. An archive node? 15+ TB and growing. That's not just disk space; it's enterprise-grade SSDs, specialized sync processes, and weeks of initial synchronization.

Who it's best for

Blockchain analytics platforms
Security auditors and forensic researchers
DeFi protocol historians
Block explorer operators
Anyone debugging historical transaction behavior
Compliance and regulatory teams

Ready to access blockchain data with flexible pricing? Sign up for GetBlock and start building with our RPC endpoints today.

Full Node vs Archive Node: The Real Differences

	Full Node	Archive Node
Current state	✅ Yes	✅ Yes
Recent history (~128 blocks)	✅ Yes	✅ Yes
Full historical state	❌ No (pruned)	✅ Yes (every block)
Disk storage (Ethereum)	~1 TB	~15+ TB
Monthly cloud cost	~$200–500	~$1,500–3,000+
Sync time	Hours to days	Days to weeks
Hardware requirements	Standard SSD	Enterprise NVMe, high IOPS
Primary use case	Production dApps, real-time queries	Analytics, forensics, historical research

When You Don't Need Archive Data

Here's the thing: most developers don't need an archive node.

If your use case involves any of the following, a full node handles it perfectly:

Getting current wallet balances
Sending and signing transactions
Reading the current smart contract state
Subscribing to new events and logs
Fetching recent transaction receipts
Monitoring mempool activity
Deploying and interacting with contracts
Building wallets and payment systems

The full node can answer: "What is the balance now?" It can tell you what happened recently. For 90% of dApps, that's all you need.

When You Actually Need Archive Data

You need archive access when your query includes a historical block parameter and the answer requires state data—not just transaction records.

Clear signals you need to archive:

Querying balances at specific past blocks: eth_getBalance at block 10,000,000 requires knowing the state at that moment
Reading historical contract storage: What was the value of mapping(address => uint256) six months ago?
Running debug_traceTransaction on old transactions: Step-by-step execution traces need the state that existed when the transaction ran
Blockchain analytics across time ranges: Tracking how a protocol's TVL evolved month-over-month
Auditing smart contract state changes: "When exactly did this variable change, and to what?"
DeFi forensics and exploit analysis: Reconstructing the state before, during, and after an attack
Building block explorers with full history: Showing what any address held at any point in time
Compliance reporting: Proving account holdings at specific regulatory checkpoints

The Error That Tells You

When you hit the archive boundary, the blockchain doesn't stay silent. You'll see something like this:

{

  "error": {
    "code": -32000,
   "message": "missing trie node 0x1234...abcd (path ) state 0x5678...efgh is not available, state pruning may have been in progress"
   }
}
//or sometimes
{
  "error": {
    "code": -32000,
"message": "historical state not available"
}}

This isn't a bug in your code. The node is telling you exactly what happened: the state you're asking about was pruned. The solution isn't debugging—it's switching to archive access.

And that's per chain. Need archive access on Ethereum, BSC, and Polygon? Triple it.

Beyond cost, there's the operational reality: archive nodes are maintenance-intensive. A corrupted database means weeks of re-syncing. Client updates require careful coordination. A single misconfiguration can mean data loss.

Archive Data on GetBlock

Instead of building and maintaining archive infrastructure, you can access historical state through GetBlock's ready-to-use endpoints.

Shared Nodes: Archive included

Archive data is available on all GetBlock plans, including Free. You don't need to pay enterprise rates just to query the historical state:

Plan	CU/month	Archive Access
Free	50K/day	✅ Included
Starter	50M	✅ Included
Advanced	220M	✅ Included
Pro	600M	✅ Included

Dedicated Nodes: Unlimited archive queries

For high-volume analytics or production applications requiring consistent historical access:

Full archive mode with no query limits
Dedicated hardware tuned for historical queries
Custom configuration (client, location, performance tier)
99.9% uptime SLA

Pricing starts at $1,500/month for archive-dedicated nodes; comparable to self-hosting but without the operational burden.

Enabling Archive Mode

When creating an endpoint in the GetBlock dashboard, you'll see an Archive Mode toggle. Enable it to unlock historical state queries.

Without archive mode enabled, your endpoint behaves like a full node, perfect for the current state, limited for historical queries

Practical Examples

1. Query a Historical Balance

from web3 import Web3

# Connect to GetBlock (archive mode enabled)
w3 = Web3(Web3.HTTPProvider("https://go.getblock.io/<YOUR-ACCESS-TOKEN>/"))

# Vitalik's address
address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

# Get balance at block 15,000,000 (requires archive)
historical_balance = w3.eth.get_balance(address, block_identifier=15000000)
print(f"Balance at block 15M: {w3.from_wei(historical_balance, 'ether'):.4f} ETH")

# Get balance at block 10,000,000 (even older)
older_balance = w3.eth.get_balance(address, block_identifier=10000000)
print(f"Balance at block 10M: {w3.from_wei(older_balance, 'ether'):.4f} ETH")

# Get current balance (works on full nodes too)
current_balance = w3.eth.get_balance(address)
print(f"Current balance: {w3.from_wei(current_balance, 'ether'):.4f} ETH")

Without access to the archive, the first two queries fail. With archive access, you get the exact balances at those historical moments.

2. Trace a Historical Transaction

curl -X POST https://go.getblock.io/<YOUR-ACCESS-TOKEN>/ \
-H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "debug_traceTransaction",
"params": [
 "0xTRANSACTION_HASH",
{"tracer": "callTracer"}
 ],
"id": 1
}'

The debug_traceTransaction method re-executes the transaction step by step, showing every internal call, state change, and gas consumption. This requires the exact state that existed when the transaction ran, archive data.

3. Read Historical Contract State

const { ethers } = require("ethers");
const provider = new ethers.JsonRpcProvider(

  "https://go.getblock.io/<YOUR-ACCESS-TOKEN>/"
);
// USDC contract on Ethereum
const usdcAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
//Minimal ABI for balanceOf
const abi = ["function balanceOf(address) view returns (uint256)"];
const usdc = new ethers.Contract(usdcAddress, abi, provider);
// Query balance at a specific historical block
const historicalBlock = 17000000;
const walletAddress = "0x..."; // Any address you want to check
const historicalBalance = await usdc.balanceOf(walletAddress, {
  blockTag: historicalBlock
})
console.log(`USDC balance at block ${historicalBlock}: ${historicalBalance}`);

Archive Support by Chain

GetBlock provides archive data access across 100+ supported blockchains:

EVM Chains: Ethereum, BNB Smart Chain, Polygon, Arbitrum, Optimism, Base, Avalanche, Fantom, Gnosis, and more

Non-EVM Chains: Solana, TRON, TON, Near

UTXO Chains: Bitcoin, Litecoin, Dogecoin, Bitcoin Cash

For specific archive availability and pricing, check the GetBlock nodes page or contact the team for enterprise requirements.

Key Takeaways

Full nodes handle 90% of use cases: Don't pay for archive if you only need the current state.
Archive is about the historical state, not historical transactions: The blockchain remembers all transactions—archive nodes remember what the world looked like at each block.
The "missing trie node" error is your signal: When you see it, you've hit the archive boundary.
Self-hosting an archive is expensive and operationally complex: $1,500+/month per chain, weeks of sync time, and an ongoing maintenance burden.
GetBlock includes archive access on all plans: You don't need enterprise pricing just to query historical data.
Start without an archive, add it when needed: It's a feature toggle, not an infrastructure migration.

Need archive data for your project? Get started free — archive access is included on all plans, excluding the free tier.