DOCS

The CLI

caas is the isolance command line. Use it to create and run sandboxes, move files in and out of them, take their snapshots, deploy MCP servers, push images, add connectors and manage billing from a terminal or a script. Each command calls one route of the same API as the console (The API), with an API key from your workspace.

Install the CLI

The CLI needs Node 22 or later. Install the @caascade/cli package globally:

shell

npm i -g @caascade/cli

The package isn't on npm yet. Once it's published, this command installs it.

This installs the caas command. To list every command and option, run caas help, or caas on its own. Adding --help to any command does the same.

Some commands use other tools: caas registry login runs Docker, and --from uses Git.

Connect the CLI to your workspace

The CLI doesn't sign in with your email and password. It uses an API key, which belongs to one workspace: every command acts in the workspace of its key. The CLI also keeps that workspace's tenant ID, which names your images in the registry.

Create an API key

Sign in to the console and open Settings.
Under Workspace, copy the Tenant ID.
Under API keys, enter a Key name, such as my laptop. If you're an owner and want to use caas billing, check Billing access.
Choose Create key, then copy the key. It starts with ck_, and the console shows it only once.

Owners and operators can create keys. Viewers can't.

Configure the CLI

Save the tenant ID and key:

shell

caas configure --tenant <tenant-id> --key <api-key>

The CLI saves them in ~/.config/caas/config.json, or in $XDG_CONFIG_HOME/caas/config.json if XDG_CONFIG_HOME is set. Only you can read the file. Every later command uses what you saved. To check that everything works, list your sandboxes:

shell

caas sandboxes list

Running caas configure again replaces the saved tenant ID and key.

What a key can do

A new key can:

list, create, change, start, stop and delete sandboxes, and run commands in them
deploy MCP servers and manage their client tokens
push and pull images in the registry
read connectors and the audit log

A key with Billing access can also read the balance and usage and add funds (caas billing).

A key can never do more than the member who created it. An operator's key can't use caas billing, and only an owner's key can add, change or remove connectors or connect their workspace accounts. If the member who created a key leaves the workspace, the key stops working. To revoke a key, choose Revoke next to it under Settings → API keys.

Choose a workspace

The CLI always works in one workspace: the one its key was created in. A key from one workspace doesn't work in another.

To work in another workspace:

In the console, open the workspace card at the top of the sidebar and switch to that workspace.
Create an API key there, as in Create an API key, and copy that workspace's tenant ID.
Either save the new pair, which replaces the one you saved before:
shell
```
caas configure --tenant <other-tenant-id> --key <other-api-key>
```
Or pass the pair to a single command and keep what you saved:
shell
```
caas sandboxes list --tenant <other-tenant-id> --key <other-api-key>
```

Options for every command

Option	What it does
`--key KEY`	Use this API key, and so its workspace, instead of the saved one.
`--tenant ID`	The workspace's tenant ID for the registry, instead of the saved one. Pass it with `--key` for another workspace.
`--api-url URL`	Use another API address. The default is `https://api.caas.sh`. It must use `https://`, except on `localhost`. `caas configure` saves it.
`--json`	Print the API's JSON response instead of the text output.
`--idempotency-key KEY`	Retry a create, exec or payment without doing it twice: 8 to 128 letters, digits, `_` and `-`.
`--help`	Print every command and option.

caas run, caas sandboxes create, caas sandboxes exec, caas mcp create and caas billing add-funds send their request with an idempotency key. If the CLI can't reach the API, the error names the key. Run the same command again with --idempotency-key KEY to retry without creating a second sandbox, command, server or payment.

Commands that take a sandbox (SANDBOX) accept its ID or its name, and commands that take an MCP server (SERVER) accept its ID or its name.

Exit codes

Code	Meaning
`0`	Success.
`1`	The request or the command failed.
`2`	The command line isn't valid, for example an unknown option, a missing value or a value out of range. Nothing was changed.
`3`	The API or the registry refused the key: it's revoked, from another workspace, or lacks the access the command needs.

caas run and caas sandboxes exec exit with the command's own exit code when it's between 1 and 125, and with 1 for any other failure. Errors are printed to standard error as caas: <message>. When the workspace is out of funds, the error also links to the console page where an owner adds them.

Sizes

