Hetzner vs Contabo 2026: I Ran Both for 6 Months — Here’s What the Spec Sheets Won’t Tell You

Six months ago I provisioned two servers: Hetzner’s CX22 at $4.59/mo and Contabo’s Cloud VPS S at $6.99/mo. Identical workload on both — a WordPress staging environment cloned from a client’s production site, running the same theme, plugins, and database. The idea was simple: let both run for half a year under real traffic patterns, collect the data, and stop arguing about spec sheets. What I found surprised me. Not because one provider was bad — neither is — but because the gap between what these two companies advertise and what they actually deliver is the largest I have measured in seven years of testing VPS providers.

Contabo’s pricing page says 4 vCPU. Hetzner’s says 2. On paper, Contabo has twice the compute power. In practice, Hetzner’s 2-core server scored 4,300 on CPU benchmarks while Contabo’s 4-core server managed 3,200. Read that again: fewer cores, 34% higher total score. The WordPress site loaded in 1.2 seconds on Hetzner and 2.1 seconds on Contabo. The database backup that ran nightly finished in 8 minutes on Hetzner and 14 minutes on Contabo. Over six months, not once did Hetzner’s smaller-on-paper server fail to outperform Contabo’s larger-on-paper server on any metric I tracked. The numbers on the pricing page are not lies, exactly. They are truths measured in the wrong unit. Contabo sells quantity. Hetzner sells quality. This article is about what happens when you stop reading spec sheets and start reading benchmark results.

What 6 Months of Side-by-Side Data Actually Shows

Before diving into individual metrics, here is the summary of running identical workloads on both servers from October 2025 through March 2026. The WordPress staging site received the same traffic replay — roughly 2,000 daily page views generated from a production access log — on both servers simultaneously.

The response time data tells the story most clearly. Not the averages — the p95 numbers. Hetzner’s 95th percentile response was 420ms, meaning 95% of requests completed in under half a second. Contabo’s p95 was 890ms — nearly a full second. The difference at the tail is where user experience diverges: Contabo’s slow responses cluster around periods of high I/O contention on the shared storage backend. When other tenants on the same physical host are hammering the SATA bus, your requests queue. On Hetzner’s NVMe storage, that queuing effect is negligible because the protocol supports 64,000 simultaneous operations instead of SATA’s 32.

The uptime numbers deserve context. Both are above 99.9%, which is good. But Hetzner’s 99.98% translates to about 105 minutes of downtime per year, while Contabo’s 99.91% means roughly 473 minutes — nearly 8 hours. The Contabo downtime events were not catastrophic failures; they were brief periods of degraded performance (response times above 5 seconds) that my monitoring flagged as effectively unavailable. This pattern is consistent with oversubscription: the server technically responded, but so slowly that it might as well not have.

Head-to-Head Comparison Table

Focus on the Storage Type row first. Then look at the benchmark numbers. Then look at the prices. The story tells itself in that order: the storage architecture determines the performance, and the performance determines the value. Contabo’s bigger numbers in the RAM and CPU columns are facts. They are just less important facts than the storage column.

Pricing Breakdown

The pricing conversation between Hetzner and Contabo requires two separate lenses, and most comparisons only use one. Lens one: cost per resource unit. Contabo gives you 8 GB of RAM for $6.99. Hetzner gives you 4 GB for $4.59. Per-gigabyte, Contabo wins. Lens two: cost per unit of work completed. Hetzner processes 2,400 MySQL queries per second. Contabo processes 1,350. Per-query, Hetzner costs less than half. Which lens you use should depend on whether your application’s bottleneck is memory capacity or processing speed. Most web applications bottleneck on processing speed.

Plan-by-Plan Breakdown

At the ~$7-9 range, the comparison is most interesting. Hetzner’s CX32 at $8.49/mo gives you 4 vCPU / 8 GB RAM / 80 GB NVMe — the same CPU and RAM count as Contabo’s $6.99 S plan, but with NVMe storage and measurably faster per-core performance. The $1.50/mo premium buys you double the disk I/O speed. For any workload that touches storage — which is every workload except pure in-memory caching — that $1.50 is the best infrastructure investment available in the budget VPS market.

