Limits and pricing

Every plan meters compute at the same rate and differs in what it grants and what it lets you run at once.

Plans

Each plan is a monthly subscription that grants more credit than it costs. Compute is drawn against that credit as it runs.

Scale sells concurrency, not a bigger sandbox: Base and Scale share the same 4 vCPU / 8 GB ceiling. A team with no plan is granted nothing, so it has nothing to spend.

Your plan, the credit left on it and these limits are on dashboard.impello.ai/billing and dashboard.impello.ai/limits.

What you are billed for

Compute is metered per vCPU-second, at the same rate on every plan. The bigger plan's extra credit is the only discount.

The rate is $0.0000075 per vCPU-second. Micro's $6 covers about 111 hours of a 2 vCPU sandbox; Base's $60 covers about 555 hours of a 4 vCPU one.

Only running time is metered. A sandbox is charged from the moment it starts or resumes until it is paused or killed, for the vCPU count it was allocated. There is no separate charge for disk, for network traffic, for snapshots, or for the time a sandbox sits paused.

Prices are exclusive of VAT and any other tax.

Sandbox size

A sandbox's vCPU and RAM come from the template it was built from, not from your plan. Creating a sandbox takes no size argument. The default template, base, is built at 2 vCPU and 1 GB, so an hour of it costs $0.054 on every plan.

Your plan's vCPU and RAM figures are the ceiling a template your own team builds may be built at. The size is fixed at build time, not when a sandbox starts from it. On Micro that ceiling is 2 vCPU and 4 GB.

Read the size back from the sandbox itself.

import { Sandbox } from '@impello/sdk'

const sandbox = await Sandbox.create('base')
const info = await sandbox.getInfo()

console.log(info.cpuCount, info.memoryMB)

await sandbox.kill()

When you build your own template you choose its size with cpuCount and memoryMB, which default to 2 and 1024. The template builder is TypeScript only; see Build a custom template.

import { Template } from '@impello/sdk/template'

await Template.build(Template().fromUbuntuImage('24.04'), 'my-template', {
  cpuCount: 4,
  memoryMB: 8192,
})

Sandboxes share servers Impello owns, under a fair scheduler. A sandbox has its full vCPU count most of the time and at least half of it when every neighbour is busy. For what a sandbox is actually using, see Metrics.

Credit

Two kinds of credit sit on the account, and plan credit is always spent first.

• Plan credit is granted at the start of each billing month and expires at the end of that month. It does not roll over.
• Credit packs are one-off purchases of $20, $50 or $100 from dashboard.impello.ai/billing. They do not expire while your account is open, so a pack sits untouched until the month's plan credit is gone.
• Promotional credit, where Impello grants it, expires 90 days after it is granted.
• Automatic top-up is off until an owner both turns it on and sets a monthly budget for extra spend on top of the plan; the switch on its own buys nothing. It then buys one pack of a fixed size when the balance runs low. It stops when extra spend reaches the budget, not when card payments reach it, and a server-side cap no one on the team can raise limits it per month.

Nothing is refundable once bought, and consumed compute is never refundable — except that where Impello terminates an account for convenience, unused purchased credit is refunded pro rata. What the team has spent this month, and the ten sandboxes that cost the most in it, are at dashboard.impello.ai/usage.

Cap your spend

An owner can set one monthly budget on dashboard.impello.ai/billing. It caps extra spend on top of your plan, not all usage or card payments. It excludes the separate plan fee and usage covered by plan or promotional credit, but includes usage paid from purchased credit packs. A team with $60 of plan credit that has used $45 has $0 extra spend, and a $40 budget does not touch it. Plan credit is used first, then promotional credit, then credit packs. Extra spend includes usage paid from credit packs you already bought; it is not a new card charge. Your monthly plan fee is separate.

• New sandboxes are refused once extra spend reaches the budget. Usage is reconciled every hour, so the refusal starts within the hour of the figure being crossed, not on the second.
• Raising the budget, or clearing it, lifts the refusal at the next hourly pass.
• A budget never kills a running sandbox. Sandboxes already running carry on to their own timeout.
• An email goes to the team's billing address at 80% and again at 100% of the budget.
• The budget is a whole number of dollars, from $1 to $50,000. It cannot be set at or below the team's extra spend this month.
• Automatic top-up stops at the budget as well.
• A team that sets no budget is never blocked by this.

When credit runs out

Usage is reconciled every hour. At zero available credit new sandboxes are refused. The same hourly pass releases the block once credit returns, so both take effect within the hour rather than on the second the balance moves. Sandboxes that are already running keep running — and keep metering — for a 24-hour grace period, and are killed at the end of it if credit has not returned.

A blocked team can still list its sandboxes and kill them; it cannot create one. Adding credit releases the block at the next hourly pass.

Concurrency

Your plan sets how many sandboxes you may have running at once, and the figure is in the table above. A create over that cap is refused rather than queued, so kill or pause a sandbox and create again. A create is also refused when the fleet is at capacity — again a refusal and never a queue, so retry rather than wait. See Refused creates.

Starts are rate limited as well. The API answers HTTP 429 when you ask for sandboxes faster than it allows. Both SDKs raise that as one error type, so back off and retry.

import { RateLimitError, Sandbox } from '@impello/sdk'

try {
  const sandbox = await Sandbox.create('base')
  await sandbox.kill()
} catch (error) {
  if (!(error instanceof RateLimitError)) throw error
  console.error('too many starts, retrying later:', error.message)
}

Every error type both SDKs raise is listed in Errors.

Paused sandboxes

A paused sandbox costs nothing. It holds its disk, and billing starts again when it resumes. There is no limit on how many sandboxes a team keeps paused, on any plan. Paused sandboxes do not count against the concurrency limit.

See Pause, resume and snapshots for what survives a pause, and Timeouts for the maximum length a sandbox may run before it stops on its own.

Changing plan

An upgrade takes effect immediately and is prorated: you pay for the rest of the period and the larger grant arrives at once. A downgrade waits until the end of the period you have paid for, so the plan, its limits and its grant all stay until then.

Cancelling drops the team back to the tier that grants nothing at the end of the period it has paid for. From then on it has no credit to run anything on.

Where sandboxes run

Sandboxes run on dedicated servers in Germany and Finland. The database, the usage-event store, the cache and the backup storage holding your templates are all in the European Union. Your code and your data do not leave the EU in the course of running. There is no region option on any call and no second region today.

Availability

Impello commits to no level of availability: there is no service level agreement, no uptime target and no service credits. Sandboxes may be interrupted, paused sandboxes may fail to resume, and maintenance may happen without notice. Design for it — and do not run anything on Impello whose interruption you could not tolerate. There is no status page. The full terms are at impello.ai/terms.

Your plan, your credit and your usage are at dashboard.impello.ai/billing. legal@impello.ai is the only address Impello publishes and it is for legal notices; there is no separate support channel yet.

Next: Migrate.