--size sets a sandbox's vCPU, memory and disk. The default is m.

Size	`--size`	vCPU	Memory	Disk
XS	`xs`	1/16	256 MiB	2 GB
S	`s`	1/4	1 GiB	4 GB
M	`m`	1/2	4 GiB	8 GB
L	`l`	1	6 GiB	12 GB
XL	`xl`	2	8 GiB	16 GB
2XL	`2xl`	4	12 GiB	20 GB
Custom	`custom`	1 to 4	At least 3 GiB per vCPU, at most 12 GiB	2 to 20 GB

For a custom size, add --vcpu N --memory GIB --disk GB, all whole numbers:

shell

caas sandboxes create --size custom --vcpu 2 --memory 6 --disk 12

A sandbox that runs your own image needs size M or larger. vCPU bills only while the sandbox computes; memory and disk bill while it runs. See pricing for the rates.

Sandbox options

caas sandboxes create, caas run and caas mcp create set up a new sandbox with these options, one for each of its fields. caas sandboxes update takes them too (but --name, --workdir, --user and --provider, which can't change). A list option replaces the whole list: repeat it for each item.

Option	Field	What it does
`--name NAME`	`name`	Names the sandbox: a lowercase letter, then up to 49 lowercase letters, digits and hyphens, unique in your workspace. Without it, the sandbox is named `sbx-` and part of its ID.
`--image IMAGE`	`image`	Runs your own image from the registry; see Push images to the registry. Without it, the Default image: Alpine Linux with bash, coreutils, Node and Docker.
`--command "COMMAND"`	`command`	What the sandbox itself runs, a quoted command line. Without it, its image's own entrypoint and command; the Default image has none, and waits for the commands you run in it.
`--env NAME=VALUE`	`env`	Sets a variable, up to 64.
`--workdir DIR`	`workdir`	Its working directory, `/workspace` by default.
`--size SIZE`	`size`	Its size; see Sizes.
`--volume PATH`	`volumes`	A directory it keeps between stops and restarts and in its snapshots, up to 8. Without it, `/workspace`.
`--port N[:public]`	`ports`	A port it serves: 1024 to 65535, at its provider's own URL where the provider gives one. `3000:public` sets the port's `public`, which opens nothing in isolance. Up to 16. See Port URLs.
`--egress HOST`	`egress`	A host it may reach, or `.example.com` for the names under example.com (list `example.com` as well if the sandbox calls it), up to 32; other hosts are blocked. `--egress ''` allows every host, as a sandbox does without the option. A command that starts with `npx` also gets `registry.npmjs.org`, unless a listed host covers it.
`--idle-stop MINUTES`	`idleStopMinutes`	Stops it after this many minutes with no command, file transfer or MCP request: 5 to 240. The default is 15.
`--label KEY=VALUE`	`labels`	Sets a label, up to 16. A connector reaches the sandboxes whose labels its `--reach` matches; see Connectors.
`--user USER`	`user`	Starts it for one of your users, by your ID for them: it gets their connections. Where it needs a sign-in they make with a code, such as Codex (ChatGPT)'s, `caas sandboxes create` prints their code when they haven't signed in; see Your users.
`--provider PROVIDER`	`provider`	Where it runs: `auto`, the default (isolance places it), or a provider such as `cloudflare` (Native).

caas sandboxes update also takes --no-command, --no-env, --no-volumes, --no-ports, --no-egress and --no-labels, which empty a field. --no-volumes works on create too: the sandbox keeps nothing between restarts and takes no snapshots of its own.

Run a command in a new sandbox

caas run is the shortcut: it creates a sandbox, waits until it runs, runs one command in it, waits for the command to end, and prints its output:

shell

caas run -- node --version
caas run --from . -- npm test
caas run --name build-agent --size xl --from . -- node task.js
caas run --image worker:latest -- python task.py
caas run --from . --detach -- node long-task.js
caas run --egress api.example.com --no-volumes -- node --version
caas run --label team=ci -- git clone https://github.com/acme/private-repo
caas run --from . --port 3000:public --detach -- node server.js

The command runs as an executable with its arguments, not through a shell. To use shell features, run a shell:

shell

caas run --from . -- sh -c 'node build.js && node test.js'

Options come before --, and everything after -- is the command. caas run takes the sandbox options, and:

Option	What it does
`--from DIR`	Puts your code in the sandbox's working directory before the command runs. See Upload your code. Can't be combined with `--image` or `--no-volumes`.
`--timeout SECONDS`	The command's time limit: 1 to 7200, or 1 to 86400 with `--detach`. The default is two hours.
`--detach`	Returns as soon as the command starts, with its exec ID.

When caas run is done, the sandbox keeps running until its idle stop. Delete it with caas sandboxes delete when you no longer need it. With --detach, check on the command later with caas sandboxes exec <sandbox> <exec-id>.

Upload your code

--from DIR uploads the committed Git tree of the repository at DIR, usually .. caas run, caas sandboxes create and caas sandboxes files put unpack it into the sandbox once it runs.

DIR must be the root of a Git repository with at least one commit.
Commit your changes first. The CLI refuses a repository with uncommitted changes or untracked files. Files that Git ignores are never uploaded.
The CLI refuses to upload a repository that tracks a sensitive-looking file: .env files, .dev.vars, .npmrc, id_rsa, credentials, or any .pem or .key file.
The compressed upload can be at most 100 MiB.

Manage sandboxes

Each caas sandboxes command calls one route of the API; SANDBOX is a sandbox's ID or name.

Command	What it does
`caas sandboxes create [OPTIONS] [--from DIR]`	Creates a sandbox with the sandbox options and prints it. With `--from`, waits until it runs and puts your code in its working directory.
`caas sandboxes list`	Lists the sandboxes, newest first: each one's ID, name, state, size and image. `--label KEY=VALUE` (repeat it to match several) and `--provider` filter them; `--limit` sets the page size, 1 to 100. If there are more, the CLI prints a `--cursor` for the next page. A sandbox that runs an MCP server has the label `caas.sh/mcp-server`.
`caas sandboxes get SANDBOX`	Shows the sandbox: its fields, its state and why it stopped, its provider's ID, its URLs, and its usage, including what it costs per hour now and what it has cost today.
`caas sandboxes update SANDBOX [OPTIONS]`	Replaces each field you give, and says what waits for its next start.
`caas sandboxes start	stop
`caas sandboxes delete SANDBOX`	Deletes it, with its volumes and snapshots.
`caas sandboxes logs SANDBOX`	Prints its newest log entries, oldest first: what isolance recorded (`system`) and what its command wrote (`stdout` and `stderr`). `--since TIME` starts at a time; `--follow` keeps printing new entries until the sandbox is gone.

shell

caas sandboxes create --name web --image web:1 --port 3000:public --volume /data --env MODE=production
caas sandboxes update web --egress api.github.com --label team=web --idle-stop 60
caas sandboxes update web --size xl
caas sandboxes restart web
caas sandboxes logs web --follow

A running sandbox takes new variables, ports, hosts, its idle stop and labels at once. A new image, command, size or volumes, the connectors its labels pick, and a change between every host and a list of hosts wait for its next start: the CLI says which, and caas sandboxes restart applies them.

Run commands in a sandbox

shell

caas sandboxes exec <sandbox> -- node --version
caas sandboxes exec <sandbox> --env NODE_ENV=test --workdir /workspace/app -- npm test
echo hello | caas sandboxes exec <sandbox> --stdin -- cat
caas sandboxes exec <sandbox> --timeout 7200 --detach -- node long-task.js
caas sandboxes exec <sandbox> <exec-id>
caas sandboxes exec <sandbox> <exec-id> --cancel

With a command after --, exec runs it, waits for it, prints its output and exits with its exit code. With an exec ID instead, it shows that command's state, exit code and output, or cancels it with --cancel.

Option	What it does
`--env NAME=VALUE`	Sets a variable for this command, over the sandbox's.
`--workdir DIR`	Runs it in this directory; the sandbox's working directory by default.
`--stdin`	Sends standard input to the command, up to 64 KiB.
`--timeout SECONDS`	The command's time limit: 1 to 7200 seconds (two hours), or up to 86400 with `--detach`. The default is 600 (10 minutes).
`--detach`	Prints the command's exec ID and returns without waiting.

As with caas run, the command runs without a shell. A command sent to a sandbox that stopped while idle starts it again. The exec ID is the command's idempotency key, so --idempotency-key names it.

Files

shell

caas sandboxes files put <sandbox> /workspace/config.json config.json
caas sandboxes files put <sandbox> /workspace/site site.tar.gz --extract
caas sandboxes files put <sandbox> /workspace --from .
caas sandboxes files get <sandbox> /workspace/config.json > config.json
caas sandboxes files get <sandbox> /workspace/build.log --tail 4096
caas sandboxes files get <sandbox> /workspace
caas sandboxes files delete <sandbox> /workspace/tmp --recursive

Command	What it does
`caas sandboxes files get SANDBOX PATH`	Prints a file's bytes, or lists a directory: each entry's type, size and name. `--tail BYTES` prints only a file's last bytes.
`caas sandboxes files put SANDBOX PATH [FILE]`	Writes `FILE` (standard input without it, or with `-`) as the file at `PATH`, up to 100 MiB, creating its directories. With `--extract`, `FILE` is a `.tar.gz` unpacked into the directory `PATH`. With `--from DIR`, your Git repository's committed files are unpacked there.
`caas sandboxes files delete SANDBOX PATH`	Deletes a file, or a directory with `--recursive`.

PATH is absolute. A transfer starts a sandbox that stopped while idle.

Snapshots

A snapshot is a copy of a sandbox's volumes you take yourself.

shell

caas sandboxes snapshots create <sandbox> --name before-upgrade
caas sandboxes snapshots list <sandbox>
caas sandboxes stop <sandbox>
caas sandboxes snapshots restore <sandbox> before-upgrade
caas sandboxes snapshots delete <sandbox> <snapshot-id>

Command	What it does
`caas sandboxes snapshots create SANDBOX [--name NAME]`	Takes a snapshot of a running sandbox. Without `--name`, it's named `manual`. Names follow the same rules as sandbox names.
`caas sandboxes snapshots list SANDBOX`	Lists the snapshots: ID, name, kind, when each was taken, its size and which one is current. Then the bytes stored.
`caas sandboxes snapshots restore SANDBOX SNAPSHOT`	Restores a snapshot, by its ID or a manual snapshot's name, onto a stopped or failed sandbox and starts it. Stop the sandbox first.
`caas sandboxes snapshots delete SANDBOX SNAPSHOT_ID`	Deletes a snapshot.

Snapshots stay until you delete them. See Sandboxes for how snapshots work.

Port URLs

A sandbox serves the ports you list with --port, at its provider's own URLs: while it runs, caas sandboxes get shows the URL the provider gives each port, where it gives one. Who can open a URL is up to the provider; isolance serves none itself. See URLs.

shell

caas sandboxes update <sandbox> --port 3000 --port 9229
caas sandboxes update <sandbox> --no-ports

The sandbox's processes get the first port in PORT (8080 without any).

MCP servers

caas mcp create puts an MCP server online at its own endpoint, https://mcp.caa.sh/<server-id>. The server runs in a sandbox, a new one or one you have, which caas sandboxes manages like any other, and serves MCP over Streamable HTTP on a port of it:

shell

caas mcp create --image server:1.2.3 --http 3000
caas mcp create --image server:1.2.3 --http 3000 --command "node http.js"
caas mcp create --sandbox build-agent --http 3000 --name build-tools

Option	What it does
`--name NAME`	The server's name, unique in the workspace: up to 63 lowercase letters, digits and hyphens. When it's also a free sandbox name, it names a new sandbox too. Without it, the server is named `mcp-` and 12 hex digits.
`--image IMAGE`	Runs your own image from the registry, or `default`, in a new sandbox. Without `--command`, the image's own entrypoint and command run.
`--command "COMMAND"`	With `--image`: the command that starts the server.
`--http PORT`	The port the server serves Streamable HTTP on, 1024 to 65535.
`--path PATH`	With `--http`: the path it serves MCP at, `/mcp` by default.
`--sandbox SANDBOX`	Adds the server to an existing sandbox, which runs it itself.

--command takes a quoted command line. The CLI splits it into words like a shell does, with quotes and backslashes, but doesn't run it through a shell. A new sandbox takes the sandbox options (but --name and --command, which are the server's).

The CLI prints the server's endpoint, its sandbox, and a first client token that can call every tool and doesn't expire. The token is shown only once. Clients send a token as an Authorization: Bearer header. A retry with the same --idempotency-key doesn't print the token again; create a new one with caas mcp tokens create.

Command	What it does
`caas mcp list`	Lists the servers: ID, name, state, sandbox and endpoint.
`caas mcp get SERVER`	Shows a server: its endpoint, sandbox, transport, state and its gateway's last 24 hours.
`caas mcp update SERVER`	Renames it (`--name`) or changes its port and path (`--http PORT` with `--path`).
`caas mcp traces SERVER`	Prints its newest 100 requests: time, status, tool, client, duration and why one was blocked.
`caas mcp stats SERVER`	Prints its gateway's last 24 hours: requests, blocked, errors, timeouts and median latency.
`caas mcp delete SERVER`	Deletes the server, its tokens and traces, and the sandbox it was created with; `--keep-sandbox` keeps that sandbox.

Create from a file

caas mcp create -f FILE (or --file FILE) creates a server declared in a YAML or JSON file, the same format the console's Deploy from a server file page takes:

yaml

server: search-mcp
source:
  image: search-mcp:1
  port: 8080
size: m
state:
  persistent: true
idle: stop after 30m
tokens:
  - name: laptop-claude
    tools: [search.query, search.fetch]
  - name: ci-pipeline
    tools: [search.query]
    expires: 30d
egress: [api.search.example.com]

shell

caas mcp create -f search-mcp.yaml

The CLI checks the whole file before it creates anything, creates the server and its tokens in one request, and prints the endpoint and each token's tools, expiry and secret once. The file declares the server and its sandbox's image, size, state, idle stop and hosts, so options for those can't be combined with -f; --env and --label can. A server's sandbox gets keys through a connector whose Reaches picks it (caas.sh/mcp-server=<server ID>, or a label of your own). A file without egress lets the server reach every host; a file with it reaches only the hosts it lists. See MCP servers for every field.

Client tokens

shell

caas mcp tokens list <server>
caas mcp tokens create <server> --name "Claude Desktop"
caas mcp tokens create <server> --name ci --expires-days 30 --allow-tool search.query
caas mcp tokens revoke <server> <token-id>

Command	What it does
`caas mcp tokens list SERVER`	Lists the server's client tokens: ID, name, whether each is active, revoked or expired, the tools it may call, and its calls and errors.
`caas mcp tokens create SERVER --name LABEL`	Creates a token and prints its secret once.
`caas mcp tokens revoke SERVER TOKEN_ID`	Revokes a token. The server keeps running.

create takes these options:

Option	What it does
`--name LABEL`	Required. A label for the client that uses the token.
`--expires-days DAYS`	When the token expires: 1 to 365 days. The default is 90.
`--allow-tool NAME`	Let the token call only this tool. Repeat it for each tool. Without it, the token can call every tool.

Push images to the registry

Your workspace has its own namespace in the isolance registry, registry.caas.sh/<tenant-id>/. Log Docker in with your saved key, then build and push a linux/amd64 image:

shell

caas registry login
docker build --platform linux/amd64 -t registry.caas.sh/<tenant-id>/server:1.2.3 .
docker push registry.caas.sh/<tenant-id>/server:1.2.3
caas mcp create --image server:1.2.3

caas registry login runs docker login registry.caas.sh, with your tenant ID as the username and your API key as the password. New keys can push and pull.

Wherever a command takes --image, you can write the image as NAME[:TAG] or NAME@sha256:DIGEST, optionally under registry.caas.sh/ or registry.caas.sh/<tenant-id>/. The CLI looks a tag up in the registry (latest when you give none) and always deploys its digest. Images from other registries or other workspaces are refused: push them to your namespace first. See Images and the registry.

Connectors

isolance keeps your API keys and tokens out of your sandboxes. A connector is a service your sandboxes reach: a tool of the catalog, an MCP server, or an API by its hosts. isolance adds its key to a sandbox's HTTPS requests to its hosts, and inside the sandbox its variables, such as GITHUB_TOKEN, hold only a placeholder. A sandbox started without a user gets your workspace's account; one started for a user gets only that user's. See Connectors for how it all fits together.

Only an owner's key can add, change or remove connectors and connect their workspace accounts. Sign-ins finish in the console.

shell

caas connectors catalog
caas connectors add anthropic
caas connectors account anthropic --api-key < anthropic-key.txt
caas connectors add github --reach team=ci
caas connectors account github --sign-in
caas connectors add --api --host registry.npmjs.org --id npm --env NPM_TOKEN
caas connectors account npm --api-key < npm-token.txt
caas connectors list
caas connectors get github
caas connectors remove npm

Command	What it does
`caas connectors catalog`	Lists the catalog's tools, and whether each is available or added.
`caas connectors list`	Lists your connectors: whom each reaches, its workspace account's status and how many users connected, and how to reconnect any that need it.
`caas connectors get ID`	Shows one connector, its hosts and its variables.
`caas connectors add CATALOG_ID`	Adds a tool of the catalog, such as `github`, `linear`, `anthropic` or `openai`.
`caas connectors add --mcp URL`	Adds an MCP server by its address. `--keys` when its accounts connect with a key.
`caas connectors add --api --host HOST`	Adds an API by its hosts; repeat `--host` for each, up to 16. See the options below.
`caas connectors update ID`	Changes its `--name`, its `--reach` (or `--reach-all`) and its `--env` (or `--no-env`).
`caas connectors account ID METHOD`	Connects its workspace account. See the methods below.
`caas connectors account ID --disconnect`	Disconnects its workspace account.
`caas connectors remove ID`	Removes it, with its workspace account and every user's connection.

add also takes --id ID, --name NAME, --env VAR (one more variable that holds the placeholder) and --reach KEY=VALUE, repeated for each label a sandbox must have to get the connector (every sandbox without it; caas.sh/user=ID picks one user's sandboxes).

Option	What it does
`--host HOST`	With `--api`: a host the key is sent to; `*.example.com` covers `example.com` and every name under it.
`--header NAME`	With `--host`: the request header to set. The default is `authorization`.
`--scheme SCHEME`	With `--host`: `bearer` (the default), `basic` or `raw` (the value as is).
`--username USER`	With `--scheme basic`: the username. Required for `basic`.

account takes exactly one method, among those the connector takes:

Method	What it does
`--api-key`	Reads the key from standard input. The CLI never takes a key as an option.
`--sign-in`	Signs in on the tool's page (GitHub through isolance's GitHub App).
`--install`	For GitHub with your own GitHub App: installs it on the account it acts for.
`--device`	For Codex: prints a code and OpenAI's page to enter it on.

A sign-in or install prints a page to open. It returns to the connector's page in the console, which finishes it while you're signed in there as the owner who started it. The CLI waits until the account is connected; --detach returns at once instead.

Your own app

shell

caas connectors app example --preset google --client-id 1234.apps.googleusercontent.com \
  --scope https://www.googleapis.com/auth/drive.readonly < client-secret.txt
caas connectors app example --remove
caas connectors github-app github --client-id Iv1.0123abcd --slug acme-bot < private-key.pem
caas connectors github-app github --remove

caas connectors app has an MCP server's or an API's accounts sign in through your own OAuth app; on an API it's allowed only while the connector has no accounts. caas connectors github-app lets GitHub's workspace account install your own GitHub App. The client secret or private key is read from standard input.

Option	What it does
`--client-id ID`	The app's client ID. For a GitHub App, its Client ID.
`--scope SCOPE`	Each scope to ask for. Required for an API's app.
`--preset PRESET`	For an API: `google`, `gitlab` or `linear`, which fills in the provider's endpoints.
`--authorize-url URL`, `--token-url URL`	For an API with no preset: the provider's endpoints, `https://` URLs on a public host.
`--token-auth METHOD`	With those endpoints: how the token endpoint takes the client secret, `post` (the default) or `basic`.
`--slug SLUG`	With `github-app`: the app's slug, as in `github.com/apps/<slug>`.

Set the app's redirect URI (for a GitHub App, its callback and setup URL) to https://api.caas.sh/v1/credential-interactions/callback.

Your users

caas users manages your users' connections one user at a time (see Connect each user's account); USER is your ID for the user. Codex (ChatGPT)'s users sign in with a code, which caas users sign-in gets them:

