# Billing and usage

isolance is prepaid. Each workspace has a balance of credits that you buy with a card, and usage is deducted from it as it's recorded. There's no subscription fee, no minimum spend and no monthly invoice. Each successful top-up gets its own Stripe receipt.

This guide covers the balance, adding funds, auto-recharge, what happens when the balance runs out, what each meter costs, and how to read your usage.

## How billing works

- **One balance per workspace.** Sandboxes, MCP servers and registry images all draw from the balance of the workspace they belong to.
- **Usage is deducted as it's recorded.** isolance charges the balance to the millionth of a dollar and never rounds up to cents.
- **Sandboxes need a card and funds.** A sandbox can start only while the workspace has a card on file and a balance above $0. Adding funds for the first time saves your card.
- **Prices are in US dollars.** The rates are listed under [Rates](#rates) and on the [pricing page](/pricing.html).

Who can do what depends on your role in the workspace:

| Role | Billing access |
| --- | --- |
| Owner | Sees usage and the balance, adds funds, changes auto-recharge, the spend alert and the card |
| Viewer | Sees usage and the balance, and downloads the usage CSV |
| Operator | No billing access |

## Add funds

1. In the [console](https://console.isolance.com/), open **Usage & billing**.
2. In the **Auto-recharge** section, enter an **Amount** of credits from $5 to $2,000, such as `25` or `$25.50`.
3. Choose **Add funds**.

The amount is what's added to your balance, and it's what your card is charged.

What happens next depends on whether the workspace has a card on file:

- **No card yet:** Stripe Checkout opens. Paying there adds the funds and saves your card for later top-ups.
- **Card on file:** isolance charges that card. The top-up shows as **Processing** under **Recent top-ups**, and the balance updates once Stripe confirms the payment. If your bank asks you to verify the payment, Stripe Checkout opens so you can finish it there.

If the card is declined, the page shows Stripe's reason, and the top-up is listed as **Failed**. Try another card (see [Receipts and payment methods](#receipts-and-payment-methods)) or another amount.

From a terminal:

```sh
caas billing add-funds 25
```

With a card on file, this charges it. Otherwise it prints a Stripe Checkout link, which you open to pay and save your card. See [Billing from the CLI and the API](#billing-from-the-cli-and-the-api) for the API key it needs.

## Auto-recharge

Auto-recharge keeps the balance from running out by charging your card when the balance gets low. **It's off by default.** Saving a card or adding funds never turns it on.

To turn it on:

1. Open **Usage & billing** and find the **Auto-recharge** section.
2. Set **Auto-recharge** to **On**.
3. Set **When balance falls below**, the minimum: $5 to $1,000. The default is $10.
4. Set **Recharge to**, the target: at least $5 above the minimum, and at most $2,000. The default is $50.
5. Choose **Save**.

Auto-recharge needs a card on file. If you turn it on before there's one, it starts working once a card is saved, for example by your first top-up.

### How a recharge works

- When usage takes the balance below the minimum, isolance charges your card once to bring the balance back to the target. It buys the target minus the balance in credits, rounded up to the cent. For example, with a $10 minimum and a $50 target, a balance of $9.40 gets $40.60 of credits.
- It charges once each time the balance falls below the minimum. It doesn't charge again until the balance is back at or above the minimum.
- It also recharges at once if the balance is below the minimum when you turn auto-recharge on, when you raise the minimum above a balance that was at or above the old minimum, or when a new card is saved, unless a recharge is already on its way.
- Each recharge is listed under **Recent top-ups** as **Auto-recharge**, with its receipt.

### If a recharge is declined

The **Auto-recharge** section shows the decline with Stripe's reason, and isolance sends one email about it. It tries again an hour later, then six hours after that, then a day after that: four attempts in all, each charging whatever then brings the balance to the target. Each attempt charges the card on file at the time, so a card you change in the meantime is the one the next attempt charges. After the last attempt, saving a new card recharges at once if the balance is still below the minimum. You can also add funds yourself at any time; once the balance is back at the minimum, the remaining attempts are canceled.

### While auto-recharge is off

isolance emails a low-balance warning each time the balance falls below the **When balance falls below** amount. Nothing is charged. Sandboxes stop when the balance reaches $0. The same warning goes out while auto-recharge is on but no card is on file.

Low-balance warnings and declined-recharge emails go to the billing email Stripe has for the workspace, which starts as the email of the owner who first added funds or a card in the console. If Stripe has no email, they go to the owner who set the spend alert.

From a terminal:

```sh
caas billing auto-recharge show
caas billing auto-recharge set --below 10 --recharge-to 50
caas billing auto-recharge set --off
```

`set` turns auto-recharge on and keeps any amount you don't give. `--off` turns it off.

## When the balance reaches $0

When the balance reaches $0 or goes below it:

- Every running sandbox and MCP server stops, saving its state the same way an [idle stop](/docs/sandboxes#idle-stop) does.
- Starting a sandbox is refused. The console says the balance is empty, and the API answers `402` with the code `out_of_funds`.
- Storage keeps billing: snapshots and registry images. Together with usage recorded just before the stop, this can take the balance below $0.

To run again, add enough funds to bring the balance above $0, then start your sandboxes. As after an idle stop, a sandbox stopped this way also starts again by itself when a command, a file transfer or an MCP request arrives. On the **Usage & billing** page, a balance at or below $0 is shown in red.

Without a card on file, sandboxes can't start whatever the balance. The API answers `402` with the code `payment_method_required`.

## Rates

Sandboxes on Native bill per resource, MCP servers per request on top of their sandbox, browsers by their time, and the registry for storage, pulls and lists.

These rates apply from October 21, 2026, 00:00 UTC. See [A month with more than one set of rates](#a-month-with-more-than-one-set-of-rates) for the earlier ones.

**Native** is isolance's own runtime, where any workspace can run sandboxes.

**Daytona, Freestyle, Maritime and E2B** run your sandboxes only on your own account, with your own key. That provider bills you directly for their compute and egress, at its own rates, and isolance bills none of it. Their other meters, such as snapshot storage and MCP Gateway requests, bill here as usual.

### Sandboxes on Native

| Meter | Price | What counts |
| --- | --- | --- |
| CPU | On the [pricing page](/pricing.html) | The vCPU of the sandbox's size, while it runs, whether it's busy or waiting |
| Memory | On the [pricing page](/pricing.html) | The memory of the sandbox's size, while it runs |
| Disk | On the [pricing page](/pricing.html) | The disk of the sandbox's size, while it runs |
| Egress | On the [pricing page](/pricing.html) | Data leaving the sandbox: what it sends to the hosts it's allowed to reach (a sandbox that allows every host counts only what it sends to its connectors' hosts), and what you download from it through its MCP endpoint and its files. Pulls of your images from registry.caas.sh don't count. |
| Snapshot storage | On the [pricing page](/pricing.html) | Each snapshot, from when it's taken until it's deleted |
| Snapshot create and restore | Included | No charge per operation |

A stopped sandbox bills no CPU, memory or disk, only its snapshots. See [Sizes](/docs/sandboxes#sizes) for each size's vCPU, memory and disk.

### MCP servers

| Meter | Price | What counts |
| --- | --- | --- |
| MCP Gateway requests | On the [pricing page](/pricing.html) | Requests to the server's endpoint with a valid client token |

Requests refused for a missing, invalid, expired or revoked token aren't billed. The server runs in a sandbox, which bills at the sandbox rates while it runs. See [MCP servers](/docs/mcp).


### Browsers

| Meter | Price | What counts |
| --- | --- | --- |
| Browser time | On the [pricing page](/pricing.html) | Each browser on isolance's own browsers, from when it opens until it closes, or, left to idle out, until 20 minutes after its last call |

A check of a login and a person's live view are browsers too. Browsers on your own Browserbase account, which Browserbase bills you for, and logins aren't charged. Browser time bills from October 25, 2026, 00:00 UTC. See [Browser time](/docs/browser#browser-time).

### Container registry

| Meter | Price | What counts |
| --- | --- | --- |
| Registry storage | On the [pricing page](/pricing.html) | The images you keep at registry.caas.sh |
| Registry pulls | On the [pricing page](/pricing.html) | Each image manifest fetched, by Docker or by your sandboxes. A multi-platform image counts two: its index and the platform's manifest. `HEAD` requests and layer downloads are free. |
| Registry lists | On the [pricing page](/pricing.html) | Each listing of an image's tags (`tags/list`). The registry doesn't list your workspace's image names. |

See [Images and the registry](/docs/images).

### Units and rounding

- A month is 30 days (720 hours) for every per-month price.
- A GB is 1,000,000,000 bytes, for disk, egress, snapshot storage and registry storage. A GiB is 1,073,741,824 bytes, for memory.
- Each meter's amount is rounded down to the millionth of a dollar.
- Credits are bought in whole cents.

### A month with more than one set of rates

October 2026 is billed in six parts, each at its own rates:

- **Until October 15, 00:00 UTC:** the first rates, with vCPU billed by the CPU time used.
- **October 15 to October 20, 00:00 UTC:** vCPU billed by the sandbox's size, whether busy or waiting, on isolance's own account of every provider.
- **October 20 to October 21, 00:00 UTC:** on Native, vCPU billed by the CPU time used.
- **October 21 to October 23, 00:00 UTC:** today's rates, without browser time.
- **October 23 to October 25, 00:00 UTC:** today's rates, without browser time, with E2B among the providers that run on your own key.
- **From October 25, 00:00 UTC:** today's rates, browser time included.

The other rates didn't change. Usage that spans a change, such as a sandbox that runs through midnight or a snapshot kept across it, is split at it in proportion to time. Each part is rounded on its own, and the month's lines and total are the sum of the parts. The month's usage report from the API lists each part under `plans`, with its own rates, lines and total.

## The Usage & billing page

Open **Usage & billing** in the console to see a month's spend. The menu at the top switches between this month and last month. Months and days are in UTC.

- **Summary:** **Month to date**, **Projected for** the month (see [Projections](#projections)), and **Today so far**. For last month, you see the month's total instead.
- **Daily spend:** one bar per day, with today's bar marked.
- **By meter, month to date:** each meter's usage, rate, share of the total and cost, then the **Total**. Storage meters show the average amount stored over the period. Snapshot create and restore are listed as included.
- **Spend alert** and **Auto-recharge:** see [Spend alerts](#spend-alerts) and [Auto-recharge](#auto-recharge).

The **Spend this month** tile on the **Overview** shows the same month-to-date total.

### Download usage as CSV

Choose **Download CSV** to save the selected month as `caas-usage-YYYY-MM.csv`. It has one row per day and meter with usage, and its amounts add up exactly to the **By meter** table and the month's total.

| Column | Contents |
| --- | --- |
| `day` | The UTC day, such as `2026-10-07` |
| `meter` | The meter: `vcpu`, `memory`, `disk`, `egress`, `snapshotStorage`, `gatewayRequests`, `registryStorage`, `registryPulls`, `registryLists`, `browserTime`, or `snapshotOperations` for the included snapshot creates and restores |
| `quantity` | The usage, in the unit the price is quoted in. For `vcpu`, that's the vCPU of the sandbox's size while it ran, except before October 15, 2026 and on October 20, 2026, when it was the CPU time used |
| `unit` | That unit: `vcpu-hour`, `gib-hour`, `gb-hour`, `gb` (egress; `gib` from October 15 to October 19, 2026), `gb-month`, `1000-requests`, `gib-month`, `1000-pulls`, `1000-lists`, `hour` (browser time), or `operation` |
| `rate_usd` | The price per unit on that day, in dollars with six decimal places |
| `amount_usd` | What the row cost, in dollars with six decimal places |

Snapshot operations have a rate and amount of `0.000000`. From a terminal, `caas billing usage --csv` prints the same file:

```sh
caas billing usage --month 2026-09 --csv > caas-usage-2026-09.csv
```

## Spend alerts

A spend alert emails you the first time a month's spend reaches an amount you choose. It doesn't stop or limit anything.

1. Open **Usage & billing**.
2. In **Spend alert**, enter an amount in dollars, such as `300`. The field is labeled with the current month, such as **Email me when October passes**.
3. Choose **Save**.

Only owners can set it. The email goes to the owner who saved the alert. The amount applies to every month until you change it, and each amount emails at most once a month. If you set a new amount after an alert, the new amount can alert again in the same month. To turn the alert off, clear the amount and choose **Save**.

### Projections

For the current month, isolance projects the month's spend at the current pace: the month to date, divided by the days so far (today counts as a whole day), times the days in the month. The summary shows it as **Projected for** the month, and the spend alert shows when you'd reach your amount at that pace, such as "At the current pace you'd reach $300 around Oct 23."

## Receipts and payment methods

isolance doesn't send monthly invoices. Each top-up that succeeds, whether you added the funds or auto-recharge did, gets a Stripe receipt for the credits:

- On **Usage & billing**, **Recent top-ups** lists your latest top-ups, each paid one with a **Receipt** link.
- In **Settings**, the **Billing** section, which only owners see, lists receipts for recent top-ups.
- `caas billing balance` prints recent top-ups with their receipt links.

Owners manage the card:

- **Change** next to the card on **Usage & billing**, or **Manage billing** in **Settings**, opens Stripe's billing portal, where you manage your card.
- **Add payment method** in **Settings** saves a card through Stripe Checkout without charging it.

Top-ups and auto-recharge charge the card marked **(charged)** in **Settings**.

## Billing from the CLI and the API

The CLI and the API need an API key with billing access. In the console, an owner opens **Settings**, enters a **Key name** in the **API keys** card, checks **Billing access**, and chooses **Create key**. See [Connect the CLI to your workspace](/docs/cli#connect-the-cli-to-your-workspace) to configure the CLI with it.

```sh
caas billing balance
caas billing usage
caas billing usage --month 2026-09
caas billing add-funds 25
caas billing auto-recharge set --below 10 --recharge-to 50
```

`caas billing balance` prints the balance, the auto-recharge setting and recent top-ups. `caas billing usage` prints a month's spend by meter, the projection while the month is current, and the spend alert. Add `--json` to any of them to get the response as JSON. See [Billing](/docs/cli#billing) in the CLI guide for every option.

The API serves the same data under `https://api.caas.sh/v1/billing/`, in the API key's workspace:

| Request | What it does |
| --- | --- |
| `GET …/billing/balance` | The balance, auto-recharge, the card and recent top-ups |
| `GET …/billing/usage?month=YYYY-MM` | A month's usage report, this month by default. Add `&format=csv` for the CSV. |
| `POST …/billing/top-ups` | Adds funds: `{"amountMicroUsd": 25000000}` for $25 of credits, with an `Idempotency-Key` header of 8 to 128 characters. The top-up in the response has `feeMicroUsd` 0 (only a top-up made from October 20, 2026 until the fee's removal can carry a fee). Without a card on file, the response has a Stripe Checkout `url` to pay at. |
| `GET …/billing/auto-recharge` | The auto-recharge setting |
| `PUT …/billing/auto-recharge` | Changes any of `enabled`, `minimumMicroUsd` and `targetMicroUsd` |

Amounts are in millionths of a dollar. Reading needs the `billing:read` scope, and adding funds or changing auto-recharge needs `billing:write`; a key created with **Billing access** has both. For example:

```sh
curl "https://api.caas.sh/v1/billing/usage?month=2026-10&format=csv" \
  -H "Authorization: Bearer $CAAS_API_KEY"
```

See [Send the key](/docs/api#send-the-key) for setting `CAAS_API_KEY`, and [Billing](/docs/api#billing) in the API guide for the response fields.