Netcup's €8.74 Box vs Hetzner's €42.99 CCX: What a Second EU Provider Actually Costs Your Fleet

Hetzner's CCX13 — two dedicated vCPUs, 8 GB RAM, 80 GB disk — cost €15.99 in March. In July it costs €42.99. Nothing changed about the hardware. The invoice did.

On June 15, 2026, Hetzner applied the third price hike of the year to its Cloud catalog. This time the lines that matter most for production fleets moved the most: dedicated-vCPU CCX jumped 113% to 175%, on top of an April hike that had already added 30% to 37% across the board.

The result is a catalog that no longer has one "Hetzner price." It has two tiers pretending to be one brand. And at that moment, a provider this list has never treated as a fleet default — Netcup — started looking like the cheaper line on the spreadsheet: an RS 1000 G12 root server with four dedicated AMD EPYC 9645 cores, 8 GB DDR5 ECC, 256 GB NVMe and a 2.5 Gbps port for €8.74 a month.

Here is the number you came for, before the why, so you can find your own row.

The answer up front: one node, four bills​

All Hetzner prices are Germany/Finland, excl. VAT and excl. IPv4, monthly cap from the hourly rate as published at docs.hetzner.com/general/infrastructure-and-availability/price-adjustment. Netcup RS 1000 G12 is the 12-month term price (incl. VAT handling varies by customer location; we note the nuance below). Disk and cores are the contract — not a burst allowance.

One extra contract difference that does not fit in a table: Hetzner bills hours capped to the monthly ceiling and gives you a real Cloud API with server_types, floating IPs and load balancers. Netcup's RS line is a KVM root server — dedicated cores with hardware RAID backing, not a Cloud VM life-cycled through a declarative API — sold on a fixed monthly term with snapshots and an SCP console.

Fleet math for the shape Bex actually runs — a three-node HA pool that survives one node loss, and a 10-node worker pool that carries a real app and its Postgres:

Two things to read off this before you read the history:

1. Per dedicated core, Hetzner CCX is now roughly 10× Netcup RS. That is not a rounding error. It is what happens when one provider moves a line 169% and the other does not move at all.
2. If you are willing to run shared cores, Hetzner is still cheaper than Netcup dedicated. CX32 at €6.80 beats RS 1000 G12 at €8.74. The story is not "Netcup beats Hetzner." It is "Netcup dedicated beats Hetzner dedicated, and the fleet default you picked last year determines which sentence matters."

The rest of this post shows which hike flipped the ranking, what RS 1000 G12 actually buys, and why — despite that table — Netcup remains a cost-comparison footnote rather than a drop-in MachineDeployment target today.

The three 2026 hikes that flipped the ranking​

This list has followed Hetzner's repricing in real time because Bex's default node pool is a CAPH-provisioned Hetzner fleet. Every example's monthly number depends on which generation and family string is in the HetznerMachineTemplate. Before June, none of the examples needed an asterisk. After June, all of them do.

Hetzner's 2026 catalog did not move once. It moved three times, with the dedicated lines hit hardest at the end.

The June table is the one that rewrote the value ranking. Hetzner's own Germany/Finland price-adjustment page gives old vs new monthly caps (ex-VAT, ex-IPv4):

Sources: Hetzner price-adjustment notice (docs.hetzner.com/general/infrastructure-and-availability/price-adjustment), PrivateDevOps June 15 recomputation, byteiota price-shock table, Hetzner press room statements for April 1 and April 29, vpsmaxxing curated price history. Hourly and monthly caps align; region is EU where published.

"Roughly tripling" is not rhetoric. CCX13 went from €15.99 to €42.99 — 2.69× in one step, after April had already lifted it from roughly €12 to €16. Against March pricing the line is past 200%.

Netcup, in the same window, did not move the RS 1000 G12. Its €8.74 monthly figure is the 12-month term price, stable since the G12 generation launched on the AMD EPYC 9645 platform. VPSBenchmarks' July 2026 "€14.87" spot reflects a different bookkeeping basis — incl. VAT without the long-term term, or a rolling-month snapshot — not a price increase. We unpack that nuance next so the table is not comparing a promo to a list price without saying so.

What RS 1000 G12 actually is​

Netcup's RS line and Hetzner's Cloud line are not the same product category, and the price gap only makes sense once you see the contract you are buying.

