Changelog

Sandboxes now run in US East (Ashburn, Virginia) as well as EU Central (Helsinki, Finland). New sandboxes go to the region nearest you, or pick one with region in the API, sbx new --region us-east, the SDKs, MCP's create_sandbox or the Daytona API's target. GET /api/v1/regions lists them, and every sandbox reports its region. Forks, and sandboxes made from a snapshot, stay in their source's region; existing sandboxes stay in EU Central.

On the free trial, a sandbox can now run for up to 8 hours before it auto-stops, up from 2. Auto-stop is still required on the trial and still defaults to 1 hour; the trial's 25 hours of machine time, 2 sandboxes at once and the small and default sizes are unchanged. Extend a sandbox with sbx extend or the dashboard's Extend button.

New agent cookbook pages answer questions developers asked this week: how long an agent's sandbox can run, keeping an API key out of the sandbox, giving an agent a bigger machine mid-task, running each MCP server in its own sandbox, letting a coding agent check its UI change, a background coding agent that pushes a branch for review, requiring a human's approval before risky commands, and per-team sandbox templates. A decision guide covers running coding agents at home or on a cloud VM. Every command was run on a real sandbox.

Each node now keeps a few sandboxes already booted and paused, and a new small or default sandbox from the standard image takes one instead of booting. Measured from US-East through sandboxer.com, 20 creates of the default size were ready in a median of 0.69 s (90% within 1.15 s), down from about 1.5 s. large, xlarge and creates from a snapshot boot as before. Every sandbox still gets its own machine id, SSH host keys and random seed when it's created, and pooled sandboxes are never billed. Nothing changes in the API, SDKs or CLI.

New starters set up Go, Rust, Java, Bun, Deno, .NET, PHP and Ruby dev environments in a sandbox, each with a real project, measured cold and cached builds and a named snapshot. Seven "who it's for" guides cover AI app builders, eval and research teams, classrooms, data scientists, hackathons, DevRel and QA teams. A benchmark measures Docker image pull times by sandbox size. New recipes run Flowise, Strapi, Ghost, NocoDB and Umami, and a guide shows how to run scheduled jobs with systemd timers. Every command was run on a real sandbox.

New starters set up a Python dev environment with uv and a Node.js one with pnpm in a sandbox, with measured install times and a named snapshot. New recipes test an MCP server with the MCP Inspector on a private URL and self-host Langfuse and Dify. New agent cookbook pages shard a test suite across sandboxes, with the measured result for one and two shards, and limit CPU, memory and processes for one run inside a sandbox. Every command was run on a real sandbox.

New agent cookbook pages show how to cap what agent sandboxes can cost, find and clean up orphaned sandboxes with a dry run first, tell whether a resume restored memory or cold-booted, know when a service in a sandbox is ready, and script the sbx CLI with its JSON output and jq. Others show which way of starting a service survives resume, reboot and kill, how to stream a command's output live to a web UI, and how to handle rate limits and concurrency caps. New recipes run Uptime Kuma, Label Studio and SearXNG, OCR scanned PDFs with Tesseract and OCRmyPDF, and render HTML to PDF with headless Chrome. Every command was run on a real sandbox.

New recipes run a Streamlit app, Storybook with a shareable URL, Redpanda (Kafka API), RabbitMQ, OpenSearch with Dashboards, the Chroma vector database, a HashiCorp Vault dev server and llama.cpp's server on CPU in a sandbox, and convert Markdown to PDF, DOCX and HTML with Pandoc. A new agent cookbook page shows how to run best-of-N agent attempts in forks and keep the winning diff, and another measures a fresh sandbox per tool call against one sandbox per session. Recipes cover Keycloak behind an HTTPS URL and a Next.js dev server with live reload, and benchmarks measure CPU performance and disk throughput by sandbox size. Recipes also cover Redis, an FFmpeg video pipeline, an MLflow tracking server, WordPress and a self-hosted Excalidraw whiteboard. Every command was run on a real sandbox.

