Pricing and plans

Diese Seite gibt es noch nicht auf Deutsch: Hier ist sie auf Englisch.

All prices are in US dollars; the platform is not yet registered for GST, so none is included or added. There is one price list for everything: Cube and every Managed Application (Sandbox, Browser, Serverless Postgres) are billed by the Cube resources they use, with no price of their own.

The plans

• Free needs no card. It has a quota of each meter every day, which comes back at 00:00 UTC: a quota used up stops that one thing until then (below). What is kept is a level, not a day’s quota: at most 15 GB of data in all, and 15 GB of NVMe cache. Free is never charged and never owes.
• Paid is $5 a month, charged to a card. Each month it includes a quantity of each meter (below), each meter on its own: what is left of one pays for nothing of another, and it is not carried over. Past it, usage is charged at the list prices and taken from the account’s balance.
• A period is, on Paid, a month of the subscription (from the moment it was paid to the same day of the next month); on Free, the day (UTC).
• What a plan lets an account have at once (instances awake, their vCPUs and memory, how fast new ones are made) is in limits.

The meters and their prices

• Data and cache. Data is one quantity for what sleeping instances keep and what snapshots, Drives and volumes keep, together. A Drive’s NVMe cache, the part of it kept on the machine’s NVMe at the size you set, is a quantity of its own, and so are the logs. Nothing is charged for writing or reading a Drive.
• Past what is included, on Paid, usage is charged at these prices and taken from the account’s balance. On Free nothing is charged: the thing stops until the next day.
• Browser, not open to accounts yet, is billed as every instance is, by its CPU, its memory and its traffic out: see Browser.
• To the millionth. Money is counted in millionths of a dollar. Each meter’s amount is its quantity times its price, rounded once, and every line of a bill can be worked out again from the quantities and prices it shows.

What each meter counts

GET /v1/billing has a line for each meter under its name (meters), in the unit its quantity has in the reports of GET /v1/usage; the price is for a larger unit.

A GB is 10⁹ bytes. A GB-month is a gigabyte kept for a whole period: the GB-hours divided by the hours in the period, so a gigabyte kept all month is one GB-month in February and in October alike.

Traffic out, by region

Traffic is priced by the region of the machine it leaves from. The bill, the statement and GET /v1/usage show it region by region, with each region’s price.

Volumes

Drives (publicly, volumes) are billed for their data, by the bytes written, not their size, all of it kept in tiered storage, and for their NVMe cache, the size you set: $0.08 a GB-month all cached, $0.02 with none cached, at the network’s speed. Writing and reading cost nothing. See Drive. A fork of a Drive is a Drive, billed for everything it holds as you read it (its used_bytes), shared blocks included: a fork of a 10 GB snapshot is a 10 GB Drive. A snapshot of a Drive is billed for what it keeps alone, on the data meter: see Drive snapshots and forks.

Usage is recorded by the hour, with the labels (metadata) each sandbox had then: GET /v1/usage?from=…&to=…&group_by=day,metadata.team gives the quantities behind a bill, and the prices to multiply them by; glac usage --from 7d --group-by day prints the same.

The balance

The balance is in Credits: one Credit pays for one US dollar of usage past what Paid includes. Credits come from top-ups. They cannot be withdrawn or moved to another account, and a top-up does not change the plan. Paid’s fee is charged to your card, never taken from the balance.

• Top-up: glac billing topup 20 (POST /v1/billing/topups), at least $20, in whole cents, charged to your card; or pay on the payment page (POST /v1/billing/checkout), which also keeps your card. Credits arrive when the payment is collected.
• Auto reload: off until you turn it on (glac billing auto-reload on), and it needs a card on record. When the balance falls below a line (5 Credits unless you say), it tops up an amount ($20 unless you say): glac billing auto-reload on --below 5 --reload 20.
• Expiry: Credits expire 365 days after they arrive, each top-up’s on their own. Notices go out 30, 7 und 1 days before; support can bring back Credits within 30 days after they lapsed.
• Refunds: Credits are not refunded, and Paid’s fee is not refunded when you move back to Free or end the subscription. A payment is refunded only if it was charged in error or the law requires it, as when a consumer in the European Union or the United Kingdom withdraws: see the Terms of Service, 9.6. A payment that is refunded takes back only the Credits it bought that are not used yet: refunded in part, that part’s share of them, and no more than is left unused; what was used stays used. The event (topup.refunded, subscription.refunded) says what was refunded and what was taken back.
• Tax: we are not registered for tax in any country yet (GLAC PTY LTD is not registered for GST), so no tax is added to payments and Credits are the amount you pay. When we register somewhere, this page will say where, and the tax of your billing address will be added there. Tax goes by where the account is, so a charge to the card that nobody is there to make (a top-up through the API, Paid’s fee, auto reload) needs the account’s billing address, or a card that says its country: without either it is refused, 409 billing_address_required, and nothing is charged. Set the address with glac account billing-address --country DE (PATCH /v1/account with billing_address), or pay on the payment page, which asks for it.

The account’s spend limit

The most auto reload may charge your card in a calendar month: glac billing spend-limit 50 (PATCH /v1/billing with spend_limit_usd). Until you choose one, an account on Paid has $50 a month; Free, never charged, has none:

Auto reload is never more than the account’s trust level allows: glac billing says what auto reload may still take this month, the less of what the spend limit and the trust level leave (reload_left_usd of GET /v1/billing/balance).

Trust levels

A new account may be charged only so much a month. The limits rise by themselves after the first payment, while no payment is disputed; support can raise them sooner.