RS is a root server, not a Cloud VM. Netcup sells the RS 1000 G12 as a KVM root server with four guaranteed dedicated cores from an AMD EPYC 9645, 8 GB DDR5 ECC RAM, 256 GB NVMe (hardware RAID), a 2.5 Gbps port with flat traffic, snapshots, and a browser-based SCP console and rescue system. You buy a monthly term — 1 month or 12 months, with the €8.74 figure tied to the 12-month term — and you get a single-tenant machine where the cores are yours rather than a shared vCPU with a fair-use expectation. Hetzner Cloud's CCX13 is a Cloud VM with two dedicated vCPUs on a shared host that exposes a real infrastructure API: server_types, servers, networks, floating IPs, load balancers, volumes, and placement groups, all addressable from a HetznerMachineTemplate.

The disk delta matters at small scale. RS 1000 G12 ships 256 GB NVMe. CCX13 ships 80 GB. At one node that is 3.2× the disk for one-fifth the price per dedicated core. At ten nodes it is 2.56 TB vs 800 GB. For a Postgres-backed app that keeps WAL and backups on the node, that is not a footnote; it is the reason a single RS node can hold a dataset that would push a minimum CCX fleet into add-on volumes.

Network and traffic are billed differently. Hetzner Cloud famously includes 20 TB per Cloud server in the monthly flat in EU regions (pooled per project), billed hourly and capped monthly. Netcup's RS line advertises a 2.5 Gbps port with flat traffic in its product sheet and a 99.9% minimum availability backed by hardware RAID, with snapshots via SCP. Neither provider meters the small, bursty egress that shocks tenants on Render or Fly.io, but they converge from opposite directions: Hetzner counts terabytes and forgives the first 20, Netcup exposes a raw port and calls traffic flat.

Expect the €8.74 asterisk. The reason VPSBenchmarks shows €14.87 for RS 1000 G12 in July 2026 while Netcup's own listing says €8.74 is not a hidden price hike. Netcup quotes RS monthly prices on two axes — 12-month vs 6-month vs 1-month term, and excl. vs incl. VAT depending on customer country — plus periodic voucher codes that temporarily lower the first 6 to 12 months. The €8.74 figure is the 12-month term anchor this post benchmarks against; the €14.87 spot reflects the 1-month or VAT-inclusive bookkeeping that comparison sites tend to snapshot. If your fleet turns over every month, price the shorter term. If it lives for a year, the €8.74 is the honest number. Either way, Netcup has held the line through the exact quarter where Hetzner moved CCX 169%.

And the benchmark is competent, not magical. VPSBenchmarks' July 2026 sysbench and YABS runs for RS 1000 G12 on the EPYC 9645 show the expected: four full cores that do not steal, DDR5 ECC, and disk I/O in the mid tier — not a record breaker, but consistent and uncorrelated with a neighbor's noisy build. That is the point of a dedicated-core comparison in the first place.

Fleet math at Bex scale​

Bex's starter fleet is not one box. It is a small HA pool that Cluster API can reconcile — control plane spread, MachineDeployments with rolling updates, and an autoscaler that actually has capacity to scale into. Pricing one box tells you the unit cost. Pricing the fleet tells you whether sweeping a server_type string is a cleanup or a budget event.

We keep the workload intentionally fixed: the same containers, the same three to ten nodes — only the server_type and the provider change.

Three-node HA, the smallest fleet you should run in production:

Ten-node worker pool, where the yearly delta funds another fleet:

Read that last row carefully. Netcup RS is 4× cheaper than Hetzner CCX at fleet scale and still more expensive than Hetzner's shared CX32. The win is not "Netcup beats Hetzner." The win is narrow and conditional: if your workload genuinely needs dedicated cores — steady CPU, no noisy neighbor, Postgres on the same host — Netcup dedicated is the cheapest dedicated line in the EU right now. If shared cores are fine, Hetzner CX still wins and the "alternative provider" story is moot.

Where the delta actually matters: ten CCX13 nodes at €5,159 a year versus ten RS 1000 G12 nodes at €1,049 a year is €4,110 a year you are not spending to keep noisy-neighbor isolation. That margin pays for a second three-node dev fleet, a managed Postgres you deliberately keep off-cluster (Neon, Supabase, RDS — Bex's deliberate non-goal is not bundling the database), or simply the next Hetzner hike.

Sensitivity to check before you quote the headline: add €1 to €1.20 per month per IPv4 if you need one (both providers charge for it), add VAT at your local rate to Hetzner's excl.-VAT monthly (Netcup's checkout computes it by customer country and term), and remember that Hetzner Cloud's 20 TB included traffic is forgiving for request-heavy workloads while Netcup's flat 2.5 Gbps port is forgiving for sustained throughput workloads. Neither moves the ranking at the scale above, but both belong in a procurement sheet.

