# Introduction

> Sandboxer gives AI agents and people full Linux computers in the cloud that start fast, pause with their memory intact, fork instantly and bill by the second.

Sandboxer runs **persistent Ubuntu 24.04 microVMs** — we call them sandboxes — that you create from a CLI, an HTTP API or an SDK. Each one is a real virtual machine, not a container: you get root, systemd, Docker, nested KVM, SSH and SCP, a public HTTPS URL for any port, a streamed desktop with Chrome, and coding agents that are already installed and signed in with your keys.

The point of a sandbox is that it is **yours for as long as the work takes**. Leave it running for a week, stop it for a month, resume it in seconds, fork it into ten copies, or save it as a template that every new sandbox starts from.

## What makes it different

- **Resume keeps running processes.** When you stop a sandbox we snapshot its memory as well as its disk. A resume restores that memory, so your dev server, your database, your tmux session and the agent that was halfway through a task are still running. Other platforms reboot on resume.
- **Forks are copy-on-write.** A fork reflinks the disk, so it takes about the same time for a 2 GB sandbox as for a 200 GB one, and costs no extra storage until the copies diverge.
- **Stopped costs nothing.** You pay per second while a sandbox runs. Disks and snapshots of stopped sandboxes are free, up to your plan's included storage.
- **A standard, documented REST API.** Everything is one HTTP API under `/api/v1`, described by an OpenAPI document, with the `sbx` CLI and TypeScript and Python SDKs on top. See [API reference](/docs/api).

## Three ways in

```bash title="CLI"
curl -fsSL https://sandboxer.com/install | sh
sbx new            # create a sandbox and wait until it is ready
sbx ssh            # open a shell in it
```

```bash title="curl"
curl -sS -X POST https://sandboxer.com/api/v1/sandboxes \
  -H "Authorization: Bearer $SANDBOXER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"ttlSeconds": 3600}'
```

```typescript title="TypeScript"
import { SandboxerApi, Configuration } from "sandboxer-sdk";

const sbx = new SandboxerApi(new Configuration({
  basePath: "https://sandboxer.com/api/v1",
  accessToken: process.env.SANDBOXER_API_KEY!,
}));
const { sandbox } = await sbx.create({ ttlSeconds: 3600 });
```

```python title="Python"
import os
from sandboxer import ApiClient, Configuration
from sandboxer.api.sandboxer_api import SandboxerApi
from sandboxer.models import CreateSandboxRequest

config = Configuration(host="https://sandboxer.com/api/v1", access_token=os.environ["SANDBOXER_API_KEY"])
with ApiClient(config) as client:
    created = SandboxerApi(client).create(CreateSandboxRequest(ttl_seconds=3600))
    print(created.sandbox.id)
```

## Where to go next

| If you want to | Read |
| - | - |
| Get a sandbox running in two minutes | [Quickstart](/docs/quickstart) |
| Understand sizes and what is installed | [Machines & sizes](/docs/machines) |
| Pause, resume and copy sandboxes | [Snapshots](/docs/snapshots) |
| Put a web app on the internet | [Hosting](/docs/hosting) |
| Hand a task to Claude Code or Codex | [Integrated agents](/docs/agents) |
| Call the API from your backend | [API reference](/docs/api), [TypeScript SDK](/docs/sdk-typescript), [Python SDK](/docs/sdk-python) |
| Script everything from a shell | [CLI reference](/docs/cli) |
| Know what it costs | [Billing](/docs/billing) and [pricing](/pricing) |

## Core ideas in one minute

**Sandbox.** One microVM with an id like `sb_23456789`, a stable three-word subdomain such as `amber-fjord-lumen`, a size (`small`, `default`, `large`, `xlarge`) and a state.

**States.** A new sandbox goes `provisioning → ready`. While an integrated agent works it shows `running`, then `idle`. A stop moves it through `archiving` to `archived` (stopped). `error` and `cancelled` are the failure states.

**Auto-stop.** Every sandbox has a time-to-live (`ttlSeconds`, one hour by default). When it runs out we stop the sandbox for you, so a forgotten sandbox never runs up a bill. Extend it, or turn it off with `null`.

**Snapshots.** Running sandboxes are snapshotted every ten minutes and at every stop. Named snapshots are templates you save on purpose and start new sandboxes from.

**Environments.** The variables, secret files, repositories and credentials that a new sandbox starts with. Versioned, so changing them never surprises a running sandbox.

**Wallets.** Sandboxes bill your personal account or an organization you belong to. The active wallet decides which.

> **Note** Every page of these docs is also available as plain Markdown for agents: add `.md` to the URL, or start from [/docs/llms.txt](/docs/llms.txt).
