# Quickstart

Four steps, a few minutes, with the [CLI](/docs/cli). Rather use `curl`? [With curl and an API key](#with-curl-and-an-api-key)
does the same over the [API](/docs/api).

## 1. Sign up

Create an account at [raw.computer/sign-up](https://raw.computer/sign-up) and verify your email. You get an **org**
(it holds the wallet) with one **workspace** called `default` (it holds keys and sandboxes). See
[Concepts](/docs/concepts) for how the two relate.

## 2. Install the CLI and sign in

```sh
curl -fsSL https://raw.computer/install.sh | sh
raw login
```

`raw login` shows a code and opens the console, where you check the code and approve it. The CLI keeps a personal
token that acts as you, in your workspaces, and keeps itself up to date.

## 3. Check who you are

```sh
raw whoami
```

```text
Person     ada <ada@example.com> (usr_DEMJ4NCDUxm2h7orD6T6WkB16m74Tvx8)
Token      raw CLI on laptop (key_01m6xxge1kf83t1tk6pss3awgm, personal; stored by raw login)
Workspace  default · Default (ws_01m6xxgde9f2c9q3y3gn9e8zdp) as admin
Org        ada (org_01m6xxgde9eaer8hxj9q8kx58d)
API        https://raw.computer (version 2026-11-08)
```

Add `--json` to any command for the API's own JSON (here, the answer of `GET /v1/me`).

## 4. Create a sandbox

```sh
raw sandboxes create --class std --size 4x8
```

During early access no cell is open to customers, so this is the answer you get today:

```text
raw: No cell serves std yet: raw.computer is in early access. [capacity_unavailable]
  next: Read the early-access note; sandbox creates open when the first cell does.
  see:  https://raw.computer/docs/limits#early-access
  docs: https://raw.computer/docs/errors#capacity_unavailable
```

It is honest on purpose: a request that no cell can serve is refused rather than queued, so nothing waits for capacity
that does not exist, and the CLI exits `1`. Once cells open, the same command starts a sandbox, or queues it with its
position and ETA ([Concepts › The queue](/docs/concepts#the-queue)).

## With curl and an API key

In the console, open **API keys**, give the key a name and choose **Create key**. The key starts with `rc_live_` and is
shown once; only its hash is kept. A key acts in one workspace, as `developer` (reads and writes, the default) or
`viewer` (reads), and never at org level. Keep it in an environment variable:

```sh
export RAW_API_KEY="rc_live_…"
```

Check who you are:

```sh
curl https://raw.computer/v1/me \
  -H "Authorization: Bearer $RAW_API_KEY" \
  -H "Raw-Version: 2026-11-08"
```

```json
{
	"object": "me",
	"user": {
		"object": "user",
		"id": "usr_DEMJ4NCDUxm2h7orD6T6WkB16m74Tvx8",
		"name": "ada",
		"email": "ada@example.com"
	},
	"api_key": {
		"object": "api_key",
		"id": "key_01m6xxge1kf83t1tk6pss3awgm",
		"name": "laptop",
		"kind": "workspace",
		"relation": "developer"
	},
	"workspace": {
		"object": "workspace",
		"id": "ws_01m6xxgde9f2c9q3y3gn9e8zdp",
		"code": "default",
		"name": "Default",
		"org": { "object": "org", "id": "org_01m6xxgde9eaer8hxj9q8kx58d", "name": "ada" },
		"relation": "developer"
	},
	"raw_version": "2026-11-08"
}
```

`Raw-Version` pins the API version your code was written against. Leave it out and the request is answered in the
version your key is pinned to: the one that was current on the day you made the key. See
[API › Versions](/docs/api#versions).

Create a sandbox:

```sh
curl https://raw.computer/v1/sandboxes \
  -H "Authorization: Bearer $RAW_API_KEY" \
  -H "Raw-Version: 2026-11-08" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{ "class": "std", "size": "4x8" }'
```

```http
HTTP/1.1 503 Service Unavailable
Content-Type: application/json; charset=utf-8
Raw-Version: 2026-11-08

{
  "error": {
    "code": "capacity_unavailable",
    "message": "No cell serves std yet: raw.computer is in early access.",
    "next_step": {
      "message": "Read the early-access note; sandbox creates open when the first cell does.",
      "url": "https://raw.computer/docs/limits#early-access"
    },
    "docs": "https://raw.computer/docs/errors#capacity_unavailable"
  }
}
```

An error never holds on to its `Idempotency-Key`, so the same request can be sent again later. Once cells open, the
same call answers `201` with the sandbox starting, or `202` with it `queued` and its position and ETA.

The CLI takes the same key: `RAW_API_KEY=rc_live_… raw sandboxes list`.

## Next

- [CLI](/docs/cli): every command, `--json`, and using it in CI.
- [Agents](/docs/agents): `raw agent setup` gives Claude Code, Codex and Cursor the skill and the MCP tools.
- [Concepts](/docs/concepts): orgs, workspaces, sandboxes and the queue.
- [API](/docs/api): every endpoint, idempotency and money.
- [Errors](/docs/errors): every code and its next step.