stop

crabbox stop ends a single lease. For coordinator-backed and direct cloud providers it releases or deletes the backing machine; for delegated runners it tears down the underlying sandbox; for static provider=ssh hosts it only removes the local claim and never touches the host.

crabbox stop swift-crab
crabbox stop --id cbx_0a1b2c3d4e5f
crabbox stop --provider namespace-devbox swift-crab
crabbox stop --provider daytona swift-crab
crabbox stop --provider e2b swift-crab
crabbox stop --provider ssh --static-host mac-studio.local mac-studio.local

crabbox release is a compatibility alias for crabbox stop.

#Identifying the lease

Pass the lease as a positional argument or with --id; both accept the canonical cbx_... ID or an active friendly slug (see Identifiers). Supplying both --id and a positional argument, or more than one positional argument, is an error.

Several providers also accept their own native identifiers in addition to the Crabbox lease ID and local slug:

• blacksmith-testbox — accepts a tbx_... ID or local slug and forwards to blacksmith testbox stop.
• blaxel — accepts a Crabbox lease ID (blx_<sandbox-id>) or local slug and deletes the Blaxel sandbox only when the local claim and remote ownership labels match. Missing sandboxes keep the local claim unless --blaxel-forget-missing is set.
• namespace-devbox — shuts down the Namespace Devbox by default and retains its local claim and SSH files for reuse. Set namespace.deleteOnRelease (or pass --namespace-delete-on-release) to delete the Devbox and local SSH files instead.
• namespace-instance — accepts a lease ID, local slug, or Namespace instance ID and destroys the Compute instance with nsc destroy --force.
• morph — pauses the instance by default and retains its local claim and SSH key for reuse. Set morph.deleteOnRelease (or pass --morph-delete-on-release) to delete the instance and key instead.
• exe-dev — accepts a Crabbox lease ID, local slug, or exe.dev VM name only when an unchanged local claim binds the exact deterministic VM name, complete remote ownership tags, and current control route. Claimless or legacy unscoped tagged VMs require explicit --reclaim through a normal reuse command before stop; untagged VMs remain read-only inventory. Failed deletion keeps the claim.
• semaphore — stops the Semaphore CI job and removes the local claim.
• sprites — deletes the Sprites sprite and removes the local claim.
• daytona — deletes the Daytona sandbox.
• coder — stops the Coder workspace by default and removes the local claim. Set coder.deleteOnRelease or pass --coder-delete-on-release to delete the workspace instead.
• islo — accepts an exactly claimed isb_... ID, Crabbox-created sandbox name, or local slug and deletes the Islo sandbox. Claimless canonical names must first be adopted through an explicit supported --reclaim reuse.
• freestyle — accepts an exactly claimed fsb_... ID, Crabbox-created VM name, or local slug and deletes the Freestyle VM. Claimless canonical names remain visible to status/list but cannot be deleted until explicit --reclaim reuse persists a claim.
• runpod — accepts a lease ID, pod ID, pod name, or local slug only when an exact local claim binds that RunPod id and provider-returned name. Unclaimed and legacy pods remain visible to status/list but require explicit --reclaim reuse before deletion.
• e2b — accepts a Crabbox lease ID, local slug, or E2B sandbox ID only when an exact local claim binds the sandbox and configured API endpoint. Claimless raw or e2b_<sandboxID> identifiers require explicit --reclaim; Crabbox re-reads canonical remote ownership metadata and persists the exact claim before deletion. Failed deletion retains the claim for an exact retry.
• railway — refuses unclaimed service IDs. Use --reclaim only after inspecting the configured API endpoint, project, environment, service, and current deployment; Crabbox persists that exact one-deployment binding before stopping it. Failed stops retain the claim for an exact retry, while successful stops remove it.
• hetzner — requires canonical remote ownership labels and an exact local claim bound to the server ID and lease ID. Unclaimed resources must first be explicitly reclaimed through a normal reuse command; failed deletion keeps the claim for an exact retry.
• vercel-sandbox — accepts a Crabbox-created local slug or vsbx_... lease ID, verifies ownership metadata, deletes the Vercel Sandbox, and removes the local claim. Missing remote sandboxes preserve the claim unless --vercel-sandbox-forget-missing is explicit.
• cloudflare-dynamic-workers — accepts a local claim, lifecycle run ID, or slug, deletes loader metadata for that run, and removes the local claim. Stable and explicit Worker cache IDs are not lifecycle IDs. If the loader already reports not found, Crabbox removes the stale local claim.
• cloudflare-sandbox — accepts a Crabbox-created local slug or cfsbx_... lease ID, verifies ownership metadata, deletes the Cloudflare Sandbox through the configured bridge, and removes the local claim. Missing remote sandboxes preserve the claim unless --cloudflare-sandbox-forget-missing is explicit.
• docker-sandbox — accepts only a Crabbox lease ID or local slug backed by a provider=docker-sandbox local claim, then removes the sandbox with sbx rm --force. This is destructive cleanup, not Docker Sandbox pause, and it remains the manual cleanup path for clone-mode Docker Sandbox runs that Crabbox keeps after a successful one-shot command.
• hostinger — stops the VPS and retains its local claim and SSH key for later reuse. Hostinger still owns the subscription and may continue billing it.
• ssh (static hosts) — removes the local claim for the configured static target; it never deletes the host.
• xcp-ng — accepts a Crabbox lease ID or local slug for a Crabbox-managed VM, deletes the attached config drive when present, and refuses to touch VMs that are not labeled as Crabbox-managed XCP-ng leases.

