# How to run a pruned Monero node (monerod) on a VPS

> Run a pruned Monero node on Ubuntu 24.04. Verify the official monerod download, write monerod.conf, start it with systemd and decide on a public RPC.

Running your own Monero node means your wallet talks to a daemon you control instead of a random remote node that can see your IP address and the timing of your requests. A **pruned** node keeps roughly one third of the blockchain data while still validating everything. This guide follows the official Monero systemd setup on Ubuntu 24.04 and adds pruning.

## What you need

- **A VPS with 6 vCPU, 12 GB RAM and 192 GB of disk.** On DataPasa that is **VPS-5**. A pruned database takes around 110 GB and keeps growing, so smaller disks run out quickly. Our [crypto node VPS page](https://datapasa.com/en/crypto-node-vps) compares plans for other networks.
- **Ubuntu 24.04** with root access over SSH, see [how to connect via SSH](https://datapasa.com/wiki/server-management/connect-via-ssh).

You can pay for the VPS in XMR directly. The list of accepted coins is on [crypto VPS hosting](https://datapasa.com/en/crypto-vps).

## Step 1. Download monerod and verify it

Check the latest CLI version on [getmonero.org/downloads](https://www.getmonero.org/downloads/) and set it in a variable without the `v`:

```bash
VERSION=0.18.5.1
cd /tmp
wget https://downloads.getmonero.org/cli/monero-linux-x64-v${VERSION}.tar.bz2
```

Import the key of binaryFate, who signs the list of hashes, and check its fingerprint:

```bash
wget -O binaryfate.asc https://raw.githubusercontent.com/monero-project/monero/master/utils/gpg_keys/binaryfate.asc
gpg --keyid-format long --with-fingerprint binaryfate.asc
gpg --import binaryfate.asc
```

The fingerprint must be `81AC 591F E9C4 B65C 5806 AFC3 F0AF 4D46 2A0B DF92`. Now download the signed hash list and verify it:

```bash
wget -O hashes.txt https://www.getmonero.org/downloads/hashes.txt
gpg --verify hashes.txt
```

Look for `Good signature from "binaryFate"`. Finally compare the archive hash with the signed list:

```bash
grep "monero-linux-x64-v${VERSION}.tar.bz2" hashes.txt | sha256sum --check
```

The output must be `monero-linux-x64-VERSION.tar.bz2: OK`.

## Step 2. Install the binaries and create a user

```bash
apt install -y bzip2
tar -xjf monero-linux-x64-v${VERSION}.tar.bz2
mv monero-x86_64-linux-gnu-v${VERSION}/* /usr/local/bin/
chown root:root /usr/local/bin/monero*
monerod --version
```

Create the service user and the directories for config, blockchain and logs, exactly as in the official guide:

```bash
useradd --system monero
mkdir -pm 750 /etc/monero /var/lib/monero /var/log/monero
chown root:monero /etc/monero
chown monero:monero /var/lib/monero /var/log/monero
```

## Step 3. Write monerod.conf

Create `/etc/monero/monerod.conf`:

```bash
nano /etc/monero/monerod.conf
```

A private node for your own wallets:

```ini
data-dir=/var/lib/monero/bitmonero
prune-blockchain=1
sync-pruned-blocks=1

check-updates=disabled
enable-dns-blocklist=1

log-file=/var/log/monero/monero.log
log-level=0

p2p-bind-ip=0.0.0.0
p2p-bind-port=18080
no-igd=1

out-peers=12
in-peers=48
```

- `prune-blockchain=1` enables pruning. Set it **before** the first sync. Added later, old data is only pruned logically and the database file does not shrink.
- `sync-pruned-blocks=1` accepts already pruned blocks from peers, which saves download traffic.
- The full RPC stays on `127.0.0.1:18081`, the default. Do not bind it to a public address.

## Step 4. Create the systemd service

Create `/etc/systemd/system/monerod.service`:

```ini
[Unit]
Description=Monero Daemon
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
ExecStart=/usr/local/bin/monerod --config-file /etc/monero/monerod.conf --non-interactive
Restart=always
RestartSec=30
User=monero
Group=monero
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
```

Start the node:

```bash
systemctl daemon-reload
systemctl enable --now monerod
systemctl status monerod
```

If you use UFW, open the P2P port so other nodes can connect to you:

```bash
ufw allow 18080/tcp
```

## Step 5. Watch the sync

`monerod` accepts commands for the running daemon. Run them on the server:

```bash
monerod status
monerod sync_info
tail -n 100 /var/log/monero/monero.log
```

`status` prints the height as `current/target` with a percentage. The first sync downloads and verifies the whole chain history, which on a VPS usually takes from one to several days. Disk speed matters most, which is where NVMe helps. Check free space from time to time with `df -h /var/lib/monero`.

> **Do not interrupt the database.** Stop the node with `systemctl stop monerod` and let it finish. A hard power off during heavy writes can corrupt the LMDB database and force a resync.

## Step 6. Connect your wallet

The safest way to use the node from your computer is an SSH tunnel to the local RPC port, so nothing extra is exposed:

```bash
ssh -N -L 18081:127.0.0.1:18081 root@YOUR_SERVER_IP
```

While the tunnel is open, point your wallet (Monero GUI, Feather or `monero-wallet-cli`) to the remote node `127.0.0.1:18081`.

## Public RPC: should you open it?

You can let other people's wallets use your node through the **restricted** RPC, which hides admin calls. The official guide does it with these lines:

```ini
rpc-restricted-bind-ip=0.0.0.0
rpc-restricted-bind-port=18089
public-node=1
```

and a firewall rule `ufw allow 18089/tcp`. `public-node=1` advertises the node on the P2P network so wallets can find it automatically. Leave it out if you want to share the address only with friends.

Before you open it, keep in mind:

- **Traffic and load grow.** Every connected wallet scans blocks through your node. VPS-5 includes 32 TB of traffic a month, but CPU and disk load rise with users.
- **Your IP is public.** The node is listed and gets scanned, so keep the rest of the server locked down with [UFW and fail2ban](https://datapasa.com/wiki/server-management/secure-vps-ufw-fail2ban).
- **Never expose port 18081.** The unrestricted RPC allows admin calls like stopping the daemon.

## Keep the node running

- Update when a new version is released: download, verify, replace the binaries in `/usr/local/bin`, then `systemctl restart monerod`.
- Keep your DataPasa balance topped up. When it runs out, the server is suspended and deleted after 24 hours together with its disk, so you would have to sync from scratch.

## Summary

You verified and installed `monerod`, enabled pruning before the first sync and run the daemon under systemd with its own user. Your wallets can now use a node you control, privately through an SSH tunnel or publicly through the restricted RPC.