New recipes run Metabase, n8n with a working webhook URL, the Temporal dev server, a Selenium Grid, Gitea with git push over HTTPS, Home Assistant, code-server, Grafana with Prometheus, Apache Airflow, JupyterLab, Meilisearch, MinIO S3 storage, a Gradio app, PocketBase and the Qdrant vector database in a sandbox, convert DOCX to PDF in batches with LibreOffice, and preview a Hugo or Astro site with live reload. A reference lists what every sandbox has pre-installed, with versions. Each recipe puts the app behind a private HTTPS URL and covers stop and resume. The API error codes guide now lists file_not_found for a missing file, and the environment variables guide reflects that a per-command env now wins for string commands too. Every command was run on a real sandbox.

New recipes run Ollama on CPU with measured tokens per second, Open WebUI on top of it, MySQL or MariaDB, MongoDB, and whisper.cpp transcription in a sandbox, each behind a private HTTPS URL that survives stop and resume. A new guide shows how to cache dependencies in a named snapshot so an agent's sandbox skips the install. Every command was run on a real sandbox.

New guides cover every sbx command on one page; every error code the API returns, with its HTTP status and what to do; the environment variables and tokens inside a sandbox; passing secrets to a sandbox safely; retrying API calls with idempotency keys; what common workloads cost per hour and per month; and a glossary of sandbox terms. New recipes run Postgres with pgvector and Supabase locally in a sandbox. Every command was run on a real sandbox.

New migration guides cover moving from Replit, Fly.io, Runloop, Northflank, the CodeSandbox SDK and Beam. New guides publish start, resume and fork times we measured on 2026-10-27, and show how to run each GitHub Actions job in a fresh microVM, turn a GitHub issue into a pull request from a sandbox, and run the Android emulator in a cloud VM. Every command was run on a real sandbox.

New guides explain what a microVM is; what can reach a sandbox and what it can reach, with a tested outbound firewall; giving every user of your product their own sandbox; persistent vs ephemeral sandboxes; Claude Code's sandbox mode vs Docker vs a cloud VM; git worktrees vs one VM per agent; fixing exit code 137 or a full disk by resizing; running kind or k3s inside a sandbox; and SWE-bench-style evaluations on microVMs. A migration guide covers moving from GitHub Codespaces. Every command was run on a real sandbox.

Signed preview URLs from the Daytona SDK (getSignedPreviewUrl) now work from scripts as well as browsers: from fetch or requests without a cookie jar, with a path added to the URL, and on the very first request. To choose a sandbox size from the Daytona SDK, set the label sandboxer.type to small, default, large or xlarge. Without it, you get small.

After every resume, a sandbox's memoryRestored is true when memory was restored and your processes kept running, or false when it booted from disk with your files intact. When it's false, resumeReason says why: cpu_mismatch, resized, no_memory_snapshot or restore_failed. sbx resume straight after sbx stop now waits for the stop to finish instead of failing.

A command killed for running out of memory now exits with code 137, and the sandbox keeps answering. Before, it sometimes returned a 502 "guest agent: EOF" error. This applies to sandboxes created from today.

New guides walk through building a stateful Jupyter code interpreter, a data-analysis agent, and a text-to-SQL agent tested against a real Postgres; running Browser Use or Playwright with Chrome, and a computer-use agent on the Linux desktop; RL and eval environments from snapshots and forks; Docker Compose with a URL per service; idle auto-pause; a preview URL per pull request; and OpenHands with its UI on HTTPS. A migration guide covers moving from Cloudflare Sandbox. Every command was run on a real sandbox.

New migration guides show how to move from E2B, Modal and Vercel Sandbox: how their concepts and calls map to ours, a before-and-after example (ours run on a real sandbox), moving files and settings, and what's different. New guides cover forking a running sandbox, saving a sandbox as a reusable template, giving a port an HTTPS URL, moving files, SSH from VS Code or Cursor, long-running jobs, connecting Claude.ai and ChatGPT over MCP, local vs hosted MCP, and using Sandboxer from LangGraph, CrewAI, the Vercel AI SDK, the OpenAI Agents SDK and the Claude Agent SDK.

Every guide and comparison page, including the rankings and category tables, now ends with a "Start your free trial" box, and long pages show it once mid-page too. It states the trial as it is: 7 days and 25 hours of machine time, a card is required, and you can cancel any time from your billing page.

