# Hetscale

> Add autoscaling and self-healing to the Hetzner servers you already run. No Kubernetes, no migration; your traffic never touches us.

Generated 2026-10-21 from https://hetscale.com

## Product

- [AWS-style Auto Scaling Groups for Hetzner Cloud](https://hetscale.com/): Add autoscaling and self-healing to the Hetzner servers you already run. No Kubernetes, no migration; your traffic never touches us.
- [How Hetscale works](https://hetscale.com/product): How Hetscale adds a Hetzner node when load rises and replaces one when it dies: the loop step by step, with the rule that keeps each step safe.
- [Hetzner autoscaling for servers you already run](https://hetscale.com/autoscaling-for-hetzner): Hetzner Cloud has no built-in autoscaling. Hetscale adds servers when load rises and replaces dead ones behind your load balancer. No Kubernetes, no migration.
- [Coolify autoscaling on Hetzner](https://hetscale.com/coolify-autoscaling): Coolify deploys but does not decide how many servers to run. Hetscale copies the server Coolify deploys to when load rises; the load balancer opens traffic.
- [Pricing: Starter, Growth, Pro, Team](https://hetscale.com/pricing): Plans priced on the nodes Hetscale runs for you, from €5/month, ex-VAT. No per-server fee, no meter. Self-healing, cost guard and drain in every plan.
- [Security: tokens, ownership guard](https://hetscale.com/security): What Hetscale can reach, writes and stores, what it never touches, how the control loop is tested, and how to report a vulnerability.
- [Observe: the read-only 14-day trial](https://hetscale.com/observe): Connect a read-only Hetzner token. Hetscale reads 30 days of history, writes a ranged report, then records for 14 days what it would have done.
- [Cost and capacity calculator](https://hetscale.com/calculator): Estimate what a fixed Hetzner fleet costs against one that follows your load. Ranged results from dated Hetzner list prices; assumptions shown.
- [Onboarding cases and fit](https://hetscale.com/cases): Twelve starting points on Hetzner, from Docker Compose on one server to Coolify and CI deploys: prerequisite work, time to set up and fit.
- [Documentation](https://hetscale.com/docs): Documentation for Hetscale, autoscaling and self-healing on Hetzner Cloud: quickstart, concepts, task guides, adapters, operation, troubleshooting and the API.
- [Hetscale compared with the alternatives](https://hetscale.com/compare): Hetscale next to the other ways to autoscale on Hetzner, on the same six rows for every alternative, with when each one is the better choice.
- [Frequently asked questions](https://hetscale.com/faq): How Hetscale decides, what it touches and what it never does: modes, health checks, healing, tokens, what you need to start, who bills you.
- [Articles](https://hetscale.com/blog): Articles on autoscaling and self-healing for Hetzner Cloud: load balancers, health checks, Coolify, Docker Compose and running without Kubernetes.

## Documentation: Start

- [Quickstart](https://hetscale.com/docs/quickstart): From a Hetzner project to a node group in four steps: connect read-only, read the day-0 report, run one Rehearsal, go Live with a floor of two nodes.
- [Concepts](https://hetscale.com/docs/concepts): The words Hetscale uses for autoscaling on Hetzner: node, node group, seed, release, adapter, traffic provider, readiness, drain, ownership labels, the modes.
- [Modes](https://hetscale.com/docs/modes): Observe, Rehearsal, Propose and Live: what each mode may do on your Hetzner servers, how to switch between them, and what every action records.

## Documentation: Guides

- [Connect a project](https://hetscale.com/docs/connect-a-project): Connect a Hetzner project with a Read token: where to create the token, what Hetscale checks before it stores it, and the read that follows.
- [Start observing](https://hetscale.com/docs/start-observing): Start a node group in Observe: answer three questions, pick a load balancer and a seed, then get the day-0 report and 14 days of decisions Hetscale would take.
- [Go Live](https://hetscale.com/docs/go-live): The Go Live page's steps, in order: Live opened, the Read & Write token, delete protection, release v1, SSH keys, stock fallback, Rehearsal, the switch.
- [Replace a project's token](https://hetscale.com/docs/replace-a-token): Put a new token of the same Hetzner project in place of the current one: when to do it, what Hetscale checks, which permission it accepts and what happens.
- [Archive and restore](https://hetscale.com/docs/archive-and-restore): Node groups and projects are archived, never deleted: when a node group can be archived, what archiving stops, what stays readable, and how to restore.
- [Members and invitations](https://hetscale.com/docs/members): Invite people to your organisation, what owners and admins can do, how seats count, what happens when someone leaves, and deleting your data.
- [Leaving Hetscale](https://hetscale.com/docs/leaving-hetscale): Stop Hetscale, cancel the plan, delete your account, then find and remove what it left in your Hetzner project: servers, snapshots, placement groups, labels.
- [Hand your own servers over to the node group](https://hetscale.com/docs/hand-over-servers): Retire the servers you ran before Hetscale one at a time, so servers of the node group take their place and the group can scale below their count.

## Documentation: Deploy

- [Webhook adapter](https://hetscale.com/docs/webhook-adapter): Your pipeline deploys each new node: a signed node.created event, your deploy, a ready report, then the load balancer health check opens traffic.
- [GitHub Actions](https://hetscale.com/docs/github-actions): Deploy to a webhook group from GitHub Actions with the Hetscale Deploy action: the deploy lock, the release, the server list and each new server.
- [Kamal](https://hetscale.com/docs/kamal): Kamal 2 on a webhook group: the host list from the inventory, the deploy lock while Kamal rolls the fleet, and a deploy for each new server.
- [Coolify](https://hetscale.com/docs/coolify): Autoscale an app Coolify deploys: Coolify keeps deploying to one server, Hetscale clones it. What the seed needs, the Sentinel step, a release per deploy.

## Documentation: Operate

- [When Hetscale adds or removes a server](https://hetscale.com/docs/scaling-policy): How Hetscale decides to add or remove a Hetzner server: what it measures, the default thresholds, how many servers a scale-out adds, and what holds a scale-in.
- [How fast is a scale-out](https://hetscale.com/docs/time-to-capacity): Time to Capacity runs from the decision that asks for a server to its first healthy check at your load balancer: its phases, what shortens it, where to see it.
- [Removing a server without dropping requests](https://hetscale.com/docs/scale-in-and-drain): How Hetscale removes a Hetzner server: out of the load balancer first, a drain window for open requests, a clean shutdown, then a delete inside the paid hour.
- [What happens when a server dies](https://hetscale.com/docs/healing): When a Hetzner server stays unhealthy at your load balancer, Hetscale starts a new server beside it from the current release. What happens to the failed one.
- [When your Hetzner server type is sold out](https://hetscale.com/docs/stock-and-fallback): What Hetscale does when Hetzner has no stock of your server type: the other locations of the zone, the fallback modes, capacity deficit and the stock view.
- [Adding servers before a known peak](https://hetscale.com/docs/schedules): A schedule holds a node group at a floor or under a ceiling at the same time every week, so the servers for a known peak are there first. Pro and Team.
- [Releases, rollouts and rolling back](https://hetscale.com/docs/releases): How Hetscale replaces servers on an older release one at a time, what stops it, and how to roll back to an earlier release.
- [Prometheus](https://hetscale.com/docs/prometheus): Scrape every node group’s servers, newest Time to Capacity, state and limits from /v1/metrics in the Prometheus text format, on Pro and Team.
- [Integrations: webhooks, Slack and Discord](https://hetscale.com/docs/integrations): On Pro and Team, send alerts to a Slack or Discord channel, and alerts or every timeline event to your own signed webhook, beside the alert mail.
- [Manage node groups through the API](https://hetscale.com/docs/group-api): Read, export and change node groups with an API token: one JSON document per group, settings changed safely with If-Match, Observe started, the Archive.
- [Monthly summary](https://hetscale.com/docs/monthly-summary): On the first of each month, a mail adds up your node groups’ month: scale-outs, scale-ins, healings, time short of capacity, Time to Capacity and cost.
- [Audit log](https://hetscale.com/docs/audit-log): Every change in your organisation, by its people, their API tokens and Hetscale, sealed into a SHA-256 hash chain: reading it, exporting it, checking it.
- [Policy templates](https://hetscale.com/docs/policy-templates): Save a scaling policy once for your organisation and copy it into node groups on purpose: versions, applying them, and leaving a template. On Team.

## Documentation: Troubleshooting

- [A token is refused](https://hetscale.com/docs/token-refused): The messages the panel shows when it refuses a Hetzner token, in its own words, with what each one means and what to do. Nothing is stored after a refusal.
- [A node group is paused](https://hetscale.com/docs/group-paused): Why a node group is paused, in the words the panel uses, and how to resume it: from its controls, on the billing page, or in the Hetzner Console.
- [Outside Hetscale, quarantined, gone from Hetzner](https://hetscale.com/docs/outside-quarantined-gone): The three counts on the dashboard and a project’s Reconciliation tab: servers Hetscale never touches, quarantined servers, and servers gone from Hetzner.
- [A node group is servers short](https://hetscale.com/docs/servers-short): When a node group is short of capacity, and what else holds a new server: your plan, a euro ceiling, the cost guard, the node cap. What the panel shows.
- [A new server never becomes ready](https://hetscale.com/docs/server-never-ready): Why a new server fails its health check or its Rehearsal, in the words the panel uses: where to look, the usual causes on a copy of the seed, and each fix.

## Documentation: Reference

- [Hetzner limits that shape a node group](https://hetscale.com/docs/hetzner-limits): The Hetzner Cloud limits a node group meets, from API requests and Primary IPs to networks and load balancer targets, and what Hetscale does at each one.
- [Hetzner API errors and what Hetscale does](https://hetscale.com/docs/hetzner-api-answers): What Hetscale does with each Hetzner Cloud API answer, from 5xx and 412 to 423 and 429: retry, fall back, treat as done, wait or stop. A 429 never means gone.

## API reference

- [API reference](https://hetscale.com/docs/api): The Hetscale API from its OpenAPI specification: authentication, the inventory of your Hetzner nodes, lock and release endpoints, callbacks, errors, schemas.
- [OpenAPI specification](https://hetscale.com/openapi.json): The OpenAPI 3.1.0 document of the API, version 0.12.0-draft (draft), that the reference pages are generated from.
- [API: Groups](https://hetscale.com/docs/api/groups): Scaling groups: their documents and settings, the start of Observe, the Archive, the current node inventory, the deploy lock and the rollout of older servers.
- [API: Projects](https://hetscale.com/docs/api/projects): The organisation's Hetzner projects, connected on the panel.
- [API: Nodes](https://hetscale.com/docs/api/nodes): Optional callbacks a deploy pipeline sends about a single node.
- [API: Releases](https://hetscale.com/docs/api/releases): The release pointer every scale-out and healing action boots from.
- [API: Metrics](https://hetscale.com/docs/api/metrics): Every group's state in the Prometheus text format, for a Prometheus server to scrape. Part of the Pro and Team plans.
- [Webhooks](https://hetscale.com/docs/api/webhooks): The signed events Hetscale sends: node.created, node.terminating and group.release_changed to your pipeline; timeline, alert and ping to a webhook integration.

## Articles

- [Replace an unhealthy Hetzner server automatically](https://hetscale.com/blog/replace-unhealthy-hetzner-server-automatically): Go by the load balancer health check, not ping. Wait out reboots, start the replacement beside the failed server, keep the evidence, stop if the new one fails.
- [Hetzner Cloud metrics API: what it gives you and what it does not](https://hetscale.com/blog/hetzner-cloud-metrics-api): The Hetzner Cloud metrics API gives CPU, disk and network per server and four load balancer metrics, 30 days back. No RAM, latency or per-target requests.
- [Capacity planning on Hetzner when your server type is sold out](https://hetscale.com/blog/hetzner-server-type-sold-out-capacity-planning): A sold-out Hetzner type fails with resource_unavailable and cannot be reserved. Keep your pre-June 2026 servers, keep a fallback type and rent only the peak.
- [Write a health endpoint your load balancer can trust](https://hetscale.com/blog/health-check-endpoint-load-balancer): A health endpoint answers one question: can this server take a request now? What to return, what never to check, code for four frameworks, Hetzner settings.
- [AWS Auto Scaling Groups, explained for Hetzner users](https://hetscale.com/blog/aws-auto-scaling-groups-for-hetzner-users): Hetzner Cloud has no auto scaling group. What each part of an AWS ASG does, and what Hetzner has in its place: a snapshot, a load balancer, an API, or nothing.
- [From one Coolify server to automatic scaling on Hetzner](https://hetscale.com/blog/coolify-single-server-to-autoscaling-hetzner): Coolify deploys to several servers but does not decide how many. What has to move off a single Coolify box before the app can scale, and how an autoscaler fits.
- [Put your Docker Compose app behind a Hetzner Load Balancer](https://hetscale.com/blog/docker-compose-behind-hetzner-load-balancer): Create a Hetzner Load Balancer, add a health check, move TLS from the server to the balancer without downtime, point DNS at it. One server today, more later.
- [How to autoscale a web application on Hetzner Cloud without Kubernetes](https://hetscale.com/blog/autoscale-web-application-hetzner-without-kubernetes): Hetzner has no auto scaling group and you do not need Kubernetes to build one. What autoscaling needs on plain servers, the loop by hand, and where it bites.

## Onboarding cases

- [Docker Compose on a single server](https://hetscale.com/cases/docker-compose-single-server): One Hetzner server, one docker-compose.yml, TLS on the box, the database elsewhere. How to get to a node group without rewriting the deploy.
- [One server behind the Cloudflare proxy](https://hetscale.com/cases/behind-cloudflare): Your app sits behind Cloudflare’s proxy with no load balancer. Today: a Hetzner load balancer behind the proxy. Cloudflare Load Balancing is planned.
- [Hetzner load balancer, two or more servers, registry image](https://hetscale.com/cases/hetzner-load-balancer-ready): You already have the shape: a Hetzner load balancer, identical servers behind it, an image you deploy from. Nothing to prepare; connect and read the report.
- [Coolify on a single server, app and database together](https://hetscale.com/cases/coolify-single-server): A single Coolify server that runs the app and its database. What has to move before the app can scale, and how Hetscale copies the app server once it has.
- [Coolify, multi-server ready](https://hetscale.com/cases/coolify-multi-server): Coolify already deploys to several servers behind a load balancer, with state outside. Coolify keeps deploying; Hetscale adds copies of one of them.
- [GitHub Actions or GitLab CI deploys over SSH](https://hetscale.com/cases/github-actions-deploy): Your pipeline deploys over SSH to one to three servers behind a Hetzner load balancer. Teach it to deploy to the IP Hetscale sends, and the rest stays as it is.
- [Stateless API with a managed database, one server](https://hetscale.com/cases/stateless-api-managed-database): An API on one server, its database already managed elsewhere, no load balancer yet. One prerequisite, then a group.
- [Kamal](https://hetscale.com/cases/kamal): Kamal deploys to a host list. Add each new node to it on node.created and deploy; Kamal keeps doing the deploys.
- [Laravel Forge or Ploi](https://hetscale.com/cases/forge-ploi): Forge and Ploi provision and deploy servers on Hetzner. Hetscale serves them via a snapshot of one server behind a load balancer; no native adapter is planned.
- [Two apps on two servers, no load balancer](https://hetscale.com/cases/two-apps-two-servers): Two applications, each on its own server, nothing in front. Each app becomes its own group behind its own Hetzner load balancer.
- [Campaign and e-commerce peaks, load balancer in place](https://hetscale.com/cases/campaign-and-ecommerce-peaks): A shop or a campaign site behind a Hetzner load balancer that knows when its peaks come. Twenty minutes to connect; scheduled scaling from Pro.
- [WordPress, Plesk or cPanel on a single box: not a fit](https://hetscale.com/cases/not-a-fit): One server with the site and its MySQL on the same disk. Hetscale’s preflight declines this outright, and here is why, and what would change it.

## Comparisons

- [Hetscale vs Kubernetes on Hetzner](https://hetscale.com/compare/kubernetes-on-hetzner): Autoscaling on Hetzner with Kubernetes (kube-hetzner, hetzner-k3s, Syself Autopilot) or with Hetscale on the servers you run, on the same six rows.
- [Hetscale vs a do-it-yourself autoscaling script](https://hetscale.com/compare/diy-scripts): Autoscaling Hetzner servers with your own script (the hcloud CLI, cron, a metrics alert) or with Hetscale, on the same six rows, and when each one fits.

## Optional

- [Privacy policy](https://hetscale.com/privacy): What Hetscale does with personal data: no cookies on this site; in the application your account, Hetzner tokens and payments through Paddle.
- [Terms of Service](https://hetscale.com/terms): The rules for using Hetscale: who runs it, what it does in your Hetzner project, plans and payment through Paddle, cancellation and liability.
- [Refund policy](https://hetscale.com/refund-policy): A full refund within 14 days of your first payment or of a yearly renewal. How to ask, how Paddle pays it back, and what happens to your groups.
- [Data processing agreement](https://hetscale.com/dpa): The terms on which Hetscale processes personal data for your organisation: the data, how long it is kept, the sub-processors, security and transfers.