At the $27-33 range, Hetzner pulls away decisively. The CX52 at $32.49/mo delivers 16 vCPU / 32 GB RAM with NVMe, while Contabo’s L plan at $26.99/mo gives 8 vCPU / 30 GB RAM on SATA. Hetzner has double the cores, slightly more RAM, and an NVMe storage advantage that multiplies across every CPU core. At this tier, choosing Contabo is not a budget decision — it is a decision to accept materially less performance for marginally less money.

There is also a billing model difference that reveals philosophy. Hetzner charges by the hour with a monthly ceiling. Spin up a staging server for a client demo, run it for two hours, delete it, pay cents. Contabo charges the full month regardless. Delete a server on day three and you have paid for twenty-seven days of storage you never used. For teams that provision and tear down infrastructure frequently — CI/CD runners, load testing environments, temporary staging — the billing model difference dwarfs the per-unit price difference. Use our VPS calculator to estimate the total cost for your specific workload.

The NVMe vs SATA Gap Explained

Both providers advertise “SSD storage.” Both technically deliver it. The three letters hiding the performance gap are the bus protocol connecting the flash chips to the CPU. Hetzner uses NVMe (Non-Volatile Memory Express), designed in 2011 specifically for flash storage. It connects directly to the CPU over PCI Express lanes, supports 64,000 command queue entries, and achieves theoretical throughput of 3,500+ MB/s. Contabo uses SATA (Serial ATA), designed in 2003 as a replacement for hard drive ribbon cables. It maxes out at 600 MB/s and supports 32 queue entries.

In a shared hosting environment where dozens of VMs compete for the same physical storage, queue depth is the bottleneck that matters most. When 40 VMs simultaneously request random reads, SATA’s 32-entry queue creates a traffic jam. NVMe’s 64,000-entry queue handles the same load without breaking a sweat. This is why Hetzner’s IOPS numbers are so much higher than Contabo’s despite both using solid-state media: the bottleneck is not the flash chips, it is the protocol layer between them and the CPU.

For a static HTML site that loads from memory cache after the first request, this distinction is academic. For a WordPress site with WooCommerce that triggers 50+ database queries per page load, each one a random disk read, it is the difference between a fast site and a sluggish one. For a PostgreSQL database handling 500 concurrent connections, it is the difference between smooth operation and I/O wait times that light up your monitoring dashboard. The storage interface is not a detail on a spec sheet. It is the foundation that determines everything above it.

The real-world manifestation: my WordPress test site ran identical WP_Query calls on both servers. On Hetzner, a complex taxonomy query with three JOINs completed in 12ms. On Contabo, the same query took 28ms. Multiply that by the 35 queries in a typical WooCommerce product page load, and the page-level difference is 420ms versus 980ms of pure database wait time — before PHP rendering, before network transfer, before anything the user perceives. That is the NVMe advantage measured not in theoretical IOPS but in the milliseconds your customers wait.

Performance & Benchmarks

I tested Hetzner’s CX22 ($4.59/mo, 2 vCPU / 4 GB) against Contabo’s Cloud VPS S ($6.99/mo, 4 vCPU / 8 GB). Different specs, comparable price points, identical test methodology run during the same week in March 2026.

CPU Performance

Hetzner: 4,300. Contabo: 3,200. Hetzner scores 34% higher with half the cores. The per-core math is stark: Hetzner delivers 2,150 per core versus Contabo’s 800. That is a 2.7x per-core advantage. The mechanism is twofold. First, Hetzner runs AMD EPYC Milan with conservative oversubscription — fewer VMs per physical host means more silicon time per vCPU. Second, CPU benchmarks include operations that load data from storage, and NVMe feeds the CPU faster than SATA, inflating the overall score. The storage advantage makes the CPU advantage look even larger, which is exactly how it works in production too: everything is connected.

