---
title: "Pricing and plans"
description: "The two plans, Free and Paid, what each includes, the one price list every product is billed by (traffic by region and Drives among it), and how the balance, top-ups, auto reload and spend limits work."
---

> Documentation Index
> Fetch the complete documentation index at: https://glac.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Pricing and plans

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

| Plan | Fee | What it includes | Past it | Largest instance |
|---|---|---|---|---|
| Free | $0, no card | A quota of each meter every day, back at 00:00 UTC | That stops until 00:00 UTC; never charged | 2 vCPUs, 4 GiB |
| Paid | $5 a month | A quantity of each meter every month | The list price, from your balance | 8 vCPUs, 16 GiB |

- **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](/docs/platform/limits/).

## The meters and their prices

| Meter | Price | Free, each day | Paid includes a month |
|---|---|---|---|
| CPU, while it computes | $0.01 a million CPU-ms | 1M CPU-ms | 60M CPU-ms |
| Memory, while awake or paused in memory | $0.008 a GiB-hour | 6 GiB-hours | 250 GiB-hours |
| Requests, into Cubes and through sandbox links | $0.30 a million | 100,000 | 10 million |
| What a sleeping instance keeps (its memory and its own disk) | $0.02 a GB-month | 15 GB of data in all, with snapshots and Drives | 20 GB-months of data, with snapshots and Drives |
| What snapshots, Drives and volumes keep | $0.02 a GB-month | The same data | The same data |
| Traffic out to the internet, from North America | $0.004 a GB | 3 GB, from any region | 1 TB, from any region |
| Traffic out to the internet, from Europe | $0.004 a GB |  |  |
| Traffic out to the internet, from Asia-Pacific | $0.01 a GB |  |  |
| Logs: what Cubes print that is kept | $0.02 a GB-month | 200 MB printed | 10 GB-months |
| Drives: their NVMe cache, the size set | $0.06 a GB-month | 15 GB in all | 20 GB-months |
| Drives: writing and reading | No charge |  |  |

- **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](/docs/browser/#what-it-costs).
- **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.

| Meter | Its name, and its unit | What is counted |
|---|---|---|
| CPU | `cpu`, `cpu_seconds` | The CPU time a sandbox's or instance's machine uses while it runs, as the host counts it: its vCPUs and the device threads working for it, to the microsecond. Time the host spends waiting on the machine's behalf is not counted, up to as much as is counted. Priced by the million busy CPU-milliseconds. |
| Memory | `memory`, `memory_gib_seconds` | The memory the host holds for a machine while it is awake or paused in memory, in steps of 128 MiB, by the millisecond. Pages it shares with its template and has only read are not counted. Priced by the GiB-hour. |
| Requests | `requests`, `requests` | Each request into a Cube, or into a sandbox through a link or a domain, that a machine takes, and each SSH session. A WebSocket is one request, however long it stays open. Requests refused before a machine took them are not counted. Priced by the million. |
| What sleeping sandboxes keep | `state`, `state_gb_hours` | Their saved memory and the part of their disk that is their own; what the object store keeps of the newest checkpoint of a sandbox or keyed instance that is awake ([checkpoints](/docs/sandbox/sleep/#checkpoints)); and what [backups of volumes](/docs/drive/volumes/#backups) take in the object store, which the line says apart (`backups_gb_hours`). By the GB-month. |
| What snapshots, Drives and volumes keep | `storage`, `storage_gb_hours` | A snapshot's own bytes; a Drive's or volume's bytes written and not trimmed away. Not their size. By the GB-month. |
| Traffic out | `egress`, `egress_bytes` | Bytes sent to the internet, answers to requests included, and logs exported to your destinations; priced by the GB, by the region of the machine they leave from (below). |
| Logs | `logs`, `log_gb_hours` | What Cubes' instances print that is kept, as printed (not as stored, compressed), for as long as it is kept. Request lines and the platform's lines are free. By the GB-month. |
| Volume cache | Volume cache, by the GB-month | The part of a Drive kept on the machine's NVMe, the size set for it, from none to all of it: the smaller of that size and the data the Drive holds, hour by hour. By the GB-month. |

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 out to the internet, by where it leaves from | Price |
|---|---|
| North America | $0.004 a GB |
| Europe | $0.004 a GB |
| Asia-Pacific | $0.01 a GB |

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](/docs/drive/#what-it-costs). 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](/docs/drive/snapshots/#what-is-billed).

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 and 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](https://glac.ai/terms/#9-credits-top-ups-and-auto-reload), 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`](/docs/errors/#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:

|  | Free | Paid |
|---|---|---|
| Spend limit until you choose one | None: never charged | $50 a month |

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.

| Level | How an account reaches it | Auto reload, a month at most | Top-ups, a month at most |
|---|---|---|---|
| 0 | A new account | $100 | $500 |
| 1 | 30 days after its first payment, with no dispute or fraud warning since | $500 | $2,000 |
| 2 | 90 days after its first payment, with no dispute or fraud warning since | $2,000 | $10,000 |
| 3 | Given by support | No limit | No limit |

A top-up or an auto reload past them is refused (403 [`trust_limit_exceeded`](/docs/errors/#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`](/docs/errors/#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:

| Used up for the day | What stops |
|---|---|
| CPU or memory | Every sandbox and instance of the account goes to sleep, with its data, and nothing new is made or woken. |
| Requests | Requests to the account's apps and sandboxes are answered with 429; the sandboxes keep running. |
| Traffic out | Traffic to the internet stops; sandboxes keep running, and requests to them are refused, since every answer is traffic out. |
| Logs | What Cubes print from then on is not kept for the long term: it stays readable on the machine for a while. No call is refused. |

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.

**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:

| Used up | What stops |
|---|---|
| CPU or memory | Every sandbox and instance of the account goes to sleep, with its data, and nothing new is made or woken (403 `balance_used_up`). |
| Requests | Requests to the account's apps and sandboxes are refused (403 `plan_limit_reached`); the sandboxes keep running. |
| Traffic out | Traffic to the internet stops; sandboxes keep running, and requests to them are refused, since every answer is traffic out. |
| Logs | What Cubes print from then on is not kept for the long term: it stays readable on the machine for a while, and the log says `logs.keep_off`. An app's `logs_state` says which machines have stopped keeping, and since when ([logs](/docs/platform/logs/#what-is-kept-and-for-how-long)). No call is refused. |
| What is kept | Nothing can stop: what is kept stays and keeps being counted, and the balance goes below zero. See [an account that owes](#an-account-that-owes). |

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](/docs/platform/projects/#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 and 29, at its address for notices once that is verified ([where notices go](/docs/platform/projects/#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.

Source: https://glac.ai/docs/platform/pricing/index.mdx