What Is AssumeUTXO?

AssumeUTXO explained

Share this article

Part of the Bitcoin ethos is not to trust, but to verify and promote decentralisation; one way to do that is to run a node at home. You could use an old computer, a standalone device like a mini PC, or you could purchase one of the many node-in-a-box products available today.

Running your own Bitcoin node is the most direct way to stop trusting other people about what is and isn’t valid. It also opens you up to a host of amazing open-source software that can take your hands-on Bitcoin experience to all new heights.

If you’re a bit of a tinkerer, starting up a node, can quickly become a fun little hobby.

But anyone who has tried it has hit a bit of a bandwidth brick wall: Before your node is any use, it has to download and verify the entire history of the blockchain.

With modern hardware like a Mac Mini or one of the premium node-in-a-box devices and high-speed fibre internet, your best case is getting up and running in 12 hours; in a world where we’re used to streaming and instant access, that can feel like an eternity to onboard.

Unfortunately, there are very few people willing to set aside a few hundred or even a thousand-plus dollars for a modern setup, nor do they have access to ultra-high-speed fibre.

On modest hardware, that can take days, and sometimes it simply never finishes, with the node crashing. As your poor Raspberry Pi and 2TB hard drive get pushed to the max, and you combine that with third-world internet speeds, onboarding to a self-sovereign setup becomes even more frustrating.

This standard node experience not only excludes many from running a node, but as the blockchain grows, sync times from boot-up only get longer, and the resources required to validate blocks and store them keep increasing.

If you plan to run a node on old hardware with limited resources and you’re open to making some concessions to speed up the process, there are a few workarounds. AssumeUTXO is a Bitcoin Core feature designed to fix that, by letting a new node become useful in minutes or hours while still verifying everything in the background.

The Problem With Syncing Nodes

When you start a new node, it goes through what’s called the initial block download (IBD). It downloads every block since January 2009, checks every transaction and signature, and rebuilds the set of all unspent outputs, known as the UTXO set.

Only once it is caught up can it tell you your balance, relay transactions or validate new blocks with confidence.

Estimates of the chain’s size vary by source and measurement method, ranging from roughly 700 GB to nearly 900 GB. One live tracker showed about 895 GB at block 976,826 this week.

The chain grows by roughly 50 to 80 GB a year, which will continue to compound; soon, a 1.5 TB HDD won’t be enough, and many current nodes will need to prune or upgrade their storage or move away from Raspberry Pis entirely.

A full sync also writes far more to disk than it downloads, because the UTXO database is constantly updated while blocks are processed.

Estimates put the total at over a terabyte of writes.

Sync time depends heavily on hardware. Sync times range from about six hours on a fast machine to a week or more on a low-powered one. The usual bottlenecks are signature verification (the CPU), the constant reading and writing of the UTXO set (the disk) and the memory available for caching.

A Raspberry Pi with a slow external drive sits at the painful end of that range, and it is exactly the sort of device people buy to run a first node.

Why Nodes Are Getting Harder to Bootstrap

Several trends push in the same direction:

  • The chain keeps growing. Every year adds tens of gigabytes that a new node must download and verify, and the debate over how much non-monetary data belongs on the chain has only made this a more visible concern.
  • The UTXO set keeps growing. As of April 2025, it held around 173 million outputs, occupying roughly 11 GB in Bitcoin Core’s database. A bigger set means more disk work for every block processed.
  • Cheap hardware is not keeping up. DIY products make running a node approachable, but they are often built on modest hardware that struggles with a full sync.
  • Node-in-a-box aren’t cheap. Plug-and-play nodes are also trying to future-proof their offerings to try and extend the lifespan of use; they’re not skimping on resources, and that reflects in the price.
  • Patience is finite. A sync that takes days, with no clear progress, is where many first-time users give up.

Why This Is Bad for Decentralisation?

Bitcoin’s rules are enforced by the people running nodes. If you run one, you decide for yourself which blocks and transactions are valid. If you don’t, you rely on someone else’s answer.

When bootstrapping is slow and costly, fewer people start nodes and some stop at the first obstacle. They fall back on light wallets that query someone else’s server, custodial apps and hosted explorers. Each of those is a point of trust. The more the network’s users depend on a small number of servers, the less meaningful it is that the protocol is decentralised on paper.

This isn’t an abstract worry.

When contentious proposals or chain splits arrive, as they have this year, the question of whose rules apply comes down to which nodes people actually run and what economic activity they follow. A large, diverse population of independent nodes is the strongest check.

What Is AssumeUTXO?

AssumeUTXO lets a node load a serialised snapshot of the UTXO set at a specific block height, start working from that point, and verify the older history in the background. It was first proposed in 2019 by James O’Beirne.

The core logic shipped in Bitcoin Core 26.0 (December 2023), and mainnet support arrived in 28.0 (October 2024) with a snapshot at height 840,000. Later releases have added newer heights, so check the release notes for the current list.

The idea is similar to the assumevalid setting that Bitcoin Core already uses to skip signature checks on very old blocks: you accept that a particular piece of the past is correct, because it has been reviewed by many people and can be checked later.

The difference is that AssumeUTXO skips much more work upfront, and then goes back and does it.

