The Cheapest Way to Run an Ethereum Archive Node in 2026

People ask "how much does an Ethereum archive node cost?" and get back numbers ranging from $50/mo to $800/mo, depending entirely on who they ask. The variance is real — but it's also explainable. The cost depends on three things, and once you know all three, the answer becomes clear.

Here's the actual math in 2026, what's changed since 2023, and where the break-even is between self-hosting and renting.

What's an archive node, and do you even need one?

A regular full node verifies the chain and keeps recent state. It can answer "what's the current balance of address X?" instantly. What it can't do is tell you "what was the balance of address X at block 12,000,000?" — because that historical state has been pruned to save disk.

An archive node keeps all historical state. Every eth_call you make can specify any historical block as the blockTag, and the node will answer correctly. That's the only difference, but it unlocks a lot:

• debug_traceTransaction against any historical transaction
• Historical token balance queries (the entire DeFi-analytics use case)
• Replaying old contract state for forensics
• Indexer cold starts that need to read the chain from genesis

If you've never used debug_traceTransaction, trace_call, or queried any blockNumber more than 128 blocks old, you don't need an archive node. A regular full node — or any RPC provider's standard endpoint — is enough. Most app developers fit here.

If you're building an indexer, an analytics platform, a security tool, or a serious trading bot that does historical sims, you need archive. Read on.

The three client choices

The Ethereum archive node landscape in 2026 looks completely different than it did in 2022. Geth-archive used to be the only option, and it was painful. Now there are three:

Geth (the heavyweight)

The original archive implementation. Stores every intermediate state trie node, which is wasteful but battle-tested. Current size in 2026: ~20-22 TB and growing ~5 GB/day. Initial sync from genesis: 3-6 weeks on top-tier NVMe hardware.

Almost nobody runs Geth-archive anymore for new deployments — Erigon and Reth do the same job in 15% of the disk space. Geth-archive only makes sense if you have an existing instance you don't want to migrate.

Erigon (the practical default)

Erigon refactored how state is stored, deduplicating intermediate trie nodes. Same archive guarantees, dramatically less disk. Current size in 2026: ~3.5-4 TB. Initial sync: 1-2 weeks on NVMe.

Erigon has been the default choice for new archive deployments since mid-2023. Stable, well-tested, supported by major providers. Some performance quirks under high concurrent load, but for single-tenant use it's solid.

Reth (the Rust contender)

Paradigm's Rust implementation. Roughly Erigon-equivalent on disk and similar sync times, with a modular architecture that makes it easier to embed in other systems. Mature enough for production now; the operational story is well-documented.

If you're starting fresh in 2026, the choice is between Erigon and Reth. The difference for an operator is mostly tooling preferences — both fit on a 4-6 TB disk, both sync in under two weeks, both answer the same RPC methods.

The actual cost components

There are five real cost lines for a self-hosted archive node:

Notice the asymmetry: hardware is mostly one-time, hosting bills accumulate forever. Over 24 months, the math flips dramatically.

Concrete pricing — three real options

Option 1: Home/office on bare metal

• Used or new enterprise NVMe (Samsung PM9A3 4TB ~$500, or 2x 2TB at similar total)
• Mini-PC or used workstation with 64-128GB RAM (~$800-1200)
• One-time: ~$1,500-2,000
• Ongoing: electricity at ~80W steady = ~$10/mo at US residential rates
• Plus your home internet, which probably handles 5 Mbps without issue

This is the cheapest long-term option if you have the space and stable power.

Option 2: Dedicated hosted (Hetzner, OVH, etc.)

• Hetzner AX102 (AMD Ryzen 9, 128GB, 2x 3.84TB NVMe): ~€110/mo + setup fee
• OVH similar tier: ~€90-130/mo
• Latitude.sh, Bytetowel, Lume, similar bare-metal hosts: $90-160/mo

For about $100-150/mo all-in including bandwidth, you get a node that's never your problem if the disk dies. This is the sweet spot for serious operators who don't want to babysit hardware.

Option 3: Cloud (AWS, GCP, Azure)

• AWS i4i.2xlarge with 4 TB NVMe instance store: ~$650/mo on-demand, ~$320/mo with 3-year reserved
• GCP n2-standard-8 + 4 TB SSD persistent disk: ~$700-800/mo (the persistent disk pricing is the killer)
• Azure similar: ~$600-750/mo

Cloud is the most expensive route by a wide margin, almost entirely because of the storage. The only reason to do it is if you need cloud-native integration (VPC peering with existing services, IAM, etc.) and the budget doesn't care.

The break-even calculation

Here's the simple math that decides "self-host or rent."

Suppose a managed RPC provider charges you $X/month for archive access. Over 24 months:

• Home rig: $1,800 hardware + 24 × $10 power = **$2,040 total**, or ~$85/mo amortized
• Dedicated hosting: 24 × $120 = ~$2,880 total, or $120/mo amortized
• Cloud: 24 × $400 reserved = ~$9,600 total, or $400/mo amortized

The home rig is genuinely cheap, but you absorb the operational cost — disk failure, sync time, network outages, software updates, the actual labor of running infrastructure. The dedicated route trades $35/mo for someone else's operational pager.

The threshold question is: does $85-120/mo of fully-loaded infra cost beat what a provider charges you for managed archive access, given the time you spend running it?

For most teams, the honest answer is no — managed access from a provider that already runs the node costs less than the equivalent hardware and you don't lose two weeks waiting for an initial sync.

When the managed route wins

If you're making fewer than ~10 million archive RPC calls a month, a managed provider's standard endpoint pricing almost certainly beats self-hosting. Even at higher volumes, you're competing against operators who run hundreds of archive nodes and amortize the cost — you can't beat that with a single rig unless your usage is genuinely massive.

If you're running 100M+ archive calls/month and the provider is charging per-call, then self-hosting starts to look good. That's the threshold.

SwiftNodes includes archive access on every paid plan — Starter at $49/mo, Growth at $89, all the way up to Pro at $249, with no per-call charges and no separate "archive tier" upgrade. For most teams, that's the whole equation: pick the plan that fits your RPS, get archive access for free as part of it.

Practical recommendation

The takeaway

In 2026, an Ethereum archive node fits on a 4 TB NVMe and syncs in under two weeks with Erigon or Reth. That makes the hardware itself affordable. What's expensive is the ongoing operational reality: babysitting it, keeping it synced, replacing disks, managing the network.

For >90% of teams the right answer is "rent it from someone who already runs them." The self-hosting break-even is real, but it's a higher RPC volume than most people think.

SwiftNodes includes Ethereum archive access on every paid plan, with no per-call fees and no separate archive tier. Same ?key= URL works for current state and historical queries. See Ethereum RPC details or grab a free API key — no credit card, no KYC.