#Behavior by provider mode

The action stop takes depends on how the lease was created:

• Coordinator-backed (aws, azure, daytona, gcp, hetzner brokered through a configured broker) — releases the lease through the broker and prints released lease=<id> server=<id>. If the lease cannot be inspected first, stop warns and still attempts the release by ID.
• Direct cloud and local providers — usually delete the backing server and print deleted lease=<id> server=<id> name=<name>, but retain-capable providers such as namespace-devbox, morph, kubevirt, and incus stop or pause instead when their *.deleteOnRelease setting is false (some providers print a provider-specific release message instead, for example stopped lease=<id> instance=<name> retained=true for retained Incus instances). Hostinger is stop-only and prints billing=still-owned; it does not delete or cancel the subscription.
• DigitalOcean, Linode, Vultr, and Scaleway — require canonical live ownership tags plus an exact local claim for the same provider account or project and resource before reuse or deletion. Claimless resources remain visible in read-only inventory and require explicit supported --reclaim reuse before stop may delete them.
• Delegated runners — call the provider's own teardown for the resolved sandbox.

For provider=docker-sandbox, crabbox stop intentionally keeps Crabbox's cross-provider cleanup meaning. Use ports and cp for non-destructive post-create workflows on a running sandbox. The separate pause and resume commands are provider-dependent and are not supported by Docker Sandbox.

Where applicable, stop makes a best-effort attempt to stop GitHub Actions hydration on the host before releasing it. For SSH leases that can host mediated egress, it also best-effort stops egress state: the local host daemon pid state and the lease-side egress client are cleaned up before the provider release runs.

#Flags

stop accepts the shared provider-selection and target flags. The most common:

--provider <name>          provider to act against (see crabbox providers)
--id <lease-or-slug>        lease ID or slug (equivalent to the positional arg)
--reclaim                   explicitly adopt a provider resource when that provider supports safe stop adoption
--target linux|macos|windows
--windows-mode normal|wsl2
--static-host <host>        static SSH host (provider=ssh)
--static-user <user>        static SSH user (provider=ssh)
--static-port <port>        static SSH port (provider=ssh)
--static-work-root <path>   static target work root (provider=ssh)

Each provider also registers its own flags; the ones relevant to stop include:

--namespace-delete-on-release            delete the Namespace Devbox instead of shutting it down
--coder-delete-on-release                delete the Coder workspace instead of stopping it
--exe-dev-control-host <host>            exe.dev SSH API host
--sprites-api-url <url>                  Sprites API URL
--e2b-api-url <url>                      E2B API URL
--e2b-domain <domain>                    E2B sandbox domain
--hostinger-url <url>                    Hostinger API URL
--hostinger-release-action stop          Hostinger release action; only stop is supported
--azure-dynamic-sessions-endpoint <url>  Azure Container Apps Dynamic Sessions endpoint
--blaxel-forget-missing                  remove a Blaxel claim after confirming the sandbox is already gone
--cloudflare-dynamic-workers-url <url>   Cloudflare Dynamic Workers loader URL
--cloudflare-sandbox-url <url>           Cloudflare Sandbox bridge URL
--cloudflare-sandbox-forget-missing      forget a local claim when the bridge reports the sandbox missing

Run crabbox stop --help for the full, provider-aware flag list, and crabbox providers for the providers available in your build.

#See also

• cleanup — sweep expired direct-provider machines and stale local state.
• ports / cp — non-destructive Docker Sandbox follow-up operations.
• pond release — stop every lease in a named pond at once.
• admin — coordinator-side release and delete for operators.
• Lifecycle & cleanup — how leases expire and get reclaimed.