The Terms of Service (section 7) now say that storage isn't charged and that each plan includes the storage shown on the pricing page: over it, new sandboxes, forks and named snapshots wait until you're back under, while stopping, resuming and deleting still work. Any future deletion of unused or over-the-limit data would come only after at least 30 days' email notice and a Terms update. The old charge for extra named snapshots is gone.

Resuming with requireMemory: true and a different size now answers 400 invalid_require_memory instead of booting from disk (a new size always boots from disk). Resuming at the sandbox's own size is unchanged.

The OpenAPI document now includes idleStopMinutes, lastActivityAt, memoryRestored, resumeReason and requireMemory; the TypeScript and Python SDKs get them in their next release.

A sandbox now pauses itself after idleStopMinutes without activity (15 minutes on the free trial, 30 on the $20 plan, 60 on $100 and $500, 120 on $2,000; 0 turns it off, up to 7 days). Pausing is a stop with memory, so files and running processes are kept and compute isn't billed while it's paused. The next API call or request to one of its hosted URLs wakes it. Commands, terminals, SSH logins, agent turns, a busy CPU (1-minute load ≥ 0.5) and a ~/.sandboxer/keep-awake file keep it awake. Set it with sbx new --idle, sbx idle, idleStopMinutes on the API or the MCP tools. Sandboxes created before today have it off until you set it.

A resume now restores memory on a machine with the same CPU type, waiting up to 2 minutes for one when it's busy before booting from disk; when it boots from disk the sandbox says so (memoryRestored: false, resumeReason: "cpu_mismatch"). With requireMemory: true (sbx resume --require-memory) it waits up to 30 minutes instead and fails with memory_unavailable rather than booting from disk.

Each plan now includes storage for what you keep: 50 GB on the $20 plan, 250 GB on $100, 1 TB on $500 and 5 TB on $2,000, and 10 GB on the free trial or without a plan. Stopped sandboxes and named snapshots count; running ones don't. Storage isn't billed: over the amount, new sandboxes, forks and named-snapshot saves wait until you free space or upgrade, and going over never deletes anything. Named snapshots no longer have a separate charge. Billing and the sandbox list show what you use.

status.sandboxer.com and sandboxer.com/status show each service (website, sign-in, API, sandboxes, preview URLs and SSH, hosted MCP, billing, email) as green, yellow or red, with its latest check time, 90 days of uptime and incidents. It's fed by our automatic production checks, which run every 10 to 30 minutes, plus checks from outside our network every minute, and it's hosted off our own servers so it stays up even if we're down. The data is public JSON at GET /api/v1/status.

The plan card on Billing now has a Cancel trial or Cancel plan button for Stripe subscriptions. Trial users see that they keep the trial until its end date, won't be charged, and will get an email 2 days before it ends. Paid users see that the plan runs to the end of the period, isn't renewed, and the rest of the period isn't refunded. Cancelling asks one optional "why?" question first (Stripe's portal asks too); nothing else about cancelling changes.

Connect Claude, ChatGPT, Claude Code, Codex, Cursor or any MCP client to https://sandboxer.com/mcp with nothing to install. Apps sign in with your Sandboxer account (OAuth, with a consent page); headless clients send an API key. The hosted server and the local sbx mcp share the same 18 tools: create, list and manage sandboxes, run commands in the foreground or detached, read and write files, publish ports, and save snapshots. Connected apps are listed under API keys, where you can disconnect them.

Sandboxes can carry labels: set them on create, replace them with PATCH, and filter with GET /sandboxes?labels=k=v. Named snapshots can be saved as versions (<name>-v<N>), with ifLatest so two parallel saves can't both win and keep to prune a series to its newest N. Named snapshots also report storedBytes, the bytes that count toward storage.

Search, filters, the open metrics dialog and its time range, the file browser's folder, the selected environment and the team you're viewing now live in the URL, so a reload or a shared link opens the same view. On the docs and pricing pages, the code sample language and the pricing estimator's inputs are kept the same way.

Synchronous commands now run up to their own timeout (at most 600 s); before, anything over 5 minutes failed with 502 sandbox_direct_failed while it kept running. While one runs, auto-stop is pushed past its end so the sandbox isn't stopped under it. A detached command's status now settles from the sandbox's own history with its real exit code, and it's marked lost when the sandbox is deleted or cold-boots.

