# Quickstart

Get a running session in under a minute. You need an API key from the [Chaser dashboard](https://chaser.sh/dashboard).

## Download the CLI

```bash
curl -fsSL https://get.chaser.sh | sh
```

Or install via npm:

```bash
npm i -g @chaser.sh/cli
chaser --version
```

## Login

```bash
chaser login
```

## Use the CLI

Install the CLI and work interactively:

```bash
# Create a sandbox and get the session ID
SID="$(chaser sandbox --ephemeral --json | jq -r '.id')"

# Open an interactive shell
chaser shell "$SID"

# Or run a one-shot command
chaser shell "$SID" -c "ls -la"
```

## Add persistence with workspaces

Create a named workspace so your files survive across sessions:

```bash
# Create a workspace
chaser workspaces create --session-type sandbox --name my-project --json

# Create a session attached to it
chaser sandbox --workspace my-project --json

# Run commands against it -- Chaser reuses the existing session
curl -sS "$CHASER_API_URL/v1/exec" \
  -H "Authorization: Bearer $CHASER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"workspace": "my-project", "command": "pwd && ls /workspace"}' | jq
```
  
## Using the REST API

```bash
export CHASER_API_URL="https://api.chaser.sh"
export CHASER_API_KEY="sk_your_key_here"
```

## Create a browser session

Spin up an ephemeral Chromium instance and connect with Playwright:

```bash
curl -sS "$CHASER_API_URL/v1/sessions" \
  -H "Authorization: Bearer $CHASER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"session_type": "browser", "ephemeral": true}' | jq
```

The response includes a `endpoints.control` URL. Connect to it with any CDP client:

```typescript
import { chromium } from "playwright";

const browser = await chromium.connectOverCDP("https://<session_id>.chaser.sh/");
const page = await browser.newPage();
await page.goto("https://example.com");
console.log(await page.title());
await browser.close();
```

## Create a sandbox session

Spin up a Linux environment and run a command:

```bash
curl -sS "$CHASER_API_URL/v1/exec" \
  -H "Authorization: Bearer $CHASER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ephemeral": true,
    "command": "uname -a && python3 --version"
  }' | jq
```

This auto-provisions a sandbox, runs the command, and returns the output. No session management required.

## Use MCP tools

For AI agent integration, use the MCP endpoint with the high-level `terminal` and `browser` tools:

```bash
curl -sS "$CHASER_API_URL/v1/mcp" \
  -H "Authorization: Bearer $CHASER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "terminal",
      "arguments": {
        "workspace": "my-project",
        "command": "echo hello from MCP"
      }
    }
  }' | jq
```

## Install local MCP server entries for agents

Keep credentials in environment variables (no secrets written to config files):

```bash
export CHASER_API_KEY=\"sk_your_key_here\"
export CHASER_API_URL=\"https://api.chaser.sh\"
```

Install MCP configuration for Codex, Claude Code, and OpenCode in one step:

```bash
chaser mcp install --agent all
```

You can also run the stdio bridge directly with npm:

```bash
npx chaser-mcp --help
```

## What to read next

- [Core Concepts](/docs/overview/core-concepts) -- understand the session and workspace model
- [Browser Sessions](/docs/sessions/browser-sessions) -- CDP automation details
- [Sandbox Sessions](/docs/sessions/sandbox-sessions) -- shell, exec, and file access
- [CLI Reference](/docs/developer-tools/cli-reference) -- full command documentation