StackRates

Disclosure: we may earn a commission or referral reward from CloudCone, Contabo, DigitalOcean (account credit, not cash), Hostwinds, InterServer, RackNerd, VPSDime and Vultr if you sign up through our links. It does not change the price you pay. Every other provider pays us nothing. Prices in this guide are as of the date shown and may have changed; see the comparison pages for the latest checked prices.

Guides · FOR

Best hosting for a Rust web service in 2026: the honest picks

Some prices quoted in this guide are out of date. It is being rebuilt on our price index; for current prices use the comparison pages, which show when each price was checked.

Rust web services (Axum, Actix, Rocket, Warp) have a specific advantage as a hosting workload: they use dramatically less RAM and CPU than equivalent Node, Python or Ruby apps. A Rust service handling 10,000 requests per second comfortably fits on a $4.60 Hetzner CX22 — the same box a WordPress site would need with far less headroom.

Prices as of 2026-09-22.

What Rust actually needs

  • RAM: 512 MB - 2 GB for most services. Rust binaries are small; the compiled service itself uses ~10-50 MB baseline. Most memory usage comes from your data structures, not the framework.
  • vCPU: 1-2 for small services, 2-4 for high-throughput. Rust's async runtime scales well across cores.
  • NVMe storage. Only matters for logs and any local state.
  • Fast network for external service calls.
  • Latest Rust toolchain for optimal compile output.

Recommended picks

Small production Rust service ($5-8/mo)

Hetzner CX22 at $4.60/mo — 2 vCPU, 4 GB RAM. Overkill for most Rust services in a good way. Cross-compile locally or build on the box (Rust compilation is CPU-hungry but only during builds).

Alternative: Vultr Regular 1 GB at $5/mo if you need Vultr's specific regions.

Real production Rust service with Postgres ($10-20/mo)

Hetzner CX32 at $7.60/mo — 4 vCPU, 8 GB. Run your Rust service, Postgres, and Redis all on the same box. Rust's efficiency lets you consolidate services that would need multiple boxes on Node or Python.

CPU-bound Rust workload (heavy compute) ($15-30/mo)

Hetzner CPX31 at $15.60/mo — 4 AMD vCPU, 8 GB. AMD's single-thread performance is a real win for CPU-bound Rust workloads.

Or Vultr High Frequency for 3.7+ GHz single-thread — Rust benchmarks generally show meaningful gains.

Deploying Rust: the systemd + reverse proxy pattern

Rust services deploy as a single statically-linked binary. Trivial to run under systemd:

/etc/systemd/system/myservice.service:

```

[Unit]

Description=My Rust web service

After=network.target

[Service]

Type=simple

User=deploy

WorkingDirectory=/opt/myservice

Environment=RUST_LOG=info

Environment=DATABASE_URL=postgres://...

ExecStart=/opt/myservice/myservice

Restart=always

[Install]

WantedBy=multi-user.target

```

systemctl enable --now myservice.

Nginx reverse proxy:

```nginx

server {

server_name api.yourdomain.com;

location / {

proxy_pass http://localhost:3000;

proxy_http_version 1.1;

proxy_set_header Host $host;

proxy_set_header X-Real-IP $remote_addr;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

}

}

```

certbot --nginx -d api.yourdomain.com for SSL.

Building Rust on cheap VPS

Building Rust from source is CPU-hungry. On a small VPS (2 GB or less), the compiler can OOM.

Options:

  • Cross-compile locally and scp the binary to the VPS. Cleanest.
  • Use cargo build --release --jobs 1 on the VPS to limit parallelism.
  • Add swap space to the VPS if it's under 4 GB.

For CI: build on a bigger box (GitHub Actions runner, or a dedicated Hetzner CX32) and deploy the binary.

Rust deployment patterns

Static binary + systemd. Simplest. Everything Rust needs.

Docker container. If you use Docker elsewhere in your stack, Rust builds cleanly into a scratch or distroless image.

Kubernetes. Overkill for a single service. Legitimate at multi-service scale.

Fly.io Machines. Excellent Rust support. See Fly.io vs VPS.

Cloudflare Workers. Rust compiles to WebAssembly and runs on Workers. Different model; different economics. Not really "hosting a Rust web service" in the traditional sense.

When Rust is genuinely cheap to host

  • Small binary. Small RAM footprint. Small CPU baseline.
  • You can put more services on one box than you could with Node or Python.
  • You don't need a runtime, garbage collector, or interpreter.
  • Binary is static; no dependency hell on the deployment box.

Real efficiency numbers vs Node/Python for the same workload:

  • RAM: 3-8x less.
  • CPU: 2-5x less.
  • Cold start: near-zero (single binary, no runtime warmup).

Which one you should actually pick

  • Prototype / small production Rust service → Hetzner CX22 at $4.60/mo.
  • Real production with Postgres on the same box → Hetzner CX32 at $7.60/mo.
  • CPU-heavy Rust workload → Hetzner CPX31 at $15.60/mo or Vultr HF.
  • Deploy-from-git DX preferred → Fly.io Machines.
  • Serverless model → Cloudflare Workers for WebAssembly Rust.

Related guides

Prices as of 2026-09-22.