Billing now shows starts left in the rolling 24 hours (with the last hour and minute), names your plan, and shows storage used against what's included; each plan row lists all three start limits. The sandbox list has a Stored column, its sparklines cover the last hour, and stopped sandboxes keep theirs. Sandbox objects in the API carry storageBytes and storageMeasuredAt.

Start-limit errors now say which window was hit, how many starts were used of the limit, which plan set it and when the next start frees up, with a Retry-After header and details (window, limit, used, planName, resetsAt). A full day window returns 429 daily_limit_reached. Concurrency and storage errors also name the plan and the numbers.

A stop's background upload now waits 2 minutes, so a quick stop-then-resume doesn't compete with it. New sandboxes go to the node with the most free memory, creates no longer queue behind large snapshot uploads, and if the node holding a just-stopped sandbox is briefly full, resume retries for up to 10 minutes instead of failing.

We now test production the way you use it. Pages, Google and GitHub sign-in, checkout and the CLI installer are checked every 10 minutes, and a full sandbox lifecycle every 30 minutes: create, run a command, a public port, stop with memory, resume, plain IPv4 SSH, delete. SSH through a sandbox's IPv4 sshEndpoint was fixed for sandboxes where it didn't connect.

The new /guides section has answer-first how-to guides (Claude Code in a cloud VM, Codex CLI on a remote machine, pause and resume with memory, Docker and nested KVM and more) and ranked roundups that disclose we're on the list. /compare has product pages with sourced facts and the date each was checked, plus category hubs. Public pages now load without JavaScript and have Markdown twins and llms.txt entries, so agents and crawlers can read them.

Card trials now get an email 2 days before they convert to the $20/month plan, unless they're already cancelling. New accounts without a card get a short welcome sequence explaining the trial, which stops once a card is added.

The home page's TypeScript, Python and curl samples now match the published sandboxer-sdk 0.1.1 on npm and PyPI, and each was run unedited against production. The SDK docs no longer say the packages are unpublished, and the Python page warns to install sandboxer-sdk, not the unrelated sandboxer package.

When there's no room for the size you asked for, create and fork now return 503 capacity_exceeded at once, with details.availableBySize saying how many of each size you can still start.

Code written for the Daytona SDK now runs on Sandboxer: set DAYTONA_API_URL=https://sandboxer.com/daytona/api and DAYTONA_API_KEY to a Sandboxer API key. It covers sandbox lifecycle (create, list, start, stop, delete, labels, auto-stop and auto-delete), running commands and code, sessions, files, ports and preview URLs. We test it with the official TypeScript and Python SDKs. Custom images, volumes, GPUs, network allow-lists, git, LSP, computer use and PTY aren't covered yet and return not_supported. The sandboxes are the same microVMs, billing and limits as the rest of Sandboxer.

Stopping a sandbox now uploads its disk (and memory, when it has it) to object storage, and the node's copy becomes a cache, so a sandbox whose node is full or offline resumes on another node. Memory is restored only on matching hardware; otherwise it boots from disk and reports resumedFrom: "disk". Named snapshots are stored off-node too and outlive their source sandbox.

Starting a sandbox now needs a card on file. Adding one for the $20 plan starts a 7-day free trial with 25 hours of machine time (2 at once, small and default sizes), which becomes $20/month unless cancelled before it ends; one trial per person, organization or card. The card goes into an in-page Stripe checkout, and sbx new offers the same checkout and waits for it.

Switching plans on the Billing page now applies in place: an upgrade is charged the prorated difference and raises your limits once it's paid, and a downgrade takes effect at the next renewal (the page shows "changes to … on ", and Keep undoes it).

The API keys page lists CLI logins, which you can revoke. Browser requests with a body must be JSON, cross-site browser POSTs are rejected, and api.sandboxer.com serves only the API.

Each sandbox keeps its newest two automatic snapshots; resume and fork use the newest, and older ones are deleted. Named snapshots aren't affected. Nodes keep a disk reserve so a full disk can't stop the host.

All three policies are final: Terms, Privacy and Acceptable Use. The contracting party and data controller is North Bay Opco I, Inc.