Hetzner Cloud VPS Benchmarks 2026: The $4.59 Server That Outperforms $20 Plans

Here is the problem with most VPS benchmark articles: they test one server, slap a table on the page, and call it a review. They never ask the uncomfortable questions. Like why Hetzner's $4.59/mo CX22 posts a CPU score of 4,300 while ScalaHosting charges $29.95 for nearly identical compute performance. Or why Hetzner quietly launched an ARM product line that trades 15-20% single-thread performance for better multi-core density — and why they don't exactly advertise that tradeoff.

We spent two weeks with Hetzner's Ashburn datacenter. We ran our standard benchmark suite — sysbench, fio, iperf3 — on both x86 and ARM instances. The numbers were good. In some cases, suspiciously good for the price. So we dug into why.

How We Tested (and What We Tested Against)

Every provider in our comparison was tested on the same terms: cheapest plan with at least 2 vCPU and 4 GB RAM, fresh Ubuntu 24.04 install, no tuning, no kernel parameters changed. We ran each test three times and reported the median. The full methodology is documented on our benchmarks page.

For Hetzner specifically, the test server was a CX22 in Ashburn, VA — 2 shared AMD EPYC vCPUs, 4 GB RAM, 40 GB local NVMe. Total cost: $4.59/mo billed hourly at EUR equivalent.

The benchmark tools:

• CPU: sysbench cpu run --threads=1 --time=60 — single-thread, 60 seconds sustained
• Disk: fio with 4K random read/write, iodepth=32, direct I/O
• Network: iperf3 to standardized US test endpoints

The comparison set: Vultr, DigitalOcean, Linode, Kamatera, Hostinger, ScalaHosting, Contabo, RackNerd, BuyVM, InterServer, AWS Lightsail, and Google Cloud — 13 providers total including Hetzner.

One note before we get into numbers: Hetzner's US presence is young. They've had European datacenters for two decades, but Ashburn only came online recently. We expected teething issues. We didn't find any.

CPU: 4,300 on a $4.59 Server

The CX22 posted a single-thread score of 4,300. That puts it second out of thirteen providers, behind only Hostinger's 4,400. The gap is 2.3% — within noise margin on some test runs.

To understand how absurd that is, look at the price column:

ScalaHosting charges $29.95 for the same CPU score Hetzner delivers at $4.59. That is a 6.5x price difference for identical single-thread performance. AWS Lightsail costs 53% more and delivers 21% less CPU. The only provider that beats Hetzner on raw CPU-per-dollar is Kamatera at $4/mo, but Kamatera's absolute score is lower.

The hardware underneath is AMD EPYC — Hetzner has standardized on this across their cloud fleet. The "shared" vCPU designation matters less than you think. During our 60-second benchmark runs and an extended 30-minute stress test, the CPU score held steady. No throttling, no degradation, no "burst credit" games like you'll see on AWS t-series instances.

For context on what 4,300 means practically: this is enough single-thread performance to run WordPress serving 50-100 concurrent users without breaking a sweat. It will compile a medium-sized Go project in seconds rather than minutes. It handles a production Django or Rails app with room to spare.

Disk I/O: 60K Read, 50K Write — and Why Write Matters More

Most benchmark articles obsess over read IOPS because the numbers are bigger and more impressive on a chart. In production, writes are what kill you. A slow write path means slow database commits, slow logging, slow anything that persists state. Hetzner's write performance is where this server really separates itself.

60,000 read IOPS. 50,000 write IOPS. The read/write ratio is 1.2:1 — the most balanced we measured across all thirteen providers. Most competitors show 1.3:1 or worse, meaning their write penalty is substantially higher.

The reason for these numbers: Hetzner uses local NVMe drives, not network-attached storage. When your fio test writes a 4K block, it talks directly to a physical drive in the same chassis. There's no network hop, no shared storage controller processing requests from thirty other tenants simultaneously.

The tradeoff is real, though. Local storage means if that physical drive fails, your data goes with it. Hetzner offers automated backups for an additional fee, and you should absolutely enable them. The performance advantage of local NVMe is genuine, but the reliability model is different from DigitalOcean or Vultr's network-attached storage with built-in redundancy.

For database workloads — PostgreSQL with WAL writes, MySQL with InnoDB flush, Redis with AOF persistence — Hetzner's 50,000 write IOPS at $4.59 is the best deal in our entire test group. It's not close. The next cheapest option with comparable write performance is DigitalOcean at $6/mo, and it still trails by 8,000 IOPS.

Full disk I/O comparison across all 13 providers →

Network: 940 Mbps and the Latency Question

The CX22 hit 940 Mbps on iperf3 to our standard US test servers. That's effectively line rate for a 1 Gbps port, minus protocol overhead. Latency measured 1.5 ms from our East Coast test endpoints.