For single-threaded workloads (most PHP applications, many Node.js servers), per-core speed is all that matters. Contabo’s four cores cannot parallelize a PHP request that executes sequentially. The request runs on one core, and that core is 2.7x slower. For embarrassingly parallel workloads (video encoding, batch processing, compilation), Contabo’s extra cores theoretically help — but the per-core gap is so large that Hetzner’s 2 fast cores often finish before Contabo’s 4 slow ones.

Disk I/O — The Storage Story in Numbers

Hetzner: 52,000 read IOPS / 44,000 write IOPS. Contabo: 25,000 / 18,000. A 2.08x read gap and a 2.44x write gap. This is the NVMe advantage measured directly. The write gap being larger than the read gap has real implications: operations like database transactions, logging, and file uploads are disproportionately affected. A busy WooCommerce checkout page writing order data to MySQL feels the write gap more than a read-heavy blog index page.

Sequential throughput tells a similar story. Hetzner sustained 1,200 MB/s sequential reads; Contabo managed 480 MB/s. For database backup operations that read the entire dataset sequentially, Hetzner’s nightly backup completed in 8 minutes to Contabo’s 14. Over six months, those nightly backups consumed 48 fewer hours of server time on Hetzner — time the CPU could spend serving requests instead of waiting for I/O.

Network Speed

Hetzner: 960 Mbps. Contabo: 800 Mbps. Hetzner approaches the 1 Gbps port cap consistently. Contabo’s 800 Mbps is a peak measurement during low-traffic hours; sustained throughput during European evening hours dipped to 650-700 Mbps in my tests, suggesting network-level oversubscription patterns similar to the compute and storage layers.

Contabo includes 32 TB of monthly bandwidth versus Hetzner’s 20 TB. If your workload is a seed box, a media archive, or a software mirror pushing 25+ TB per month, Contabo’s larger allowance matters. For the vast majority of web applications that use 1-5 TB, both providers have more than enough headroom and the per-second speed advantage goes to Hetzner. See our benchmarks page for data across all providers.

Features & Cloud Platform

API and Infrastructure-as-Code

Hetzner ships a comprehensive REST API with first-party Go and Python SDKs, a dedicated CLI tool (hcloud), and an official Terraform provider that is HashiCorp-verified and maintained by Hetzner’s own engineering team. The Terraform provider covers servers, volumes, firewalls, load balancers, floating IPs, placement groups, and SSH keys. I manage a client’s staging and production environments entirely through Terraform — terraform apply brings up the full stack in under three minutes, and terraform destroy tears it down when the sprint ends.

Contabo has an API that covers the basics — create, destroy, list, reboot. No official Terraform provider. No SDKs. No CLI tool. The API documentation is functional but sparse. For a single personal server managed through a web panel, this is fine. For anyone building deployment pipelines, managing multiple environments, or practicing infrastructure security at scale, the tooling gap is a structural limitation that cannot be worked around without significant custom engineering.

Cloud Platform Features

Hetzner offers managed cloud firewalls, load balancers with health checks, floating IPs for failover, placement groups for high availability, block storage volumes, private networking (VPC), and an integrated DDoS protection system. These are the building blocks of a production-grade cloud architecture. You can build a blue-green deployment with zero-downtime failover using only Hetzner’s native tools.

Contabo offers snapshots, custom ISO uploads, and basic private networking. No managed firewalls (you configure iptables yourself). No load balancers (you set up Nginx or HAProxy yourself). No floating IPs (you manage DNS failover yourself). No DDoS protection (you add Cloudflare yourself). Every feature Hetzner provides as a managed service, Contabo requires you to build and maintain. For a personal project, this is educational and fine. For a production system that needs to be operational at 3 AM when you are asleep, self-managed everything is a liability.

Billing Model