shell

caas users sign-in user_123
caas users link user_123 --connector linear --return-url https://app.acme.com/settings
caas users get user_123
caas users disconnect user_123 --connector linear

Command	What it does
`caas users sign-in USER`	Prints the user's code for Codex (ChatGPT) and OpenAI's sign-in page to enter it on, the same code while one still works, then waits until they're signed in; `--detach` returns at once. For a user who's signed in, it signs them in again: their sign-in keeps working until they enter the new code. `--connector ID` names the connector, your Codex (ChatGPT) one by default.
`caas users link USER --connector ID`	Makes a connect link for one connector, with `--return-url URL` to send them back to.
`caas users get USER`	Shows each of the user's connections with its status, and a code under way with until when it works (the code itself only to a key with `sandbox:write`).
`caas users disconnect USER --connector ID`	Disconnects the user from one connector. Their sandboxes' requests to it are refused from the next one.

caas sandboxes create --user USER prints the user's code when a sandbox of theirs needs a sign-in they haven't made (see Sign users in with a code).

Logins

caas logins manages the Logins connector's logins: a user's with --user USER, else your workspace's (see Logins). LOGIN is a login's ID, or its site where there's one login there.

shell

caas logins add --user user_123 --site github.com --username ana@acme.com --methods passkey,typed --password-stdin < password.txt
caas logins link --site github.com --user user_123 --return-url https://app.acme.com/settings
caas logins list --user user_123
caas logins check github.com --user user_123