Why Netcup is still a footnote, not a CAPH drop-in​

If the table were the whole story, Bex's default HetznerMachineTemplate would already say rs-1000-g12. It does not, and the honest reasons why are more interesting than the price.

There is no Cluster API provider for Netcup. CAPH — syself/cluster-api-provider-hetzner — speaks two Hetzner control planes: the Hetzner Cloud API (for Cloud VMs and their networks, firewalls, load balancers) and the Robot API (for bare-metal HetznerBareMetalHost).

A MachineDeployment that rolls out ten nodes is a declarative reconciliation loop. The controller creates a HCloudMachine or HetznerBareMetalHost, watches it become ready, joins it to the cluster, and replaces it on failure.

Netcup has an SCP web service API and a SOAP/WSDL flavor for automating RS orders, panel actions and DNS — enough for a single-box self-hoster like Coolify or Dokploy to call if it wanted to. But it is not the Hetzner Cloud API. It does not speak server_types, placement groups or load balancers, and no community project implements the infrastructure.cluster.x-k8s.io contract for it. Adding Netcup as a fleet target is not "add a new machine type." It is "write a new infrastructure provider."

The API gap is not just naming. Hetzner's Cloud API is the reason CAPH can do declarative machine lifecycle at all. Create a server of a named type in a named location, attach it to a placement group, fetch a typed price table from api.hetzner.cloud/v1/server_types, and delete it with an idempotent call.

Netcup's API surfaces a different domain: product orders, contract terms, SCP panel tasks, vServers and web-hosting packages. Provisioning timelines are hours for RS, not seconds for Cloud VMs. That is not a value judgment — Netcup's RS line is a better dedicated-core deal precisely because it sells a heavier, cheaper term product. But it is a contract mismatch with what CAPH's controllers expect to drive.

Regions and footprint are narrower. Hetzner Cloud runs production regions in Falkenstein, Nuremberg, Helsinki and Ashburn plus the Robot bare-metal fabric underneath. CAPH workload templates pin location and networkZone so a fleet can keep control plane in FSN and workers in NBG without crossing an ocean.

Netcup's footprint is primarily Germany — Nuremberg and nearby EU fabric, plus a small US expansion — with fewer location knobs to declare in a spec. For a single-tenant app that lives on one continent, that is fine. For a platform that promises MachineDeployment failover across Hetzner's eu-central and us-east design surface, it is a constraint the fleet would have to paper over with a second provider rather than a second region on the same API.

Provisioning UX and machine lifecycle do not match. A Hetzner Cloud VM appears in seconds, is addressable in the API immediately, and can be replaced by Cluster API's machine health checks without human interaction. A Netcup RS order — even automated through the web service API — provisions a KVM root server with a term commitment and an SCP lifecycle: boot, rescue, snapshot, reverse DNS and reinstall are panel or API operations on a slower cadence. Bex's fleet assumes machines are cattle. Netcup's RS line treats them, by economics, more like pets with better cores.

Community and docs gravity. CAPH has a release cadence (v1.0.0-beta.17 through v1.1.0 in 2026), a shipped set of HetznerCluster/HCloudMachine/HetznerBareMetalHost CRDs, and a book of example ClusterClass templates that upstream tooling and clusterctl know how to emit. A Netcup provider would need to replicate that surface — CRDs, controllers, webhooks, image builder, docs, CI against a real API — before any Bex installation could point its default pool there. That is months of provider engineering, not a flag flip.

None of this says Netcup is a bad deal. It says the cheapest dedicated line is not the same thing as the cheapest fleet primitive. If CAPH does not speak it, Bex cannot reconcile it.

When Netcup actually makes sense anyway​

There are workloads where "no CAPH provider" is not a dealbreaker because there is no fleet to reconcile.

On the shortlist:

