How Fast Are Burst Sandbox Creates? 20 and 40 at Once, Measured

export SANDBOXER_API_KEY=sbx_…
python3 bench-burst.py -n 20 --type default --region us-east
python3 bench-burst.py -n 40 --type default

#!/usr/bin/env python3
"""bench-burst.py: N sandbox creates fired at once, each timed from its create call to ready.

    SANDBOXER_API_KEY=… python3 bench-burst.py [-n 20] [--type default] [--region us-east] [--api https://sandboxer.com/api/v1]

Each worker thread sends POST /sandboxes, then GET /sandboxes/{id}?waitFor=ready (the server answers the moment
the sandbox can run a command; the SDKs, CLI and MCP do the same), and records the wall time from just before the
create to the ready answer. All N creates are released together by a barrier. Each sandbox is deleted the moment it
is timed (or after --give-up seconds without becoming ready), so the test holds capacity for seconds, not minutes.
Prints p50/p90/max overall and per region the sandboxes landed in.
"""
import argparse
import json
import os
import statistics
import threading
import time
import urllib.request

ap = argparse.ArgumentParser()
ap.add_argument("-n", type=int, default=20)
ap.add_argument("--type", default="default")
ap.add_argument("--region", default="")
ap.add_argument("--api", default="https://sandboxer.com/api/v1")
ap.add_argument("--give-up", type=float, default=90, help="seconds before a create that isn't ready is deleted")
args = ap.parse_args()
key = os.environ["SANDBOXER_API_KEY"]


def call(method, path, body=None, headers=None, timeout=120):
    req = urllib.request.Request(args.api + path, method=method, data=json.dumps(body).encode() if body is not None else None)
    req.add_header("Authorization", "Bearer " + key)
    req.add_header("Content-Type", "application/json")
    req.add_header("User-Agent", "sandboxer-bench-burst/1")
    for k, v in (headers or {}).items():
        req.add_header(k, v)
    try:
        with urllib.request.urlopen(req, timeout=timeout) as r:
            return r.status, json.load(r)
    except urllib.error.HTTPError as e:
        try:
            return e.code, json.load(e)
        except Exception:
            return e.code, {}


results = [None] * args.n
barrier = threading.Barrier(args.n)


def worker(i):
    body = {"type": args.type, "ttlSeconds": 900, "name": f"bench-{int(time.time())}-{i}"}
    if args.region:
        body["region"] = args.region
    barrier.wait()
    t0 = time.monotonic()
    code, r = call("POST", "/sandboxes", body)
    sb = r.get("sandbox") or {}
    if code >= 300 or not sb.get("id"):
        results[i] = {"ok": False, "error": (r.get("error") or {}).get("code", code)}
        return
    created = time.monotonic() - t0
    sid = sb["id"]
    state = sb.get("state")
    while state not in ("running", "ready", "error", "cancelled", "failed") and time.monotonic() - t0 < args.give_up:
        code, r = call("GET", f"/sandboxes/{sid}?waitFor=ready", timeout=max(5, args.give_up - (time.monotonic() - t0)))
        sb = r.get("sandbox") or sb
        state = sb.get("state")
        if code >= 300:
            break
    elapsed = time.monotonic() - t0
    call("DELETE", f"/sandboxes/{sid}", headers={"X-Sandboxer-Confirm-Delete": sid})  # free its room at once
    results[i] = {"ok": state in ("running", "ready"), "id": sid, "s": elapsed, "accepted": created,
                  "region": sb.get("region"), "source": sb.get("regionSource"), "state": state}


threads = [threading.Thread(target=worker, args=(i,)) for i in range(args.n)]
wall0 = time.monotonic()
for t in threads:
    t.start()
for t in threads:
    t.join()
wall = time.monotonic() - wall0


def pct(xs, p):
    xs = sorted(xs)
    return xs[min(len(xs) - 1, max(0, round(p / 100 * len(xs) + 0.5) - 1))]


def line(label, rs):
    ts = [r["s"] for r in rs]
    return f"{label:<22} n={len(ts):<4} p50 {statistics.median(ts):6.2f} s  p90 {pct(ts, 90):6.2f} s  max {max(ts):6.2f} s"


ok = [r for r in results if r and r["ok"]]
bad = [r for r in results if not r or not r["ok"]]
print(f"{args.n} x {args.type} creates at once{' in ' + args.region if args.region else ' (no region given)'}: {len(ok)} ready, {len(bad)} failed; all ready in {wall:.2f} s")
if ok:
    print(line("all", ok))
    for reg in sorted({r["region"] for r in ok}):
        rs = [r for r in ok if r["region"] == reg]
        srcs = ",".join(sorted({str(r["source"]) for r in rs}))
        print(line(f"{reg} ({srcs})", rs))
for r in bad[:10]:
    print("failed:", r)
print("deleted", sum(1 for r in results if r and r.get("id")), "(each as soon as it was timed)")