How It Works

  1. Get a snapshot file. The snapshot is a serialised copy of the UTXO set at a given height, generated by a node with the dumptxoutset command. It isn’t bundled with Bitcoin Core, because it would add several gigabytes to every download. Depending on the height and format, snapshots are roughly 7 to 12 GB. You can fetch one from another node, a torrent or a mirror.
  2. Load it. You run loadtxoutset with the file’s path. Bitcoin Core computes the snapshot’s hash and checks it against a value hardcoded into the software for that height. If it doesn’t match, the snapshot is rejected, so it doesn’t matter where the file came from. Loading takes roughly ten minutes to a few hours depending on the machine.
  3. Start working from the snapshot. The node creates a second chainstate, downloads the blocks from the snapshot height to the tip and begins validating new blocks. At this point, it is usable. Reported benchmarks put time-to-usability at around one to two hours, versus around eleven hours or more for a full sync on fast hardware.
  4. Verify the past in the background. Meanwhile, a background chainstate downloads and validates the whole chain from the genesis block up to the snapshot height, building the UTXO set from scratch.
  5. Compare. When the background process reaches the snapshot height, it compares the UTXO set it built with the snapshot. If they match, the snapshot is confirmed, and the node has the same guarantees as one that synced the long way. If they don’t, the node fails.
MethodTime to usableValidates full historyTrust assumption
Full IBDHours to days or longerYes, upfrontNone
AssumeUTXORoughly 1 to 2 hoursYes, in the backgroundHardcoded snapshot hash is correct, until background validation finishes

The Shortcomings

AssumeUTXO helps a lot, but it is not a free lunch.

  • Temporary trust. Until background validation finishes, your node is trusting that the hash in the software is right. That hash is reviewed by developers and contributors during the release process, much like assumevalid. Anyone with a fully synced node can generate their own snapshot at that height and compare. Even so, some contributors have raised the governance question of who decides which snapshots get “blessed”, and what happens if that process is ever pressured. A wrong hash would, in principle, be caught later by the background check, but not before the node had relied on it.
  • It doesn’t reduce the total work. The full history still has to be downloaded and validated. AssumeUTXO changes the order, not the amount. For a while a node runs two chainstates side by side, which uses more resources than usual.
  • Limited heights. You can only load snapshots at heights that are hardcoded into your version of Bitcoin Core. Older software won’t recognise newer snapshots.
  • It’s still manual. The snapshot has to be obtained separately and loaded with an RPC command. Graphical integration for Bitcoin Core’s new interface is under development, but it isn’t yet the one-click experience most new users need.
  • Some features wait. Indexes such as the transaction index are built or restarted once background validation completes, so full functionality arrives later than basic usability.

Can You Combine It With Archival and Pruned Nodes?

Yes, with different outcomes.

Full archival nodes

If you want to keep every block, you can start with a snapshot and let the background process download and verify the full history. You get a node that is usable almost immediately, and that eventually becomes a complete archive, able to serve historical blocks to others. For anyone who wants to contribute to the network’s data availability, this is the best of both worlds.

Pruned nodes

A pruned node validates blocks and then discards old ones, keeping only the most recent few gigabytes. It can use AssumeUTXO too, subject to Core’s pruning rules, which now include support for multiple chainstates.

The background validation still downloads and checks all of history, but it deletes the old data as it goes.

A minimally pruned node needs only around 12 GB of disk space in total, including the UTXO set. For someone with a small laptop or a Raspberry Pi, a pruned node bootstrapped from a snapshot may be the most realistic way to get fully validating.

While it’s not ideal, since you lose out on features like running an Electrum server, your own mempool instance and getting the true full node experience, at the current rate of chain expansion, you’re not left with much choice based on your hardware limitations.

Why Faster Onboarding Matters for Self-Sovereignty

While Bitcoiners should be open to a low time preference, giving them the option isn’t a bad thing; letting market actors make their own decisions and trade-offs is better than forcing everyone down one path.

In the case for AssumeUTXO, it isn’t really about shaving off a few days or hours. It’s about a new user’s first experience.

A person who installs a node and sees a usable, connected wallet that afternoon is far more likely to keep running it than one who spends a week watching a progress bar.

A node that works quickly makes it realistic to:

  • Connect a wallet to your own node on the first day, instead of a third party’s server
  • Recommend node software to friends without a long caveat about patience
  • Let node-in-a-box products ship with a snapshot built in, so the onboarding flow takes minutes
  • Keep nodes cheap enough that people still run them on modest hardware

More nodes mean more independent verification, which makes Bitcoin’s rules hard to change under pressure. Self-sovereignty isn’t only about holding your own keys. It also means checking your own history, and anything that makes that easier strengthens the whole network.

While full archival nodes are still the goal and remain the gold standard, having a mixed network of distributed nodes is never a bad idea in my view.

I would much rather see people onboard with pruned nodes, start getting a feel for running a node, using the apps, and finding value in the device and the software; from there, they can decide to commit capital to upgrading their node setup to access more features.

Speed Comes With Trade-Offs

AssumeUTXO doesn’t remove the need to verify Bitcoin’s history. It lets you start using your node first and finish the verification afterwards, with a safety check at the end that makes the shortcut temporary. It carries a time-limited trust assumption, and it still depends on better tooling to reach ordinary users.

But as the chain grows and hardware lags behind, features like this are one of the main ways Bitcoin can stay easy to verify for anyone who wants to participate.


Do your own research.

If you want to learn more about AssumeUTXO, use this article as a starting point. Don’t trust what we say as the final word. Take the time to research other sources, starting with the resources below.

Disclaimer: This article should not be taken as, and is not intended to provide any investment advice. It is for educational and entertainment purposes only. As of the time posting, the writers may or may not have holdings in some of the coins or tokens they cover. Please conduct your own thorough research before investing in any cryptocurrency, as all investments contain risk. All opinions expressed in these articles are my own and are in no way a reflection of the opinions of The Bitcoin Manual

Leave a Reply

Related articles

You may also be interested in

HD Aezeed Wallet Explained

What Is An HD Aezeed Wallet?

Since there is no Bitcoin University that can give you a crash course in using the technology, and most of us figure it out via

Cookie policy
We use our own and third party cookies to allow us to understand how the site is used and to support our marketing campaigns.