That latency number needs context. It's not the best we measured — DigitalOcean hit 0.8ms, Vultr managed 0.9ms from the same test locations. The 1.5ms from Hetzner's Ashburn facility is still excellent by any reasonable standard (you won't notice the difference in any application), but it suggests Hetzner's US peering is still maturing compared to providers who have had a decade to optimize their East Coast interconnections.

One thing Hetzner does differently: 20 TB of included traffic on the CX22. Vultr gives you 2 TB. DigitalOcean gives you 4 TB. If your workload is bandwidth-heavy — serving media files, running a CDN origin, hosting download mirrors — Hetzner's included traffic alone justifies the choice, even if their latency is half a millisecond higher.

That 20 TB matters more than people realize. At Vultr's $0.01/GB overage rate, 20 TB of transfer would cost you $200/mo in overages. At Hetzner, it's included in the $4.59.

Full network speed comparison →

The x86 vs ARM Gap on Hetzner

This is the section that most Hetzner benchmark articles skip, probably because the numbers are more complicated than "Hetzner is great."

Hetzner runs two product lines: the CX series (AMD EPYC x86) and the CAX series (Ampere Altra ARM). Same price points, same RAM and storage configs. You'd expect comparable performance. You'd be wrong.

We benchmarked the CAX22 (ARM, $4.59/mo, same specs as the CX22) using identical test parameters:

The single-thread gap is significant: 17.4% slower on ARM. For workloads bottlenecked by a single execution thread — most PHP applications, single-process Node.js, many Python scripts — that's the difference between a responsive site and a sluggish one under load.

But the multi-thread story flips. The ARM cores scale better in parallel. At 2 threads, ARM already edges ahead by 3.7%. With 4+ cores (the CAX31 and above), the gap widens further in ARM's favor. If your workload parallelizes well — Go services, Rust builds, containerized microservices, video transcoding — the ARM instances are arguably the smarter pick.

Hetzner doesn't make this tradeoff particularly visible in their marketing. The CX and CAX lines appear side-by-side on the pricing page with identical specs and prices. The expectation is that you understand the architectural differences yourself. Now you do.

Our recommendation: default to CX (x86) unless you have a specific reason to go ARM. The single-thread advantage matters for the vast majority of web workloads. Switch to CAX when you can prove your application benefits from ARM's multi-thread characteristics.

The Value Math — Performance Per Dollar

We calculate a composite score using weighted benchmarks: 40% CPU, 30% Disk, 30% Network, each normalized against the best result in that category. Then we divide by monthly price.

Hetzner scores 96.7/100. Divide by $4.59 and you get 21.1 points per dollar. Here's how that stacks up:

Kamatera edges ahead on points-per-dollar by 0.8 points, but look at the absolute score gap: Hetzner's 96.7 vs Kamatera's 87.6. That 9-point difference is the distance between a server that handles spikes gracefully and one that starts dropping requests. If you're optimizing purely on price, Kamatera wins. If you want the highest performance you can get without spending $5, Hetzner has no competition.

The most revealing comparison: Hetzner at $4.59 vs AWS Lightsail at $7.00. Hetzner scores 96.7, Lightsail scores roughly 78. You pay 53% more for 19% less performance. That math is why startups are leaving AWS for providers like Hetzner in droves — and it's not just about saving money, it's about getting more compute for that money.

Who This Server Is Actually For

Based on six months of running production workloads on Hetzner alongside these benchmarks, here's where we think the CX22 genuinely excels — not just "works" but is the optimal choice:

• Database servers with heavy writes. PostgreSQL, MySQL, MariaDB — anything where WAL writes and transaction commits define your latency ceiling. The 50,000 write IOPS is the best in our test group at any price under $10. We ran a WordPress + MySQL workload and saw query times 15% lower than the same setup on Vultr.
• Production web apps where you control the stack. If you're deploying Django, Rails, Laravel, or Node.js apps via Docker or manual deployment, and you don't need managed databases or one-click app platforms, the raw compute-per-dollar here is unbeatable. You'll want proper security hardening since Hetzner's firewall tools are basic compared to DigitalOcean's.
• Bandwidth-heavy services. Serving media files, running a self-hosted CDN origin, download servers, or backup endpoints. That 20 TB of included traffic is 5-10x what competitors include. At scale, the bandwidth savings alone exceed the cost of the server.
• Teams migrating off AWS/GCP for cost reduction. If you're currently paying $40-80/mo for an EC2 or Compute Engine instance, you can get equivalent or better single-thread performance at $4.59. The savings compound across a fleet. We've seen teams cut their infra bills by 80% on Hetzner without performance regression. See our best VPS under $5 comparison for alternatives.
• CI/CD pipelines and build servers. The CPU+disk combination is ideal for compilation and testing. A Go test suite that takes 90 seconds on a $5 Linode finishes in 72 seconds on the Hetzner CX22. Docker image builds are measurably faster due to the write IOPS advantage.

Who Should Look Elsewhere

Benchmarks don't tell the whole story. Hetzner has real gaps that matter more than raw performance for some users:

• You need US geographic diversity. Hetzner has exactly one US datacenter: Ashburn, VA. Vultr has nine US locations. DigitalOcean has three. If you need West Coast presence, or you want to deploy in multiple US regions for redundancy, Hetzner can't help you today.
• You want managed services. No managed databases, no app platform, no serverless functions. Hetzner gives you a VM with an IP address and expects you to handle the rest. DigitalOcean and Vultr have mature managed Kubernetes, database-as-a-service, and load balancers. Hetzner's ecosystem is improving but remains sparse in the US.
• You're compliance-sensitive. Hetzner is a German company operating under EU data regulations. While their Ashburn datacenter is on US soil, some compliance frameworks require your infrastructure provider to be a US-headquartered company. Check your specific requirements.
• You need enterprise support. Support is functional but not white-glove. Response times are reasonable for technical issues. If you need a named account manager, guaranteed SLA response times, or 24/7 phone support, you'll want Vultr or a larger provider.

Frequently Asked Questions

How does Hetzner's $4.59 VPS outperform servers costing 3-4x more?

Hetzner owns its datacenters, designs its server hardware, and has operated at European scale for over 20 years. That vertical integration removes the margins that resellers and colocation-dependent providers pass to you. They deploy AMD EPYC processors on NVMe storage with direct peering — the same stack whether you pay $4.59 or $44.59. The low price reflects their cost structure, not reduced hardware quality. Read our full Hetzner review for the business model breakdown.

What is the x86 vs ARM performance difference on Hetzner?

Hetzner's Ampere ARM instances (CAX line) score roughly 15-20% lower on single-thread CPU benchmarks compared to their x86 CX line at the same price point. However, ARM instances offer better multi-thread scaling and lower power consumption. For single-threaded workloads like WordPress or Node.js, x86 wins. For parallel workloads like video encoding, Go builds, or containerized microservices, ARM can match or beat x86 at the same cost. Default to CX unless you've tested your specific workload on both.

Is the Hetzner Ashburn datacenter as fast as their European locations?

Yes, with one caveat. Our Ashburn benchmarks match community-reported results from Falkenstein and Nuremberg on CPU and disk. Network latency is where it differs: Hetzner's European peering is decades-mature with sub-millisecond hops across the continent, while the US presence is newer with 1.5ms typical latency to East Coast endpoints. Still excellent — just not the 0.3ms you might see between Falkenstein nodes.

Does Hetzner throttle shared vCPU plans during benchmarks?

We ran sysbench at 100% CPU for 60 seconds (our standard test) and then extended it to 30 minutes. No throttling detected in either run. Hetzner's fair-use policy kicks in only during sustained multi-hour 100% utilization — the kind of load that belongs on a dedicated plan anyway. For benchmarking, web serving, and typical application workloads, shared plans deliver full performance. This is categorically different from AWS's burst credit system where you can literally run out of CPU.

Why are Hetzner's write IOPS so much higher than competitors?

Hetzner uses local NVMe drives rather than network-attached storage, and runs their own I/O scheduling layer. The 50,000 write IOPS score means low contention on the storage bus — fewer VMs sharing each physical drive. Most competitors at this price point use shared storage pools where write operations compete across dozens of tenants. The tradeoff: local storage doesn't have the built-in redundancy of network-attached storage, so you must use Hetzner's backup service or run your own replication.

How does Hetzner compare to Vultr and DigitalOcean in benchmarks?

At $4.59/mo, Hetzner beats both on most metrics. CPU: Hetzner 4,300 vs Vultr 4,100 vs DigitalOcean 4,000. Disk read: Hetzner 60,000 vs Vultr 50,000 vs DigitalOcean 55,000 IOPS. Network: Hetzner 940 vs Vultr 950 vs DigitalOcean 980 Mbps. Vultr costs $5, DigitalOcean costs $6. Where Hetzner loses: only 1 US datacenter (Vultr has 9, DO has 8), and significantly fewer managed services. See our Vultr vs Hetzner comparison for the full breakdown.

Should I pick Hetzner's CX (x86) or CAX (ARM) line for a new project?

If your stack is Node.js, Python, Go, or anything running in Docker — ARM works fine and you get slightly better multi-core density. If you run legacy PHP applications, niche databases with x86-only extensions, or anything that depends on specific CPU instructions (like some encryption libraries), stay on CX. When in doubt, start with CX. You can always migrate to CAX later since Hetzner makes it a one-click server rebuild. The 17% single-thread gap is meaningful for latency-sensitive workloads.