• A single long-lived box that runs one Postgres-backed app
• A staging or preview replica that mirrors prod without its own autoscaler
• A dev bastion or CI runner that wants four real cores and 256 GB local NVMe without paying for Hetzner's Cloud API overhead
• A cost-isolated experiment for a tenant who asked explicitly for dedicated cores on a tight budget

For any of those shapes, order one RS 1000 G12 on the 12-month term, wire Cert-Manager and a single ingress, and you have paid €8.74 for what Hetzner prices at €42.99 on its comparable dedicated contract — with more disk. No Cluster API, no MachineDeployment, no provider to write; Coolify, Dokploy or plain systemd qualify.

Off the list: any fleet where machines come and go. If you need Cluster API's autoscaler to add a fourth worker on a spike, a declarative HetznerMachineTemplate that upgrades the node image by moving a field rather than reimaging through SCP, two Hetzner locations behind one API call, or a managed load balancer that attaches to servers by label, Hetzner Cloud's CX32 at €6.80 a node is the cost-effective answer today — not Netcup, even though Netcup's dedicated math looks cheaper one row up. The fleet wants an API. Netcup sells a host.

There is a middle path that real teams take without waiting for a new provider: run Hetzner Cloud as the Cluster API fleet and attach one or two standalone RS 1000 G12 boxes outside it for the dedicated-core slice that actually earns its isolation — CI, a heavy background worker, or a dataset cache. That is not "a Netcup fleet." It is a Hetzner fleet with a Netcup sidecar, and it avoids pretending the two control planes are one object.

What to watch before changing any default​

A price gap that depends on one vendor holding steady while the other moved is not a permanent arbitrage. It is a point in time that needs a short monitoring list before it becomes a policy.

First, does Netcup hold? The RS G12 generation has held its €8.74 monthly since launch through two Hetzner Cloud hikes and one bare-metal setup-fee hike. If Netcup follows the same DRAM-driven procurement squeeze next quarter, the bottom row of the table moves and the "Netcup 10× cheaper per dedicated core" headline reverts to the pre-April 2× narrative.

Second, does a community provider appear? The moment someone ships a Netcup infrastructure provider that implements the cluster.x-k8s.io contracts and passes CAPH-style conformance, the footnote becomes a real knob in ClusterClass. Until that repo has releases, this post is the right file to quote when someone asks why Bex's default is still Hetzner.

Third, does Hetzner split the catalog again? The June 15 pattern — mild hike for CX/CAX, outsized hike for CPX/CCX — is exactly the move you make to push shared-core utilization while rationing dedicated capacity that the DRAM market makes expensive. If the next adjustment is a fourth hike that widens that split, CX32's €6.80 may be the only stable Bex default left regardless of what Netcup does.

For now, the fleet default stays what Bex documents: a Hetzner Cloud pool (CX32 or CAX11 for shared, CCX only where isolation earns its price) provisioned through CAPH MachineDeployments, with traffic, volumes and load balancers declared in the same spec. Netcup's RS 1000 G12 is the number to keep on the comparison sheet to keep that default honest — not the server_type to put in the template.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with a Render-compatible API and an MCP server any agent can already call. The default fleet reconciles through Cluster API on Hetzner; when the right default changes, a MachineDeployment edit — not a migration — is the point.

Sources

• Hetzner price-adjustment notice, June 15, 2026 and April 1, 2026 (docs.hetzner.com/general/infrastructure-and-availability/price-adjustment; old vs new hourly/monthly tables, Germany/Finland and US regions).
• Hetzner press room statements: April 1 price adjustment and April 29 dedicated-setup-fee adjustment (hetzner.com/pressroom).
• PrivateDevOps, "Hetzner More Than Doubled Some Cloud Prices Today And What To Do About It," June 15, 2026.
• byteiota.com, "Hetzner June 2026 Price Shock: CCX and CPX Are Different Now," June 2026.
• vpsmaxxing (kuberwastaken) curated price history, Hetzner June 15 +110–175% CPX/CCX table.
• VPSBenchmarks, netcup RS 1000 G12 sysbench/YABS runs, July 2026.
• Netcup product pages and checkout, RS 1000 G12 spec sheet (4× EPYC 9645, 8 GB DDR5 ECC, 256 GB NVMe, 2.5 Gbps) and G12 voucher/term pricing.
• Syself, cluster-api-provider-hetzner docs and releases (CAPH v1.0.0-beta.17 through v1.1.0, HCloudMachine/HetznerBareMetalHost CRDs).