Command	What it does
`caas logins list`	Lists the logins: site, account, how each signs in, which browser, passkeys and saved sign-in. `--site SITE` for the logins that cover a site; `--limit` and `--cursor` page through them.
`caas logins get LOGIN`	Shows one login.
`caas logins add --site SITE`	Adds a login. See the options below.
`caas logins update LOGIN`	Changes what you name, with the options of `add` but `--site`; `--no-password`, `--no-code` and `--no-deliver` remove them. A new account name, password or setup key needs every secret the login keeps piped again, as isolance keeps no copy.
`caas logins remove LOGIN`	Removes it, its passkeys and its saved sign-in. The site still lists its passkeys until you remove them there.
`caas logins passkeys LOGIN`	Lists its passkeys; `rename PASSKEY --name LABEL` and `remove PASSKEY` change one.
`caas logins session LOGIN`	Shows its saved sign-in; `upload FILE` uploads Playwright's storage state (`-` for standard input), not for a Browserbase login, and `remove` marks it signed out (on Browserbase, the user's next Browserbase browser starts signed out of every site).
`caas logins live LOGIN`	Opens a browser at its sign-in page and prints its live view: sign in there, then press Enter to save the sign-in, or Ctrl-C to cancel and save nothing. Whoever has its address controls that browser until then.
`caas logins check LOGIN`	Opens a browser to see whether the site still has them signed in, such as "user_123 is signed in to github.com", and exits with status 1 when not.
`caas logins link LOGIN --user USER`	Makes a link for a user to sign in themselves, with `--return-url URL`; `--site SITE` in place of `LOGIN` makes the login too.

