Self-Hosting a BTCPay Server on a VPS

Size a self-hosted BTCPay Server: pruned Bitcoin node on NVMe, ports 80/443/8333/9735, Prime from $9.60/mo annual-eff. No KYC, crypto-only checkout.
Size a self-hosted BTCPay Server: pruned Bitcoin node on NVMe, ports 80/443/8333/9735, Prime from $9.60/mo annual-eff. No KYC, crypto-only checkout.
Owning the rail versus renting it
The fee comparison is the feeblest argument for self-hosting BTCPay — the formidable one is custody. A third-party processor can freeze your checkout, hold a rolling reserve, or demand your buyers' papers; your own node mints the invoices, settlements land straight in your wallet, and no counterparty squats between you and the chain. The payment rail graduates from subscription to property.
Mechanically, BTCPay Server is a free, self-custodial processor: invoices derive from addresses your node watches, and the node validates every settlement against the chain rather than taking an API's word for it (the project's documentation covers the architecture — BTCPay Server documentation). Point-of-sale apps, crowdfunding pages and the Greenfield API all hang off the same self-verified balance, so the trust question migrates from a company's solvency to the discipline of your backups.
The hosting choice belongs to the same design: if the point of BTCPay is evicting the middleman from payments, a box that demands a passport reinstates him at the infrastructure layer. Signup here is token or email plus a 12-character password, the invoice is crypto-only across nineteen coins, and no KYC documents change hands — the minimum-data checkout guide explains what that does and does not mean, and the buying guide scripts the order itself.
There is also a procurement symmetry worth noticing: the coins your hosting accepts are the coins your customers can pay you in. One ledger — BTC, XMR, USDT across its networks, and the remainder of the nineteen — settles both the infrastructure bill and the storefront's revenue, which shrinks the reconciliation surface from two payment stacks to one and strikes the last card processor from the org chart entirely.
The classic error: self-hosting the processor while leaving custody half-finished — seeds on the same volume as the application, no tested restore, no offline copy. BTCPay dismisses the third party; it does not dismiss your obligation to the keys. Treat the deployment as a custody project that happens to wear a web UI, and the sizing questions in the coming sections become plain arithmetic instead of existential debates.
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 nowThe sizing floor is the node, not the checkout
The surprise in every BTCPay sizing thread: the web checkout is nearly free to operate, and the Bitcoin node standing behind it sets the entire floor. Block validation, not invoice rendering, devours CPU during sync and memory during index work — so you size for a node that happens to serve a checkout, never the reverse, and the modesty of your order volume is irrelevant to the arithmetic.
The practical floor here is Prime — 4 vCPU, 8 GB DDR5, 160 GB NVMe at $12 list, $9.60 on the annual term — which hauls a pruned node plus the web checkout with room left for a small storefront. Order Prime at $9.60/mo annual-eff ($12 list) as the baseline and step up when Lightning volume arrives; Titan at $24 list ($19.20 annual-eff, 8 vCPU and 32 GB ECC) is the comfortable tier once routing becomes a genuine occupation. Both tiers sit printed in the plan ledger.
Why the numbers lean this way: during initial block download the node validates every block back to the genesis one — processor-bound verification pressing on NVMe write lanes — and after sync it dozes at low single-digit CPU while invoices flow past. The checkout path itself is a fistful of requests per order. Local NVMe on every plan is what compresses that first download from days into hours, which is why storage class matters more than storage size here.
A sizing habit that transfers beyond BTCPay: measure the sleepy baseline and the synchronized peak separately. The node idles for most of its life and lunges during sync, index rebuilds and reindex-after-crash; the storefront idles for most of its life and lunges during campaigns. Buying for the lunge rather than the doze is the entire discipline — and the two lunges rarely share an hour, which is what makes co-location negotiable at all.
The error: sizing by invoice volume — twenty orders a day sounds minuscule — and buying a token slice, then wondering why chain sync devours a week and the checkout times out mid-sync. The node is the tenant that never sleeps; size for it and the checkout rides free. The coming sections walk the disk, port and Lightning decisions in exactly that order.
Pruning: the only disk decision you must make on day one
You do not need terabytes to operate a fully verifying node — pruning keeps validation whole and discards ancient block data you will never re-serve. The disk question is not how large the chain has grown but how much recent data your purposes require, and the answer gets set once, in megabytes, before the first sync ever begins.
The mechanics: Bitcoin Core's -prune=N ceiling caps block storage at N megabytes while the UTXO set and indexes stay intact — the pruning document in the Core repository defines the behavior and its floor (Bitcoin Core pruning doc — doc/pruning.md). BTCPay's Docker deployment exposes the setting through its environment rather than a hand-edited config, and the supported route is the btcpayserver-docker repository (btcpayserver-docker), whose btcpay-setup.sh regenerates the stack after every change.
A pruned first download over local NVMe measures in hours, not days — the 160 GB NVMe on Prime harbors a pruned node with room to spare, and the 80 GB on Core harbors one too while the target stays modest. On metal, Monolith's 4×2 TB is archive territory: full blocks retained for the pursuits that genuinely want them, behind a 25 Gbps port with an L3/L7 scrubber standing guard.
Choose the target with the workload, not with anxiety: a checkout that only needs current balances and recent history thrives far beneath a full archive, while a block explorer or an analytics hobby legitimately wants everything. The mistake underneath most pruning regret is sizing for an ambition the project never stated — decide which queries you will actually run, and the megabyte figure falls out of the answer like a receipt.
The classic stumble: beginning unpruned to keep options open on a small volume, filling the NVMe mid-sync, and restarting the entire download after the cleanup. Decide the target first — most checkout-only deployments never re-serve old blocks — and let the disk budget follow the verdict. Patience across this one sync purchases verifiability for every invoice that ever follows it.
Ports and TLS: three openings, one domain
The network surface of a BTCPay box is smaller than newcomers expect: 80 and 443 serve the checkout, 8333 receives inbound node peers, and 9735 joins only when Lightning does. Everything else — the wallet RPC above all — stays on loopback, and the deployment is calmer and safer for the restraint than any dashboard-driven pile of openings would be.
Aim a domain at the box before the first run: the Docker arrangement requests and renews the certificate automatically against that hostname, and the A record matters here — Let's Encrypt's rate limits tolerate one deployment but not hourly retries against misconfigured DNS (limits documented — Let's Encrypt rate limits). Get the record right once and TLS becomes a non-event for the machine's lifetime, renewing itself while you sleep.
Port 8333 inbound is how your node contributes peers to the network and hears about new blocks sooner; leaving it closed functions, but casts you as a listener rather than a participant. Audit the listening surface with ss -tlnp after install — the socket tool's man page annotates every column (ss(8) manual) — and confirm nothing beyond the three ports faces the public internet.
Revisit the audit after every stack change, not just once: an upgrade, a plugin, or a debugging session that left a listener bound to 0.0.0.0 will outlive its author. A weekly comparison between the listening surface and the expected three-port baseline turns configuration drift from a discovery into an alert — the same habit that keeps a firewall honest keeps a wallet's host honest.
The classic error: exposing the node's RPC port to make integrations more convenient — the RPC interface commands the wallet, and it belongs on loopback behind the application, never on a public interface. Three ports, one domain, everything else denied: the checkout is public, the node is a peer, the wallet is unreachable. With the surface settled, the Lightning question becomes an upgrade rather than an exposure.
Lightning: when the extra cores pay for themselves
Lightning demands not a larger disk but an uptime pledge. Channels require the stable IPv4 every plan ships with, 9735 unblocked, and a node that never vanishes for hours, because a routing node that naps drops payments it undertook to forward. That is why the upgrade that matters is reliability and cores, never storage volume.
Both major implementations run beneath the BTCPay Docker deployment — LND (its repository documents channel stewardship — lnd repository) and Core Lightning (Core Lightning documentation). On-chain settlement confirms in minutes to an hour; Lightning settles in milliseconds and the buyer's cart never waits. For a checkout that is the difference between paid-pending and paid — a distinction your order pipeline feels on the very first sale of the morning.
The operational addition is recovery: before opening channels, export the static channel backup — channel.backup under LND — and store it somewhere the box has never met, because channels are state and boxes are replaceable. Watchtowers supply a second line of defense for absent spells. On Titan the additional cores absorb routing load without complaint; on Prime, light personal-scale routing behaves and heavy forwarding sulks.
Liquidity deserves the same deliberateness as backups: open channels to well-connected peers, balance inbound and outbound capacity, and resist the urge to pour funds into a single giant channel. A routing node is a small market maker; its usefulness is measured in the diversity of its connections rather than the girth of any one pipe, and the discipline scales down gracefully to a checkout that merely wants instant settlement.
The error: opening channels on day one with funds you cannot afford to lock, before the invoice flow has proven itself. Channels are commitments denominated in months; prove the checkout first with on-chain invoices, then fund routing deliberately. Lightning is the upgrade that makes Titan's extra cores pay rent — it is also the component that converts a payment button into a 24/7 operation carrying genuine obligations.
Why the no-KYC fit is structural, not cosmetic
Pairing a self-custodial processor with hosting that skips identity checks is not a marketing rhyme — it seals the same gap at both layers. A processor that verified nobody's papers while sitting on a host that verifies everybody's would merely relocate the chokepoint. End to end, this deployment requests neither: token or email signup, nineteen coins, no documents — and you can be live within an afternoon of deciding.
The checkout mirrors the hosting: buyers settle in BTC, XMR or USDT across its networks, or any of the other coins the invoice offers, and the payment lands in your wallet — not in a processor's pooled account. XMR is first-class here, and USDT rides TRC-20, ERC-20, BEP-20, SPL, Polygon, Arbitrum and Optimism. The coins your hosting invoice accepts are, by construction, the coins your customers can pay you in.
The privacy posture is factual, not mystical: no payload or guest traffic logs, billing and panel actions retained, connection metadata kept at most 24 h, DDoS scrubbing included. Abuse is adjudicated under the law of the facility's location, which is why jurisdiction is a genuine decision — Reykjavik and Zurich carry premiums of +20% and +35% for their legal regimes, and the locations table prints the law for each of the twelve sites while the offshore guide compares them.
Match the jurisdiction to the checkout's audience, in the diplomatic sense: if your customer base clusters in one region, a facility whose legal regime you can actually read beats a random pick on price alone. The premium cities earn their surcharge only when their specific protections matter to your operation; for most checkouts the honest answer is that any of the twelve works, and the spec sheet should decide instead of the folklore.
The error: treating the low-friction signup as a shield. No-KYC hosting removes a data broker; it does not render traffic unattributable, and abuse still resolves under facility law as it would anywhere. Use the posture for what it is — less paperwork between you and your infrastructure — and let operational security inhabit your own habits: keys, backups, updates, and a threat model you can actually maintain.
Co-locating the storefront: honest arithmetic
The same box can carry the storefront, and for most small merchants it should — but the sizing honesty must include the node's worst minutes, not its average afternoon. Chain syncs, index rebuilds and Lightning rescans are the stretches when the node lunges for memory, and those stretches are exactly when a co-located shop is most visible to the customers who fund it.
The arithmetic on Prime: node, checkout and storefront share 8 GB, and the storefront's crest is your traffic crest, which may or may not coincide with the node's. Observe with docker stats during a forced sync in staging — the resource flags in the Docker docs demonstrate how to cap each service (Docker resource constraints) — and grant the node a memory ceiling so the shop keeps answering while the chain performs its occasional heavy lifting.
When the crests collide in practice, the upgrade is a single plan step: Titan at $24 list — $19.20 on the annual term — doubles the cores to 8, quadruples the memory to 32 GB ECC, and dissolves the collision question entirely. Move to Titan at $19.20 annual-eff ahead of the storefront's busy season, never during it; the delta is one invoice line against an outage's entire afternoon and its reputation tail.
The staging trick makes the decision empirical instead of anxious: replay a day's real traffic against the co-located stack while the node sits mid-sync, on a test box, ahead of the season that matters. If the storefront's error rate holds, co-location is fine and the money stays in your pocket; if it wobbles, you have measured exactly how much headroom the campaign will need, and the plan step stops being a guess.
The classic stumble: sizing by the storefront's average CPU and meeting the node during the first campaign — the two workloads crest together on sale days, traffic and settlement arriving in the same hour. Small catalog, steady traffic: one box is right. Campaign-driven cliffs: separate the tiers and let DNS choose who serves. Either way, watch memory rather than CPU, because memory is where the node wins the quarrel.
Monero invoices and the plugin reality
Customers can pay in XMR through BTCPay — via community plugins rather than the core flow, and that distinction carries an operational edge: plugin maturity trails core, and a production checkout is the worst conceivable place to beta-test. If Monero invoices grow into the majority of your volume, the integration has earned a staging rehearsal before it ever faces a paying stranger.
The core flow is BTC and Lightning: invoices derive from watched addresses, and confirmations are tallied by your own node. Community plugins graft Monero on by running monerod alongside the stack and watching XMR destinations in the same self-custodial fashion — the wallet RPC interfaces are documented in the Monero developer guides (Monero developer guides). The architecture rhymes with BTCPay's own: your daemon, your wallet, your verification, no custodial hop anywhere in the middle.
Alternatively, accept XMR wholly outside BTCPay — a static address, or a minimal gateway on a second subdomain — and keep the two flows estranged. That split trades unified reporting for simplicity: the BTC and Lightning checkout stays on battle-tested core, the Monero side runs its own small stack on its own update rhythm. Both remain self-custodial; only the operational surface differs, and the Monero payment guide covers the direct route.
Whichever route you choose, rehearse recovery on it: restore the Monero wallet from its seed on a scratch machine, confirm the balance reappears, and only then trust the flow with revenue. Custody claims are cheap to make and expensive to discover false — a ten-minute restore drill per wallet converts every custody claim in the stack from a slogan into a verified fact with a date attached.
The error: launching the plugin build on launch day because the demonstration worked. Plugin updates follow the community's cadence rather than yours, and a checkout regression devours orders nobody will report. Pilot in staging with real amounts, pin versions, read the changelog like an operator — payment diversity is staged, never switched, and the fallback flow must still function while the newcomer earns its keep.
The BTCPay rollout, in the order to run it
Begin with identity and DNS: elect the hostname, aim its A record at the box, and let TLS automate against it — before the first install, never after. Then take the supported route: clone the btcpayserver-docker repository, set the environment including BTCPAY_HOST and the prune target, and run btcpay-setup.sh, which assembles and starts the entire stack in one motion.
While the first download runs — hours on local NVMe, pruned — verify the openings: 80 and 443 answering, 8333 accepting peers, nothing else exposed per ss -tlnp. The node inspects every block itself, which is the entire point; the sync is the project's one long wait, and everything following it is quick by comparison. The wait tracks storage class rather than plan size: a prune target fixed at install keeps the data volume small, while an unpruned start on a small volume fills mid-sync and forces the entire download to run again.
Prove the checkout with small real invoices before any announcement: on-chain first, then Lightning once the ports and channels stand ready — exporting channel.backup off the box before the opening channel funds. Test any Monero plugin in staging with genuine amounts and pinned versions, and keep the on-chain flow operational as the permanent fallback while everything else matures around it.
Wire the operational plumbing early, while the stakes are toy-scale: a webhook into your order system, a daily balance check, disk and memory alerts, and one full backup-restore rehearsal. Integrations built during the quiet week behave during the loud one; integrations promised for later have a documented habit of becoming the outage. Run the restore drill once against a copy that does not matter, so the procedure is a known quantity before the first real campaign needs it in anger.
Seal the custody loop: seeds and wallet backups stored where the box has never been and restored once on purpose, docker stats watched through the opening sync and the first campaign, and the monthly patch cadence from the base hardening checklist. From there the node hums — validating every block, minting every invoice, deferring to nobody's API but the chain's.
What plan should I pick for BTCPay?
Prime — 4 vCPU, 8 GB, 160 GB NVMe at $12 list, $9.60 annual-eff — is the practical floor for a pruned node plus the web checkout. Add Lightning volume and Titan's extra cores pay for themselves: BTCPay wants CPU and fast small-file NVMe, not bulk capacity, and Titan adds 32 GB ECC for routing work.
Do I need my own domain?
Yes. The TLS certificate automates against a hostname, and customers read the checkout URL — a bare IP or a shared name undermines the trust the whole setup exists to build. Point the A record before the first install and certificate issuance and renewal stay invisible for the life of the box.
Can customers pay in Monero through BTCPay?
Through community plugins, yes, though the core flow is BTC and Lightning. If XMR invoices become the majority of your volume, test the plugin in staging first with real amounts — plugin maturity moves slower than core, and a production checkout is the last place to discover that difference.
Can the box also run the storefront?
It can, but size honestly: node, checkout and storefront share 8 GB on Prime. Watch memory during chain syncs and index rebuilds — those are the moments a co-located storefront feels the node — and the step to Titan at $24 list is cheaper than an outage during your first big campaign.
How long does the initial sync take?
A pruned first download over local NVMe measures in hours rather than days — every plan ships local NVMe, and the prune target set before install keeps the data volume small. The wait purchases verifiability: after sync, your node has checked every block itself and answers invoice requests from its own mathematics.
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.