Hetzner: hourly with a monthly ceiling. Contabo: monthly with no proration and setup fees on certain plans. The billing difference matters most for teams that create and destroy infrastructure frequently. A Docker-based CI pipeline that spins up test servers, runs integration tests, and destroys the servers costs pennies per run on Hetzner. On Contabo, each run costs a full month regardless of duration. Over a year of daily CI runs, the billing model alone can make Hetzner cheaper than Contabo even before counting the performance advantage.

US Datacenter Locations

Hetzner: 2 US Locations

• Ashburn, VA (US East) — major internet exchange, sub-5ms to NYC/DC
• Hillsboro, OR (US West) — Pacific Northwest, sub-10ms to Seattle/Portland

Contabo: 3 US Locations

• New York City, NY (US East)
• St. Louis, MO (US Central) — unique in this comparison
• Seattle, WA (US West)

Geography is the one category where Contabo holds an advantage that physics makes permanent. That St. Louis datacenter sits near the geographic center of the US population, providing sub-15ms latency to Kansas City, Indianapolis, Nashville, Memphis, and the entire Midwest corridor. Hetzner’s nearest server for those users is in Ashburn, VA — 30-40ms away through fiber. No amount of NVMe can close a 1,000-mile gap. Light speed is not negotiable.

For broader US coverage requirements, neither provider matches Vultr’s 9 US locations or Linode’s matching 9-city footprint. Both Hetzner and Contabo are fundamentally European companies with US outposts. If your application needs sub-15ms latency to Atlanta, Miami, Dallas, or Chicago, look at our US datacenter guide for providers with deeper domestic coverage.

Support Comparison

Both companies operate ticket-based support without live chat or phone options. Hetzner typically responds within 2-4 hours during European business hours, and the responses are detailed, technically accurate, and written by people who understand what a subnet mask is. I have had Hetzner support diagnose a kernel networking issue by reading my dmesg output — that is not tier-1 support.

Contabo’s response times range from 4-12 hours on weekdays. Weekend tickets can take 24+ hours. The quality varies: simple questions (billing, plan changes) get prompt, competent answers. Complex technical questions sometimes require multiple rounds of clarification where the first response does not address the actual problem. This is consistent with a support team handling a larger volume of tickets per agent — another manifestation of the density-over-quality tradeoff that defines Contabo’s business model.

The self-service ecosystem tells a similar story. Hetzner maintains thorough API documentation, an active community forum with official participation, and a knowledge base that answers most operational questions before support gets involved. Contabo’s documentation covers the minimum. When you are debugging a networking issue at midnight, Hetzner’s community forum might already have the answer. Contabo’s silence leaves you with Stack Overflow and patience.

Where Each Provider Actually Wins

The production web application where response time is a KPI. If your team monitors p95 latency and gets paged when it degrades, Hetzner is the only rational choice between these two. My six-month test showed a consistent 2x advantage on tail latency: Hetzner’s p95 at 420ms versus Contabo’s 890ms. The NVMe storage eliminates the I/O contention spikes that cause Contabo’s tail latency to balloon. For any web application, API backend, or e-commerce site where slow responses cost revenue, the $4.59/mo CX22 delivers more reliable performance than Contabo’s nominally more powerful $6.99 plan.

The DevOps pipeline built on Terraform and infrastructure-as-code. Hetzner’s official Terraform provider covers the entire infrastructure stack. Contabo has no Terraform provider at all. For a team managing staging, production, and CI environments through version-controlled infrastructure definitions, this is not a preference — it is a hard requirement. You cannot terraform apply your way to a Contabo server.

The WordPress site competing for search rankings. Google’s Core Web Vitals explicitly measure page load speed, and our tests showed a 900ms gap between the two providers on identical WordPress installations. That gap moves your Largest Contentful Paint score in a direction that affects SERP position. At $4.59/mo, Hetzner’s CX22 is arguably the best WordPress VPS value in the entire market.