Option	What it does
`--username NAME`	The account name, as the site shows it.
`--methods LIST`	How isolance signs in, in order: `passkey`, `typed` or `readable`, such as `passkey,typed`.
`--browser BROWSER`	`native` (isolance's own browsers, the default) or `browserbase`.
`--password-stdin`, `--code-stdin`	Read the password, or the authenticator setup key, from standard input; with both, the password then the setup key on the next line. The CLI never takes a secret as an option.
`--signer SIGNER`	Who signs with its passkeys: `caas` (the default) or `browser`.
`--creators LIST`	Who may make a passkey: any of `user` (your user, by link), `platform` (your team) and `agent` (the AI), or `none`.
`--deliver HOST:HEADER:VALUE`	Adds its `password`, `username` or `code` to a header of its sandboxes' requests to the host, such as `registry.npmjs.org:npm-otp:code`; add `:bearer` or `:basic` after the value for those schemes. Repeat it for each.

It prints sentences and tables, never a secret: "Added github.com for user_123. user_123's sandboxes sign in with a passkey, then the password." Browsers that live and check open count as browser time.

Providers

A sandbox runs on Native, isolance's own runtime, or on a provider of your own account, such as Daytona or E2B, once an owner connects its key. That provider bills you directly for what runs there. Only an owner's key can connect or remove a provider's key.

shell

caas providers list
caas providers key set e2b --api-key < e2b-key.txt
caas providers key set e2b --api-key --domain e2b.app < e2b-key.txt
caas providers get e2b
caas providers key remove e2b

Command	What it does
`caas providers list`	Lists the providers, whether each can take a sandbox now, and whether it runs on your key.
`caas providers get ID`	Shows one provider, and where its key stands.
`caas providers key set ID --api-key`	Connects your key of the provider, read from standard input. The provider checks it before sandboxes run there.
`caas providers key remove ID`	Stops your sandboxes on that provider and removes the key.

key set also takes the provider's other fields, each optional:

Option	What it does
`--domain DOMAIN`	For E2B: the domain of the region your project is in. Without it, `e2b.app`.
`--provider-api-url URL`	For Daytona: its API's `https://` URL.
`--target TARGET`	For Daytona: its target region, such as `us`.

Billing

caas billing needs a key with Billing access, which only an owner can create.

shell

caas billing balance
caas billing add-funds 25
caas billing auto-recharge show
caas billing auto-recharge set --below 10 --recharge-to 50
caas billing auto-recharge set --off
caas billing usage
caas billing usage --month 2026-09
caas billing usage --csv > caas-usage.csv

Command	What it does
`caas billing balance`	Prints the balance, the auto-recharge setting and recent top-ups with their receipts.
`caas billing add-funds AMOUNT`	Adds funds: $5 to $2,000 of credits, written as `25`, `25.50`, `$25.50` or `1,000`. It charges the card on file, or prints a Stripe Checkout link to pay and save a card.
`caas billing auto-recharge show`	Prints the auto-recharge setting.
`caas billing auto-recharge set`	Turns auto-recharge on, changing only the amounts you give. With `--off`, turns it off.
`caas billing usage`	Prints a month's spend: the total so far, the projection and today while the month is current, the amount for each meter, and the spend alert.

Option	What it does
`--below AMOUNT`	With `auto-recharge set`: recharge when the balance falls below this, $5 to $1,000. It's $10 until you change it.
`--recharge-to AMOUNT`	With `auto-recharge set`: buy credits back up to this, at least $5 above `--below` and at most $2,000, charging the card for them. It's $50 until you change it.
`--off`	With `auto-recharge set`: turn auto-recharge off. You get an email when the balance falls below the amount instead.
`--month YYYY-MM`	With `usage`: the month to show. The default is this month.
`--csv`	With `usage`: print the month as CSV, one row per UTC day and meter, with the columns `day,meter,quantity,unit,rate_usd,amount_usd`. The amounts add up exactly to the month's total. Can't be combined with `--json`.

Auto-recharge starts off, so adding funds never charges your card again on its own. Sandboxes run only while the balance is above $0. See Billing and usage.

Workspace settings and the audit log

shell

caas settings
caas settings --time-zone Europe/Berlin
caas audit
caas audit --action sandbox --since 2026-10-01
caas audit --action sandbox.stop --outcome failure --limit 20

caas settings prints the workspace's time zone, its one setting. --time-zone ZONE sets it, an IANA name such as Europe/Berlin.

caas audit lists who changed what in the workspace, newest first: the time, who did it, the action, its target, the outcome and the request ID. Records are kept for 365 days.

Option	What it does
`--action ACTION`	An action, such as `sandbox.stop` or `api_key.create`, or a group: `sandbox`, `command`, `mcp_server`, `mcp_token`, `connector`, `workspace_account`, `connection`, `end_user`, `login`, `passkey`, `provider`, `api_key`, `member`, `invite`, `tenant` or `billing`.
`--actor ID`	A user or API key ID, a sandbox's ID, one of your users' IDs, or `operator` or `system`.
`--target ID`	The ID of what was changed.
`--outcome OUTCOME`	`success` or `failure`.
`--since TIME`, `--until TIME`	ISO 8601 times, such as `2026-10-01` or `2026-10-01T12:00:00Z`.
`--limit N`	Records per page, 1 to 100.
`--cursor CURSOR`	The next page: the value the previous page printed.

An API key never sees records about API keys, members or invites, and sees billing records only with Billing access. In what a key reads, users show as their user ID rather than their email.