A top-up or an auto reload past them is refused (403 trust_limit_exceeded, which says the level and what is left this month). glac billing shows the account’s level and when it rises. A payment that is disputed or warned of as a fraud puts the account on hold until support has looked at it: nothing of it is used or charged meanwhile (account_held).

When a meter runs out

On Free, a day’s quota used up stops that one thing until 00:00 UTC, and nothing is charged:

What is kept cannot stop, so Free keeps at most 15 GB of data in all, and 15 GB of NVMe cache, and makes nothing that would keep more: a new volume or snapshot past it is refused with 403 storage_quota_reached. The Credits an account on Free holds pay for nothing there: they wait for Paid.

On Paid, a meter’s inclusion used up is paid from the balance at the list price. When the balance is empty too, the meter stops:

Everything starts again when Credits arrive, or at the next month’s inclusions. An account with no balance and no auto reload gets an email when a meter reaches 80% and 100% of what is included. The few seconds of usage between a meter running out and the stop are taken from the balance where it can pay them, and otherwise written off.

Spend limits on projects and sandboxes

PATCH /v1/limits with {spend_limit_usd} sets a monthly limit (UTC calendar month, in US dollars) on a project, or the console’s Projects page; PATCH /v1/sandboxes/{id}/limits on one sandbox. glac limits --set 50 (--sandbox web for one sandbox) and the SDKs’ update_limits do the same, and glac limits shows the limit and what was spent this month. At the limit their sandboxes are put to sleep and cannot be woken, and nothing new is made, until the limit is raised or the month ends. What Drives, snapshots and backups keep cannot be frozen: it goes on being counted. The limit is checked every few seconds, so a few seconds of usage can go past it.

Subscriptions

• glac billing plan paid (PATCH /v1/billing with {"plan": "paid"}; the plans are free and paid) subscribes: $5 is charged to the card, and Paid starts the moment it is paid, with the month’s inclusions.
• Back to Free ({"plan": "free"}): at the end of the month paid for. Nothing is refunded.
• A renewal that fails is tried again for 7 days, and the account stays on Paid meanwhile. If it is never paid, the account is on Free from then on: sandboxes larger than Free allows go to sleep with their data, and wake when the account is on Paid again. Nothing is deleted.

The statement

GET /v1/billing/statement?period=2026-10 is the bill of a calendar month (UTC): one line per meter, with what was used, what the plan included of it, what was past it and what that cost, the parts of the month that different periods or plans covered, and which Credits paid. Each part says what its usage came to at the list prices (list_usd) and what was left to pay (usage_usd). Each database has a line of its own (databases): what its branches’ instances and Drives used in the month, its history (history_gb_hours, of its storage) and its tiered partitions (tiered_gb_hours) said apart, and what that comes to at the month’s list prices (list_usd); what is billed past what the plan includes is in the meters’ lines, with everything else. glac billing statement 2026-10 (this month’s without one), the SDKs’ statement and the MCP server’s account_statement read it. GET /v1/billing (glac billing) is the account now: the plan, every meter’s used, included and left, the balance and what has stopped. The console’s Billing page, for owners, shows the same and does everything on this page.

Invoices, mail and withdrawals

• Invoices: GET /v1/billing/invoices (glac billing invoices) lists every charge that has an invoice at Stripe, newest first: its number, its status and total, the link to its PDF, and of a charge taken back, the credit note.
• Mail: GET /v1/billing/notices (glac billing notices) is the mail the account was sent and is to be sent, with how each stands (where notices go).
• Withdrawals: a consumer in the European Economic Area or the United Kingdom may withdraw from a purchase within 14 days. GET /v1/billing/withdrawals (glac billing withdrawals) says whether a purchase made now gives that right, lists each purchase the account may withdraw from now with what withdrawing would give back, and the withdrawals it made. POST /v1/billing/withdrawals with {charge_id, name} (glac billing withdraw CHARGE --name NAME, a key with the admin scope) is the buyer’s statement of withdrawal, received at once: the charge is refunded to the card it was paid with, a top-up’s Credits that are left are taken back (and auto reload is turned off), and Paid’s period and the subscription end there; the acknowledgement is mailed.

The SDKs have the same calls (invoices, notices, withdrawals, withdraw); the MCP server shows the three lists (account_documents) and withdraws from nothing: a withdrawal is the buyer’s own.

An account that owes

Only an account on Paid can owe, and only what is kept can take its balance below zero. Less than $0.50 owed is carried and taken from the next Credits or the next subscription payment. At $0.50 or more, the account is in debt:

• It can do nothing but read its bill and usage, pay, list, read and delete what it stores (sandboxes, snapshots, Drives, volumes, backups), and make a volume from a backup. Everything else answers 402 account_in_debt, and its sandboxes sleep.
• It gets an email when the debt starts, and reminders on days 7, 14, 21, 27 und 29, at its address for notices once that is verified (where notices go). On its billing day (each month, the day of the month its subscription began, or else the day its first top-up was collected) the debt is charged to its card.
• 30 days after the first email was delivered, if it still owes, everything it stores is deleted: sandboxes and instances, snapshots, Drives, volumes, backups, its own templates, and apps with their versions. The debt is then written off. The account, its projects, keys, secrets, SSH keys, webhooks, domain registrations, events, audit log, ledger and bills stay.
• Deleting what it stores stops the debt from growing; what is already owed stays owed. Paying before the date ends the debt and loses nothing; paying while the deletion is under way stops it, but what was deleted stays deleted.