How to Run a Monero Node on Raspberry Pi 2026

A full Monero node now occupies roughly 215 GB of blockchain data as of mid-2026, and the network surpassed 4,200 reachable peers in March after a fresh wave of self-hosters joined the relay set. The single biggest reason behind that growth is hardware: a Raspberry Pi 5 with a fast NVMe SSD has become powerful enough to sync the chain in under three days and serve wallets indefinitely on a fraction of a desktop's power budget. If you have been relying on remote nodes or strangers' RPC endpoints, this guide shows exactly how to flip the switch to self-sovereignty without spending more than the price of a mid-range smartphone.

Running your own node strengthens the privacy guarantees that Monero is famous for, and it removes a quiet attack surface most users overlook. Even a perfectly mixed transaction broadcast to someone else's daemon can leak your IP, your wallet's view-key activity timing, and metadata that a curious operator could correlate. That is also why services like MoneroSwapper recommend using your own daemon whenever possible — privacy is end-to-end, and the daemon is one of the ends. By the time you finish this article you will have a working node, a hardened service setup, and a maintenance routine that survives 2026's network upgrades.

Why a Personal Monero Node Matters in 2026

Monero's privacy stack — ring signatures, stealth addresses, RingCT, Bulletproofs+, and the upcoming FCMP++ migration — protects what is inside a transaction. None of those primitives protect the connection between your wallet and the daemon that broadcasts that transaction. When you connect to a public remote node, that operator sees your IP address, the exact timestamps your wallet polls for blocks, the subaddresses your view key checks, and (for RPC clients without TLS) the raw output indices being looked up. None of this breaks Monero's cryptography, but it builds a behavioral fingerprint.

A handful of incidents in 2024 and 2025 made the point sharply. Researchers from a European university published a 2025 paper demonstrating that a single malicious node could de-anonymize a non-trivial fraction of wallet sessions purely by correlating polling intervals and decoy-output requests. The Monero core team responded by improving wallet behavior, but the cleanest mitigation has always been the same: run your own daemon. The Raspberry Pi makes that practical for anyone with a spare USB-C charger.

• Privacy hygiene: No third party sees your wallet's lookups, sync timing, or IP — your daemon is on your LAN.
• Censorship resistance: A local node continues working even when public nodes are blocked at the ISP level or DDoS'd off-line.
• Network health: Each additional reachable node strengthens Monero's gossip layer and helps relay transactions for users on bandwidth-restricted regions.
• Hash-rate independence: If you decide to solo-mine via P2Pool later, you already have the daemon component ready to go.
• Atomic swap compatibility: The COMIT atomic-swap network and similar bridges require a synced full node to verify XMR-side transactions trustlessly.

Choosing the Right Raspberry Pi Hardware for 2026

The blockchain has crossed 215 GB and grows by roughly 2 GB per month, so storage is the first decision. A microSD card will technically work for an already-synced node but is brutal during initial sync because of constant random I/O. NVMe via a PCIe HAT or a quality USB 3.2 SSD enclosure is the right answer. Memory pressure during verification spikes briefly above 2 GB, which rules out the 1 GB Pi 4 variant but leaves every other modern Pi viable.

For storage, plan for at least 400 GB to comfortably last two years without rotation. A 500 GB NVMe drive is the sweet spot in 2026 and can be found new for under USD 45. Avoid the cheapest no-name SSDs — DRAM-less drives perform poorly under the sustained random writes Monero verification produces. Reputable mid-range models from Crucial, Samsung, or WD Blue are perfect.

Cooling matters more than people expect. A bare Pi 5 will thermal-throttle during the verification phase of the initial sync, which adds many hours to total time. The official active cooler or any decent third-party heatsink-and-fan combo solves this for the price of two coffees.

Step-by-Step Setup: From Box to Synced Daemon

Below is the full path from an unopened Pi to a fully synced, autostarted, hardened monerod service. The instructions assume Raspberry Pi OS Lite 64-bit (Bookworm) released in 2025, which is currently the most stable base for the Monero daemon binaries.

