Archive Node

Unlike standard full nodes that only keep recent state data, an archive node stores the entire state trie or state database for every single block since genesis. This includes all account balances, smart contract storage, and internal transaction receipts, allowing for queries about the state of the network at any historical block height.

Archive nodes are the backbone of services requiring historical data lookups, such as:

• Block explorers (e.g., Etherscan) for viewing past transactions and balances.
• Analytics platforms for tracking token flows and protocol metrics over time.
• Audit and compliance tools for verifying historical on-chain activity.

Maintaining a full archive requires significant and growing resources:

• Storage: Can require multiple terabytes (e.g., >10 TB for Ethereum) and expands continuously.
• Memory (RAM): Needs ample RAM for efficient state lookups during query processing.
• Compute: Historical state queries are computationally intensive compared to syncing the latest chain tip.

Most node clients (like Geth, Erigon) can run in different sync modes:

• Full Node (with pruning): Synchronizes all blocks but discards old state data to save space, typically keeping only the last ~128 blocks of state.
• Archive Node: Disables pruning entirely, preserving all historical state. The initial sync to archive mode is significantly slower and more resource-intensive.

Archive nodes enable advanced JSON-RPC methods like debug_traceTransaction and trace_filter. These methods re-execute transactions in the context of their original historical state, which is crucial for:

• Smart contract debugging to understand complex transaction failures.
• Building accurate transaction fee calculators.
• Protocol research and simulation of historical events.

Archive Node: Stores all blocks + all historical state. Highest resource cost. Full Node: Stores all blocks + recent state (pruned). Validates new blocks and transactions. Light Node: Stores block headers only. Relies on full nodes for state data. Lowest resource cost. Archive nodes are a superset of full nodes, providing the deepest data access layer.

Archive nodes are essential for on-chain analytics, compliance audits, and forensic investigations. They provide access to the full historical state, allowing analysts to:

• Trace the complete history of a wallet or smart contract.
• Verify transaction provenance for regulatory compliance.
• Conduct detailed research on network activity, token flows, and protocol usage over time.

Public block explorers like Etherscan and Solana Explorer rely on archive nodes to serve detailed historical information. They power features such as:

• Displaying the complete transaction history for any address.
• Showing internal transactions and token transfers.
• Providing access to historical smart contract states and event logs.

Developers use archive nodes to build and test applications that require historical context. Key use cases include:

• Indexing services that build custom databases of past events.
• Simulating complex transactions that depend on a specific historical state.
• Debugging by replaying past blocks to identify issues in smart contract interactions.

Archive nodes act as a decentralized historical backup for the network, ensuring data persistence and censorship resistance. They guarantee that:

• The entire chain history remains available even if many full nodes prune old data.
• New nodes can synchronize from genesis without relying on a single source.
• Historical data is preserved for future verification and chain analysis.

Advanced financial applications require archive node data for accurate calculations and reporting. Examples include:

• DeFi protocols calculating time-weighted average prices (TWAP) or historical yields.
• Tax reporting services generating complete capital gains reports.
• Risk assessment models that analyze historical liquidity and volatility patterns.

Infrastructure providers like Alchemy, Infura, and QuickNode operate archive nodes to offer enhanced API endpoints. These services allow dApps to query:

• Historical balances and states via eth_getBalance for a past block.
• Old transaction receipts and logs.
• Complete data for any block number, enabling reliable application performance.

Archive nodes store the complete historical state of a blockchain, not just block headers and transactions. This includes the state (account balances, smart contract storage) for every single block. For mature networks like Ethereum, this can require multiple terabytes (TB) to tens of TBs of fast storage (SSDs are recommended). This requirement grows linearly with chain activity.

The resource intensity translates directly to expense.

• Hardware: Requires high-performance CPUs, large amounts of RAM, and enterprise-grade SSDs.
• Hosting: Colocation or cloud hosting (e.g., AWS, GCP) for such a node can cost hundreds to thousands of dollars per month.
• Bandwidth: Constant, high-volume data synchronization and serving queries consumes significant bandwidth.

Initial synchronization (the "sync") from genesis to the current block is the most demanding phase, often taking weeks for major chains. The process is I/O and CPU intensive. Ongoing maintenance requires monitoring disk space, managing software updates, and ensuring high uptime. State pruning is not an option, unlike with full nodes.

The high cost is only justifiable for specific applications. Primary users include:

• Block explorers (Etherscan)
• Analytics platforms (Dune, Nansen)
• Historical data providers (The Graph for legacy queries)
• Auditors and researchers needing verifiable historical state. Most dApps and users are sufficiently served by RPC providers that offer archive data as a service.

To avoid the overhead of a personal archive node, developers often use:

• Managed RPC Services: Providers like Alchemy, Infura, and QuickNode offer archive-level API endpoints.
• Indexing Protocols: The Graph indexes historical data into queryable subgraphs.
• Light Clients & Snap Sync: For applications needing only recent state with cryptographic proofs.
• Decentralized Networks: Services like Pokt Network that decentralize RPC access.

State pruning is the process by which nodes (like full nodes) delete historical state data that is no longer necessary for validating new blocks, drastically reducing storage requirements. Archive nodes explicitly disable pruning to retain the complete historical state trie. This is the core technical distinction between a pruned full node and an archive node.

A Remote Procedure Call (RPC) endpoint is the interface through which applications (wallets, dApps, scripts) query a node's data and broadcast transactions. Archive nodes provide unique RPC methods (like debug_traceTransaction or historical eth_getBalance at old block heights) that require full state history. Most public RPC providers offer limited, non-archive access by default.