Run a Bitcoin full node on a VPS or dedicated server

A pruned Bitcoin Core node fits the 80 GB NVMe at $6/mo; archival wants Titan or metal. Port 8333, prune depth, Tor onion, and sync in hours not days.
A pruned Bitcoin Core node fits the 80 GB NVMe at $6/mo; archival wants Titan or metal. Port 8333, prune depth, Tor onion, and sync in hours not days.
The audit function outranks the archive
Counter-intuitive but load-bearing: storage is nearly optional here, verification is not. A trimmed installation discards old block files yet enforces every consensus rule on everything that arrives - your balances rest on your own arithmetic, not on an explorer's API answer. Swap that away for a light wallet leaning on somebody else's bitcoind, and no quantity of disk ever purchases the trust back. That trade - discard history, keep enforcement - is the entire design question, and it comes before any hardware pick.
Bitcoin Core remains the reference implementation, and its operator guidance - storage, trim depth, inbound reachability - lives at the project's site. The query surface a working machine actually needs is tiny: getblockchaininfo to watch the crawl, getpeerinfo to watch connections, getmempoolinfo to watch the evening storms - all specified in the official RPC reference, and identical in behavior whether the host is a laptop or a rented instance in Reykjavik.
Renting changes nothing about trust, because enforcement is CPU-and-drive work wherever the chainstate sits: a KVM guest audits as hard as bare silicon. Settlement accepts any of nineteen instruments; XMR keeps the rail discreet, tether pins the figure. What renting genuinely alters is the uptime ledger - unmetered multi-gigabit transit, facility-grade power, and cooling that is somebody's profession rather than your hallway's oldest circuit, which is the honest reason operators graduate from the spare room.
The category error to avoid: treating the machine as a backup target. The verified ledger state is reproducible from the network by construction - that is its whole point - while wallet keys exist nowhere else unless you exported them, so keys get backed up and blocks never do. That distinction settled, the genuine sizing question arrives, and it is not CPU or memory: it is which retention mode you intend to keep, and every retention mode is a drive-length answer.
VPS from $4.80* — Core on the annual term (list $6/mo), one invoice for 12 months, no auto-charges. Dedicated with IPMI from $39.20/mo. Crypto invoice, no KYC.
Launch nowDrives decide the tier
No CPU benchmark ever picked the plan; capacity did. Trimmed operation retains about 25 GB of chainstate plus the mempool - comfortable inside the entry machine's 80 GB; deeper trims past 100 GB graduate to 160 GB; whole-history retention at 700 GB and climbing belongs on dedicated arrays. The first crawl obeys the same tyrant: it is drive-bound work, and local flash versus network storage is the gap between an afternoon and a lost week.
One line in bitcoin.conf sets the policy: prune=550 is the floor, denominated in MiB of recent blocks, and every larger value trades capacity for convenience. Blocks and chainstate default to ~/.bitcoin/, and both belong on the local device, full stop - the crawl performs millions of small random reads that object storage and network shares serve miserable, turning a half-day job into a multi-day ordeal you cannot abort without starting over. The floor is a printed minimum rather than a suggestion: chainstate sits outside the pruned window entirely, so a figure beneath what those fixed structures consume is refused at startup - the daemon would rather not run than run out of room mid-crawl.
Order Core at $6/mo ($4.80/mo on the annual term) for a trimmed personal installation: 80 GB of flash, 4 GB of DDR5, unmetered 1 Gbps - margin everywhere. Past a 100 GB trim appetite, the 160 GB tier is the next rung, and Titan's 320 GB carries serious local history on the same ladder. Whole-ledger retention with growth headroom is dedicated territory, where Summit's twin 2 TB devices swallow years of chain without complaint.
The classic misstep is sizing against today's tip: retention appetite compounds, an exactly-fitting drive is a migration appointment, and a device that fills mid-crawl wedges the whole project into an outage. When unsure, trim - depth can be raised later by re-downloading, while a wedged disk needs surgery and an apology. Capacity settled, the next decision is whether the machine merely listens or actually serves, and it arrives at one port.
One port separates client from infrastructure
A machine that only dials out verifies everything and serves nobody - a private auditor, not a participant. Arriving connections land on 8333, open by policy on this platform: no form, no ticket, merely a listening daemon. Transit never meters; the ceiling is the port, 1 Gbps at entry and multi-gigabit upward, so a well-peered installation costs identical bandwidth whether it feeds ten counterparts or a hundred.
Geography barely moves the counter; configuration does. getnetworkinfo reports whether arrivals are landing, and the host firewall must pass 8333/tcp. The fixed IPv4 every plan includes is a convenience for reachability, never a prerequisite - outbound work proceeds from any address, and arriving peers reattach to the network rather than to you personally, which is why migrations and address changes strand nobody who re-enables listening afterwards. A reachability read this cheap needs no peer list: getconnectioncount climbing past a dozen within an hour of the crawl ending means the port answers from outside, while a flat zero an hour later means a firewall is still replying with silence.
Calibrate expectations: dozens of inbound links is a healthy outcome for a well-connected machine, not thousands, and each costs a sliver of bandwidth plus a file descriptor. The knobs - maxconnections, listen=1, dbcache - are documented across the project repository, and on small plans the binding constraint is usually memory before bandwidth. Peer counts accrete over days through gossip; there is no switch to flip, only patience with a graph attached.
The dangerous typo in this genre is opening the RPC listener instead: 8332 facing the internet is an unauthenticated-credential incident with no retroactive firewall fix. Keep RPC on loopback or a private interface; the peer port is public by design and the control port never is. Bind the interface to 127.0.0.1 explicitly and gate it with an rpcauth line, and the incident stays a theoretical entry in somebody else's post-mortem rather than your Sunday. Should the installation avoid advertising its location altogether, the clean instrument is an onion service - next section, end to end.
An onion identity for the wire
An onion endpoint grants the installation a location-free identity while leaving wallet privacy untouched - separate files, separate risk models, zero coupling between them. Publishing a clearnet 8333 listener etches the host IP into peer records for the address's lifetime: acceptable for most operators, disqualifying for some. Tor supplies the middle path - full participation in arriving traffic, no address disclosed, at a latency cost a background crawl will never notice.
Support is first-class in Core, and the project's Tor document walks the whole path: aim proxy=127.0.0.1:9050 at a local Tor daemon, let the client publish its own service, and counterparts arrive through onion routing instead of your street address. Purists can go further with onlynet=onion, dropping clearnet wire traffic entirely - enforcement, crawling, and serving all continue untouched behind it. The Tor side asks for one line of its own - a ControlPort on 9051 with CookieAuthentication enabled - and Core then reads the cookie file at startup rather than storing any credential, so compromising either daemon discloses nothing about the other.
The ledger of costs is short. Latency rises; peer counts settle somewhat lower, since onion-capable counterparts are a subset of the network. On the credit side: geography stops mattering to reachability, the IP exits gossip entirely, and relocating to another region breaks nothing because the onion name travels with the installation. For a private machine whose operator picked the jurisdiction deliberately, that portability alone justifies the configuration.
Where the setup wobbles: dual-mode carelessness - announcing clearnet and onion together while assuming the onion conceals the clearnet leg. It conceals nothing; the wire sees what you announce, and gossip amplifies whatever it sees. Choose one identity for the peer leg and hold it consistent, revisiting only when the threat model changes. The same vigilance covers the daemon itself: under onlynet=onion a stopped Tor process reads to Core as an absent network, so the crawl stalls while the chainstate sits intact, and peers return the moment the control port answers again. Reachability resolved, one decision remains before hardware: which of the twelve flags the machine answers to - a question of statute and ping, not of protocol.
Flags, latency, and the law that answers
The gossip network is geographically indifferent; your administration is not. A single list price covers all twelve cities - Iceland +20%, Norway +20%, Switzerland +35%, Luxembourg +15% being the published exceptions - so the flag is chosen on statute and round-trip, never on billing. EU-facing installations crawl fastest from Frankfurt or Amsterdam; a discreet personal machine sits wherever the legal texture suits, which the offshore guide examines; a compliance-sensitive archive reads the law column before anything else.
The locations table is the working artifact: tier, uplink, and governing law per city. Facilities earn their place here for reasons specific to an always-on, years-long service - redundant power and fat uplinks decide how gracefully the box rides a bad afternoon. Disputes route under the facility's legal system, and while a machine speaking wire protocol presents a small legal surface, small is not zero and deserves a read before, not after, the invoice. A node is also a decade-scale tenant, which shifts the weighting: the statute that answers a subpoena in year five outranks a 20 ms ping difference in week one, and the table's law column is where that answer lives.
Latency mathematics flatter this workload. Counterparts relay fresh blocks within seconds of announcement regardless of continent, and tip-of-chain orphan risk belongs to the network, not to your round-trip. Geography genuinely alters two things: how snappy your own administration feels over SSH, and how quickly wallets you operate elsewhere are served. Optimize for the humans minding the box; the protocol remains indifferent to their coordinates.
The misallocation to avoid: paying the Zurich surcharge for a public indexer, or archiving compliance-sensitive material under a retention statute nobody read. Match flag to motive - privacy motive, Iceland or Switzerland; audience motive, Frankfurt or Singapore; indecision, base list price - with the jurisdiction guide as the worksheet. A trimmed installation keeps the exposure argument simple: no historical blocks exist to hand a requester and no index exists to query, so the flag protects the operator's own metadata rather than an archive the disk could surrender. Flag chosen, what remains is billing and a stopwatch, which is the pleasant part.
Settling for the machine
Nineteen instruments clear the bill, and the selection is a discretion-and-fee question, never a node question: XMR for a discreet rail, tether-TRC20 for a pinned figure, BTC when already held. Intake remains credential-only - an address, a 12-character secret - and the sequence matches the purchase walkthrough, with the Monero page covering the discreet path end to end. Nothing about a verifying installation adds plumbing to that flow.
Whole-history machines settle through the same checkout: buy the Forge at $49 list ($39.20 annual-eff) when full-speed crawling and 2 x 1 TB of flash cover the archive; graduate to Summit when the ledger plus growth headroom wants twin 2 TB devices and 64 GB of ECC. Assembly consumes 2-4 hours with the IPMI console released at the end, and every tier from Forge to Monolith prices through the identical nineteen-instrument bill. Capacity changes; paperwork does not.
Keep the clocks separated in your head: chain depth precedes the credit, and the credit precedes everything else. Two blocks gate a BTC remittance; the instance then boots inside a minute; racks consume their 2-4 hours after the credit, not after broadcast. The printed ETA on the bill page exists precisely so you can start the dispatch when you will actually be present for the wallet leg rather than asleep. The split pays a small dividend if you let it: mint the bill, then spend the confirmation window drafting the bitcoin.conf you intend to paste at first login, so the chain's waiting room becomes preparation rather than an evening of refreshing a block counter.
One temptation deserves refusal at this stage: adopting a machine somebody else imaged for you. Take the box blank, install from the official release, verify what runs - the entire credibility of a self-verifying installation rests on having built it, and a stranger's pre-baked image re-imports the API's word through the tradesmen's entrance. Verification is arithmetic you personally ran: check the release signature before installing, then note the block hash your own chainstate reports at the tip and compare it against one explorer exactly once - from that moment, disagreement is the alarm rather than a routine. Installed, synced, and self-audited, the machine earns its first tenant: Lightning.
Lightning moves in upstairs
A routing client coexists happily with bitcoind on any plan, and it wants memory before CPU - channel state lives in RAM and forwarding is bookkeeping. What genuinely changes is posture: channels are state with funds attached, the machine becomes a counterparty, and backup discipline graduates from virtue to requirement. The Lightning workload page holds the channel specifics; watchtower plus clean copies is a production-grade pattern on a plain instance.
The two mainstream clients - LND and Core Lightning - share the underlying peer and add their own wire ports. Keep administrative interfaces on loopback - lnd and lightningd both default sensibly - expose only what forwarding requires, and let the base installation keep enforcing the chain exactly as it already was. The original paper explains the live-backing requirement plainly: penalty transactions are clock-critical. HTLCs expire on pre-agreed clocks, so a clean reboot costs nothing, while an outage that outlasts a pending contract's deadline can convert a routine force-close into an expensive one.
Restoration is where routing punishes improvisation. The channel database - channel.db under LND - travels with its static-channel companion file, and recoveries must follow the implementation's documented procedure, because replaying stale state can hand a counterparty a forced-close windfall at your expense. Platform-side, the playbook is ordinary: scheduled snapshots plus off-box copies, the same regimen the backup playbook prescribes for any stateful tenant.
The expectation to reset: forwarding is not day-one income. Channels want capital on both ends, fee policy wants tuning, and a machine that routes nothing earns nothing - the network functioning exactly as designed, not a defect to report. Adopt routing because self-custody of payments is the goal, and treat throughput as a slow bonus that arrives over months. Inbound capacity is the scarcer half: a node holding only outgoing links forwards nothing until a counterpart opens a channel toward it, which is why liquidity is leased as a market rather than merely provisioned. Disk, reachability, flag, settlement, channel state - every component now exists, and only the assembly order remains.
The Bitcoin full node, in the order to run it
Capacity first, because it selects the tier: trim to roughly 25 GB inside the entry machine's 80 GB, climb the ladder past a 100 GB appetite, and reserve dedicated arrays for whole-history depth. Write prune=550 or larger into bitcoin.conf, keep consensus state on the local device, and never aim the initial download at a network share - that single misconfiguration converts hours into days, and no amount of patience repairs it.
Reachability second: open 8333 if the machine should serve, keep the RPC listener on loopback unconditionally, and add an onion identity when the IP must stay out of gossip - onlynet=onion for the strict version. The flag comes third, chosen from the locations table on statute and round-trip: surcharges mark Iceland, Norway, Switzerland and Luxembourg; every other city bills at base list, leaving the invoice out of the argument entirely.
Settlement fourth, in whatever instrument fits: nineteen on one page, XMR for discretion, tether-TRC20 for a frozen figure, BTC when already held. An instance boots about a minute after the credit; racks consume the racking window with the console released last. Fifth, install from the official release and watch getblockchaininfo through the crawl - hours on local flash - and distrust anything promising to shorten it magically.
Tenants sixth, added deliberately: routing wants memory before CPU, administrative interfaces stay on loopback, and channel state acquires its backup regimen before the first channel funds. Verification seventh and finally: balances read from your own enforcement, keys duplicated separately from reproducible chain data, nothing in the stack inherited from a stranger's image. A machine you built and audited is the only kind that answers the original question - whose word do your balances carry?
The assembly order, compressed: capacity, reachability, flag, settlement, installation, tenants, audit. Every step above has its own section; every misstep catalogued here has its cure in one of them. Run the list straight and the finished machine answers to you alone - which was, from the first paragraph, the entire point of the exercise.
Is a pruned node enough?
For validating your own balances, entirely - trimming preserves full enforcement while discarding historical block files, retaining about 25 GB on the entry tier's 80 GB device. Whole-history retention is a separate purchase: capacity, patience for the first crawl, and a tier sized for a ledger that only grows.
Can Lightning run on the same box?
Yes; LND or Core Lightning coexist with bitcoind on any plan, and forwarding wants memory before CPU. The hosting bill stays on-chain at layer one. Give the channel database its backup regimen before the first channel funds, and the pairing is a standard production shape.
How long does the initial sync take?
Hours rather than days on local flash, because the first download is drive-bound work. Aim it at a network share and the ordeal multiplies - the single costliest setup error in this genre - so keep the consensus database local and the sync behaves.
Does the node need a static IP?
It does not. Outbound work proceeds from any address, and arriving counterparts reattach to the network rather than to a particular machine. The fixed IPv4 bundled with every plan is a convenience for port reachability, and an onion identity removes even that dependency.
Why not run the node at home?
You can, and many do as a first machine. A rented one contributes unmetered, well-peered transit at multi-gigabit rates, availability decoupled from your household connection, and a flash queue that survives the mempool's roughest evenings - at entry-tier pricing on the annual commitment.
Primary sources
More ways to pay
Pay with Bitcoin · Pay with Monero · Pay with USDT (TRC-20/ERC-20/SPL) · Pay with Litecoin · Pay with Ethereum · Pay with Solana · Pay with x402 · Pay with Dogecoin · Pay with XRP · Pay with TRX · Monero on bare metal · Dedicated servers with crypto · Pick the jurisdiction first.
Ready to launch?
Build the box — VPS or bare metal — create the password, pay the invoice that follows.