1. Flash the OS. Download Raspberry Pi Imager, select Raspberry Pi OS Lite (64-bit), then click the gear icon to pre-set the hostname (monero-node), SSH access with key authentication, your Wi-Fi credentials, and a non-default username. Avoid the default pi account — it is the first thing automated scanners try.
2. Boot and update. Connect the NVMe enclosure, plug in the Pi, SSH in, and run sudo apt update && sudo apt full-upgrade -y. Reboot once.
3. Prepare the SSD. Identify the SSD with lsblk, format it as ext4 with sudo mkfs.ext4 /dev/nvme0n1 (replace device path as appropriate), and mount it at /var/lib/monero. Add a matching entry to /etc/fstab so the mount survives reboots.
4. Create a dedicated user. Run sudo useradd -r -s /usr/sbin/nologin -d /var/lib/monero monero and sudo chown -R monero:monero /var/lib/monero. Running the daemon as an unprivileged service user is non-negotiable for any node exposed to a network.
5. Download monerod. Pull the latest ARMv8 release from getmonero.org, verify the GPG signature against the developer fingerprints listed on the site, then extract the archive into /usr/local/bin/. Verification matters: the binary is the root of trust for your node.
6. Write the config. Create /etc/monero/monerod.conf with data-dir=/var/lib/monero, log-file=/var/log/monero/monerod.log, db-sync-mode=safe, enforce-dns-checkpointing=1, out-peers=64, in-peers=128, and limit-rate-up=2048 to be a polite peer.
7. Create the systemd unit. Drop a monerod.service file into /etc/systemd/system/ with User=monero, ExecStart=/usr/local/bin/monerod --config-file=/etc/monero/monerod.conf --non-interactive, Restart=on-failure, and the standard hardening directives (NoNewPrivileges=true, ProtectSystem=strict, PrivateTmp=true).
8. Start the sync. Run sudo systemctl enable --now monerod, then watch progress with tail -f /var/log/monero/monerod.log. The first 12 hours dominate disk write activity; after that the Pi mostly idles between blocks. Expect 50–110 hours total depending on hardware.
9. Verify health. Once the log shows SYNCHRONIZED OK, query the daemon with curl http://127.0.0.1:18081/get_info and confirm height matches a public block explorer's tip within one or two blocks.
10. Point your wallet. In the Monero GUI, Feather, Cake Wallet desktop, or the CLI wallet, change the daemon to http://[Pi's LAN IP]:18081. Refresh and watch your wallet sync from a peer you trust completely.

Verify the GPG signature of monerod before trusting a single byte of the chain it serves you — the binary is the actual root of trust, not the SHA256 alone.

Hardening and Remote Access

A node sitting on your LAN is already much safer than using a public remote, but a few extra steps make it genuinely resistant to opportunistic attackers. Start by closing every port you do not need with ufw or nftables. SSH on a non-default port with key-only authentication and fail2ban is the minimum acceptable configuration if the Pi is reachable from the wider internet.

If you want to reach your daemon from outside your home — for example, from a phone wallet on mobile data — do not simply open port 18081 on your router. Two better options exist. The first is WireGuard: configure a small VPN tunnel back to the Pi and let only authenticated clients talk to the daemon. The second is a Tor hidden service: edit /etc/tor/torrc to publish 18081 as a HiddenServicePort, and configure your mobile wallet to use the resulting .onion address via Orbot. Tor adds latency but eliminates a port-forwarding step entirely.

RPC access deserves its own consideration. If a wallet needs to talk to the daemon, restrict rpc-bind-ip to 127.0.0.1 or to a WireGuard interface address — never to 0.0.0.0 without a TLS reverse proxy and an authentication password. Monero supports digest authentication on the RPC channel via rpc-login=user:password; use it whenever the port is not strictly loopback.

Finally, enable automatic security updates with unattended-upgrades. The Raspberry Pi OS package set is small enough that unattended updates almost never break anything, and the alternative — leaving an unpatched Linux kernel on a 24/7 device — is far worse. Set updates to apply around 04:00 local time and reboot once a week.

Real-World Performance and Maintenance

Once synced, a Raspberry Pi 5 with NVMe storage spends most of its life under 5 % CPU. Block verification spikes to one or two seconds of full-core load every two minutes, then the system idles. Power draw averaged across one week of measurement on a Pi 5 8 GB serving two wallets and one P2Pool miner was 3.7 W, or about 32 kWh per year — under USD 6 of electricity at typical European rates and a fraction of that in many other regions.

Disk space is the maintenance task that catches most people. The Monero chain itself grows roughly 24 GB per year, but the LMDB database file can also fragment after long periods. Once per quarter, run monero-blockchain-prune-known-spent-data if you need to claw back space, or perform a clean reimport with monero-blockchain-import if you want a fully compacted database. Both are documented on the Monero docs site and take a few hours on a Pi.

