Every organization is on a plan. A plan's monthly price covers that much usage; what's used beyond it is billed on top, at the prices below.
| Hobby | Business | |
|---|---|---|
| A month | $5, covering $5 of usage | $50, covering $50 of usage |
| Sizes | up to 2xl: 8 cores, 8 GB | up to 5xl: 32 cores, 64 GB |
| Instances of a service | up to 3 | up to 10 |
| A volume, at most | 100 GB | 4 TB |
| Support | by email, as soon as we can | priority: an answer within one business day |
| Private servers | — | yes, at their own monthly price |
Choose it under Billing → Plans; it applies to the month you're in. Moving to Hobby needs your services within Hobby's limits (the page says which aren't). Need more than Business? Talk to us.
Usage is counted in four numbers:
| $6 per GB of memory, a month awake | A service's size (its memory, and the cores that come with it), billed by the hour it's awake. Asleep costs nothing. |
| $0.10 per GB of a volume, per month | A volume's size, full or not, whether its service is awake, asleep or stopped. |
| $0.10 per GB stored, per month | Snapshots, buckets and static sites, by what they hold. |
| First $5 free, then your plan | Once your free $5 is used up, your plan is charged every month: Hobby's $5 covers your first $5 of usage, Business's $50 the first $50. |
Requests, data transfer, builds, custom domains and team members aren't charged. Prices are in US dollars, with no VAT on top.
Every service runs at a size: its memory and the cores that come with it. It's what the service may use, what its server keeps for it, and what it's billed for each hour it's awake.
| Size | Cores | Memory | A month awake | An hour |
|---|---|---|---|---|
| xs | ¼ | 256 MB | $1.50 | $0.0021 |
| s | ½ | 512 MB | $3 | $0.0041 |
| m | 1 | 1 GB | $6 | $0.0082 |
| l | 2 | 2 GB | $12 | $0.0164 |
| xl | 4 | 4 GB | $24 | $0.0329 |
| 2xl | 8 | 8 GB | $48 | $0.0658 |
| 3xl | 16 | 16 GB | $96 | $0.1315 |
| 4xl | 32 | 32 GB | $192 | $0.263 |
| 5xl | 32 | 64 GB | $384 | $0.526 |
Hobby runs up to 2xl, Business up to 5xl. An app gets s unless it says; a database its engine's (xs for Postgres and Redis, m for MySQL and MongoDB); a computer m.
Change it under Scaling (or with size in alf.toml, or the API): it takes effect at once, on the containers as they run, with no restart. Smaller works the same way; whatever in it uses more memory than the new size by then is stopped and started again. A size bigger than the servers it runs on can hold is refused, and the service keeps the size it had: one container can have up to 80% of its server's memory, and no more cores than it has.
What a month comes to: an app that sleeps is billed only while it's awake, so an s website awake three hours a day costs about 37 cents a month. A database never sleeps, so it costs its size all month: $1.50 for an xs Postgres. On Hobby, an s app awake all month, an xs Postgres and 2 GB of disk come to $4.70, within the $5 the plan covers.
Each container counts on its own: a service on two servers, or one that scaled out to three containers under load, is billed two or three times its size for that time. Its server counts each container's time every 15 seconds, from when it starts until it has finished its last requests, so one added for twenty seconds is billed for those twenty seconds. A container that goes over its memory is stopped by the server and started again, so a size that's too small shows as restarts (and as a warning on the service). At its cores it runs slower instead.
Disk speed isn't limited or charged, whatever the size: a service reads and writes as fast as the server's disk does.
A volume is billed by its size, whether it holds anything or not: 10 GB is $1 a month. Change its size under the service's Volumes: bigger, or smaller down to what it holds.
Everything else that's kept is billed by what it holds. A gigabyte kept for a whole month is one GB-month, counted once an hour: 10 GB kept for three days is about 1 GB-month, so $0.10. That's the snapshots kept beside volumes, snapshots' copies off the server, what your buckets hold, and static sites' files. The code you pushed isn't charged.
A private server has a flat monthly price, agreed with Alf. What runs on it isn't metered: no compute and no storage charges for it.
After signing up, you add a payment method: it comes before anything is created or deployed (without one the API answers 402 with the code payment_required). It's entered on our payment provider's page, and adding it charges nothing.
Then every organization starts with $5 of free usage, with no time limit. Billing shows how much is left.
When it's used up, nothing changes for what runs: your plan applies. From the following month, your plan's price is charged every month ($5 on Hobby, $50 on Business), whether you use anything or not, and it covers that much usage; beyond it you pay what you used. To stop paying, delete the organization: its last invoice is for the month you delete it in, up to then, plan included, and it's made a week later, when the organization is deleted for good (Deleting an organization).
Three figures at the top:
Below them, the month service by service: each one's size, the hours it was awake, what it cost so far and what the whole month comes to; then volumes, storage, any server of your own, and the sum with what your plan covers and your free credit. Then the two plans side by side, to move between.
The estimate is made like this: a service that never sleeps is awake to the end of the month, and one that sleeps is awake as much as over its last full days (up to seven), each at its size now; volumes keep their size, and what's stored now stays stored. It's a guess: a new size, a busy week or a quiet one changes it.
Billing → Usage shows, per month:
Days are in UTC; figures are brought up to date every 15 minutes. The same figures are in the API: GET /organizations/{id}/usage, GET /organizations/{id}/billing and the price list at GET /pricing.
Set one under Billing. Once the month reaches it, nothing new can be created or deployed and standing becomes capped — but what's already running keeps running. Turning someone's apps off over money they agreed to spend isn't a decision to make automatically.
Worth setting wherever a coding agent can deploy. An agent can make a service bigger, scale it out, hold a session container open, or get into a loop; the limit is what lets you hand one the keys without handing it the chequebook. You're told once when a month reaches it, if you have a notification channel for it.
The limit can't be lower than your plan's monthly price. What counts towards it is what you use, so a limit at exactly that price is reached once your usage gets there.