Quickstart

Get up and running with Sandbox Platform in just a few steps.

1. Get your API Key

Navigate to the Dashboard and copy your API key from the settings page.

2. Create a Sandbox

Use the API to create a new sandbox environment:

curl -X POST https://sandbox.dev.ab0t.com/api/sandboxes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-first-sandbox",
    "instance_type": "ab0t.medium",
    "docker_image": "ubuntu:latest"
  }'

3. Execute Commands

Once your sandbox is running, execute commands via the API:

curl -X POST https://sandbox.dev.ab0t.com/api/sandboxes/{sandbox_id}/execute \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"command": "echo Hello, World!"}'

Authentication

All API requests require authentication using a Bearer token. Include your API key in the Authorization header:

Authorization: Bearer YOUR_API_KEY

API Reference

The Sandbox Platform API is organized around REST. Our API accepts JSON-encoded request bodies and returns JSON-encoded responses. Sandbox create requests accept either branded tiers like ab0t.medium or canonical runtime types like t3.medium. Responses return both instance_type (canonical runtime value) and instance_tier (branded product value).

Base URL

https://sandbox.dev.ab0t.com

Sandbox Endpoints

Command Execution

File Operations

Cost Management

Sandboxes

A sandbox is a persistent Linux environment running on dedicated cloud compute. Unlike ephemeral containers, sandboxes survive reboots and have full root access, persistent storage, and dedicated networking.

Lifecycle

Sandboxes move through these states:

Auto-stop

Sandboxes with auto_stop_minutes set will automatically stop after the specified idle time. Idle = no API calls or SSH sessions. Set to 0 to disable.

Instance Types

Choose the right instance type based on your workload:

Networking

Each sandbox gets a public IP and a DNS entry under your org's domain. Access is controlled via:

• SSH — Direct SSH access using your uploaded keys or short-lived certificates
• Manager API — HTTP API on port 1337 for command execution, file operations, and status
• Proxy — Web-accessible ports routed through the platform proxy with auth

Persistent Storage

Sandbox storage persists across stop/start cycles. The root EBS volume is preserved when you stop a sandbox. Files are only deleted when the sandbox is terminated.

Use POST /api/sandboxes/{id}/upload to upload files and GET /api/sandboxes/{id}/download to download the workspace as an archive.

Containers

Containers are lightweight, ephemeral environments running in the cloud. They start in seconds and are ideal for short-lived tasks. Three types are available:

Browsers

Headless or visible browsers for web automation, scraping, and testing.

curl -X POST https://sandbox.dev.ab0t.com/api/browsers \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"browser_type": "chrome"}'

Available types: firefox, chrome, chromium-headless, selenium-chrome, headless-shell, lightpanda

Desktops

Full Linux desktops with GUI access via the browser. Useful for visual tasks, testing, and demonstrations.

curl -X POST https://sandbox.dev.ab0t.com/api/desktops \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"desktop_type": "alpine-xfce"}'

Available types: alpine-xfce, alpine-kde, ubuntu-xfce, windows

Ephemeral

Lightweight containers for code execution, scripts, and AI agent workloads. The fastest option for short-lived compute.

curl -X POST https://sandbox.dev.ab0t.com/api/ephemeral \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"type": "python", "command": "python -c \"print(42)\""}'

Available types: ubuntu, python, node, go, rust, agent-python, agent-node, alpine, debian, custom

Container Endpoints

SSH Access

New to this? Read SSH Into Your Sandbox — a step-by-step walkthrough from Generate Key in the dashboard to landing in a shell, plus the security model, cert path, and troubleshooting.

Each user manages their own SSH keys, scoped to their current organization. When you create a sandbox, your active public keys are provisioned to ~/.ssh/authorized_keys at first boot. Connect with ssh -i your.pem sandbox@<sandbox-ip>. The full lifecycle (generate, list, rename, delete, plus short-lived certs for power users) is below.

AI Agent Integration

Sandbox Platform is designed for AI agents that need to execute code, browse the web, or interact with desktop applications autonomously.

Recommended Pattern

1. Create a sandbox or ephemeral container at the start of an agent session
2. Use /execute for shell commands and /files for reading/writing files
3. Use browser containers for web research and data extraction
4. Set auto_stop_minutes to prevent runaway costs
5. Terminate the environment when the agent session ends

Cost Control

Use POST /api/costs/limits/user/{id} to set per-user spend limits. When billing enforcement is enabled, the platform returns 402 Payment Required when limits are exceeded.

Custom Docker Images

Sandboxes support any Docker image via the docker_image parameter. The image must be publicly accessible or from an authorized registry.

{
  "name": "ml-workspace",
  "instance_type": "ab0t.gpu",
  "docker_image": "pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime"
}

Ephemeral containers also accept a custom type with your own image URL.

GPU Workloads

For GPU workloads, use ab0t.gpu or ab0t.gpu-pro instance types. These include NVIDIA Tesla T4 GPUs with CUDA drivers pre-installed.

Changelog

See the full changelog for version history and release notes.

System Status

Check live platform status at status.ab0t.com. Subscribe to updates for maintenance windows and incident notifications.