Backups are simpler than for a Bitcoin node because the Monero chain has no UTXO snapshot to preserve — if your SSD dies, you simply re-sync from scratch. What does need backing up is your wallet seed (stored offline as a 25-word mnemonic seed, or as a Polyseed 16-word backup if your wallet supports it), plus your monerod.conf and any Tor hidden-service private key. A printed copy of the seed in a fireproof location and a separate encrypted USB stick with the config files cover both failure modes.

Monero ships a network upgrade roughly every twelve to eighteen months. The next major fork — bringing FCMP++ and Jamtis addresses — is scheduled for mid-2026 based on the current devblog cadence. Subscribe to the monero-announce mailing list or the official Mastodon account so you upgrade monerod before the fork height; running stale binaries past a fork leaves your node on a dead chain.

Using Your Node with Wallets, P2Pool, and Swap Services

A self-hosted daemon unlocks several adjacent capabilities. Feather and the official GUI both accept your Pi's IP and instantly stop leaking metadata to strangers. Cake Wallet on iOS and Android supports custom daemon URLs in advanced settings — point it at your Tor hidden service and your mobile wallet inherits the same privacy profile. The Monero CLI wallet, used for cold-signing offline transactions on an airgapped laptop, can also connect to your Pi for the watch-only side of the workflow.

If you want to mine, install P2Pool on the same Pi and point it at 127.0.0.1:18081. A Pi cannot meaningfully solo-mine RandomX, but P2Pool's decentralized payout pool happily accepts any hash rate from external miners and credits payouts to your wallet on every share. This turns the Pi into both a node and a tiny mining backend for hash rate you generate elsewhere — for instance, on a desktop CPU running overnight.

When you do need to acquire XMR with no KYC or convert between assets, a self-hosted node also lets you verify swap outputs trustlessly. MoneroSwapper transactions land in your wallet within a few network confirmations; with your own daemon serving those confirmations you can be certain about finality without trusting a remote operator's view of the chain. The same applies to atomic swaps via XMR/BTC bridges, which require a fully synced full node on the Monero side to participate.

FAQ

Is a Raspberry Pi 4 still good enough in 2026?

Yes, especially the 8 GB version. Initial sync takes roughly twice as long as on a Pi 5, but day-to-day operation is indistinguishable. If you already own a Pi 4, do not buy a Pi 5 just for this — the bottleneck after sync is storage and network, not CPU.

Can I run the node on a microSD card instead of an SSD?

Technically yes for serving an already-synced chain, but the initial sync is so brutal on SD card endurance that you will likely burn through a 128 GB card before it finishes. SSD or NVMe is strongly recommended. If you must use SD, choose a card rated A2 application class and expect it to be a consumable.

How much bandwidth does a Monero node use?

A reachable node with default peer settings consumes roughly 60–120 GB upstream and 20–40 GB downstream per month. You can cap both with limit-rate-up and limit-rate-down in monerod.conf. Setting upload to 2 MB/s keeps you a polite peer without eating into other household traffic.

Do I need to open ports on my router for the node to be useful?

No. A node that only makes outgoing connections still verifies every block, serves your own wallets perfectly, and participates in the gossip layer as a listener. Opening port 18080 only matters if you want to also accept incoming peer connections and increase the network's overall reachability.

What happens during a Monero network upgrade — will my node break?

Network upgrades happen at predetermined block heights announced months in advance. Upgrade monerod to the new release before that height and nothing breaks. If you forget, your node will stall on the old fork until you update; no funds are lost, just downtime until you catch up.

Can I run a node and Tor relay on the same Pi?

Yes, and many users do exactly that. A Pi 5 has plenty of headroom for both. Configure Tor as a non-exit relay or a bridge to keep things uncontroversial with your ISP, and place a Monero hidden service alongside it for free.

Conclusion

Running your own Monero node on a Raspberry Pi is the closest thing in cryptocurrency to a one-time chore that pays privacy dividends forever. For roughly USD 150 in hardware and a single weekend of setup you remove a metadata leak that every wallet on a public daemon quietly suffers, you contribute reachable infrastructure to a network that needs it, and you make every future swap or transaction verifiable against your own chain copy. Combine that node with a hardened wallet flow and a no-KYC acquisition path like MoneroSwapper and you have a stack that resists almost every realistic surveillance attempt without compromising on convenience.

The 2026 upgrade cycle will continue to make this easier — FCMP++ and Jamtis improve the user experience further, and Raspberry Pi hardware keeps getting faster per watt. Start with the steps above, keep the device updated, and your node will quietly outlast several wallets, several phones, and probably several internet providers.