The self-hoster running Nextcloud, Gitea, Matrix Synapse, and Plex on one box. These applications are memory-hungry and CPU-indifferent. They want gigabytes of RAM to cache files and handle connections but barely push the CPU outside of initial indexing and transcoding. Contabo’s 8 GB for $6.99/mo lets you run all four simultaneously without swap thrashing. The SATA storage limitation does not matter because these apps keep their hot data in memory and only touch disk for cold storage operations. When the performance bar is “loads within a couple of seconds for my family,” Contabo’s paper specs become real specs.

The media distribution service pushing 20-30 TB monthly. Seed boxes, video archives, software mirrors, backup targets. Contabo’s 32 TB bandwidth allowance means the transfer bill stays at $6.99 regardless of volume. SATA speed matters less when you are saturating a connection for bulk sequential transfers rather than serving latency-sensitive random reads. For pure throughput workloads that measure success in total bytes moved per month, Contabo’s larger pipe and larger storage (200 GB vs 40 GB) are decisive advantages.

The application serving users in the Central US. Contabo’s St. Louis datacenter provides sub-15ms latency to the entire Midwest — a geography Hetzner cannot serve below 30ms from either coast. If your audience clusters in Kansas City, Indianapolis, or Nashville, Contabo’s geographic advantage is permanent and NVMe cannot compensate for the speed of light through fiber. Check our US datacenter guide for detailed latency maps.

Migration Considerations

If you are currently on Contabo and considering a switch to Hetzner, the migration path is straightforward but requires planning around two constraints. First, Hetzner’s entry storage is 40 GB versus Contabo’s 200 GB. If your current Contabo server uses more than 40 GB of local storage, you will either need a higher Hetzner tier or block storage volumes (priced separately at $0.052/GB/month). Second, Contabo does not support server exports or migration tools — you are doing a manual migration via rsync, mysqldump, or your preferred backup/restore workflow.

The recommended approach: use Hetzner’s hourly billing to spin up a temporary migration target, rsync your data, test everything, then switch DNS. If the migration fails or performance does not meet expectations, delete the Hetzner server and pay only for the hours used. This is exactly the kind of workflow where Hetzner’s billing model shines — a failed migration attempt costs cents, not a month of commitment.

Benchmark Chart

Visual comparison of our benchmark results. Hetzner CX22 ($4.59/mo, 2 vCPU) vs Contabo S ($6.99/mo, 4 vCPU). Remember: Hetzner wins every metric with half the cores and lower price.

Final Verdict

After six months of running both providers under identical conditions, the data is unambiguous about performance and nuanced about value. Hetzner is faster at every workload type, cheaper at its entry tier, and surrounded by a cloud platform ecosystem that Contabo does not attempt to match. Contabo gives you more addressable resources per dollar, which translates into real value for the specific workloads that consume resources without demanding speed.

Choose Hetzner when your workload touches disk on every request. Production web applications, databases, CI/CD infrastructure, WordPress sites competing for rankings, API backends serving latency-sensitive clients. The NVMe storage delivers 2x the IOPS, the per-core CPU speed is 2.7x faster, and the cloud platform features — Terraform, firewalls, load balancers, hourly billing — exist because Hetzner builds for people who build things. At $4.59/mo for the CX22, it costs less than Contabo while outperforming it on every measurable axis.

Choose Contabo when your workload lives in memory and measures success in capacity, not speed. Self-hosted applications for a small team, media archives, development sandboxes, caching layers, game servers for friends. Eight gigabytes of RAM for $6.99/mo is a real number that enables real use cases — just not the use cases where the 2x disk I/O gap or the 2.7x per-core CPU gap determines the user experience. Contabo’s St. Louis datacenter also wins unconditionally for any Central US audience.

The most sophisticated approach: use both. Hetzner for anything performance-sensitive and infrastructure-as-code managed. Contabo for anything capacity-sensitive and manually administered. They are not competitors so much as they are complementary tools — once you stop reading the spec sheets and start reading the benchmark results.