---
title: "Sandboxes for AI agents: Firecracker microVMs · Pethost"
description: "Firecracker microVMs for AI agents: start in about 0.15 s, pause with memory while the agent thinks, wake in 0.1 s. 2 vCPU for $0.018/h, billed per second."
---

Pethost Agent Sandboxes

# Cloud VMs for AI agents, paused while they think

Every sandbox is a Firecracker microVM with its own kernel and root inside. It starts in about 0.15 s, pauses with its memory and processes when idle, and wakes in about 0.1 s at the next call, exactly where it was; an SSH login or a web request wakes it too.

From **$0.018** an hour for 2 vCPU and 4 GiB, billed by the second. Paused, 30% of that. Starting one is free.

[Start the free trial](https://console.pethost.dev/welcome?kind=sandboxes) [Read the docs](https://pethost.dev/docs/sandboxes/)

7 days with $1 of usage. A card is required, and the plan’s first payment comes when the trial ends.

Twelve sandboxes of one workspace: three running, seven paused with their memory, two stopped. Together they cost about $0.09 an hour.

- **~0.15 s** to start a sandbox from a template
- **~0.1 s** to wake a paused one, memory and processes as they were
- **$0.018/h** for 2 vCPU, 4 GiB and 10 GiB while running
- **1 s** billing step: each run rounded up to a second, 10 s at least
- **$0** to create, fork or start a sandbox

Measured on our servers on 18 November 2026, through an API 16 ms away: a create’s median 123 ms (SMALL) to 158 ms (XLARGE), a resume 124 ms, a command to a paused sandbox 80 ms.

## What teams run on it

- [**Code your model writes** An AI product runs each user’s code in a sandbox of its own: a command and its output in one call, files edited in place, a port at its own address.](https://pethost.dev/sandboxes/code-execution/)
- [**Coding agents in the cloud** Claude Code, Codex and OpenCode are installed in every sandbox. One call gives an agent a prompt, another streams each tool call it makes.](https://pethost.dev/sandboxes/coding-agents/)
- [**RL and evals** Fork a prepared environment, memory and all, in one call: three copies take about 0.25 s. Start a thousand runs a day with no start fee.](https://pethost.dev/sandboxes/fork/)
- [**Computer use** Chrome on a 1280×800 desktop in every sandbox: click, type and take a screenshot in one call, or watch it live.](https://pethost.dev/sandboxes/computer-use/)

## Three states, three prices

An agent’s VM mostly waits while the agent thinks. Its processes should not end, so it pauses with its memory at 30% of the price and wakes on the next call.

A sandbox goes from running to paused after 5 idle minutes and to stopped after 30; the next call wakes a paused one in 0.1 s.

- In memory Working, billed by the second at its size’s price: $0.018 an hour for 2 vCPU and 4 GiB. Each run is rounded up to a second, 10 s at least. **$0.018 an hour**
- On its server’s disk Memory, processes and disk kept, at 30% of the running price. The next call wakes it in about 0.1 s (a web request in about 0.2 s), and a wake is never refused for room. **$0.0054 an hour**
- In object storage Its disk kept, encrypted, at $0.03 per GiB a month of its own data; its processes end. A resume boots it from its disk in about 0.2 s, or about 10 s per GiB once its disk had to be fetched back. **$0.03 per GiB a month**

By default a sandbox pauses after 5 minutes idle and stops after 30, and is never deleted. Each timer is set per sandbox, and 0 turns it off.

## Everything an agent’s computer does

Fifteen things a sandbox does, each with a page on how it works.

- [Three sandboxes on one server, each a microVM with its own kernel and its own root shell; a fourth starts in 0.12 s. A microVM per sandbox Each sandbox is a Firecracker microVM with its own Linux kernel, root inside and its own network, started from a snapshot in about 0.15 s. How it works](https://pethost.dev/sandboxes/firecracker-microvm/)
- [A sandbox pauses: its memory moves to its server’s disk and its price drops to 30%; a request arrives and it wakes in 0.08 s with the same process still running. Pauses with its memory A paused sandbox keeps its memory and processes on its server at 30% of the price, and the next call wakes it in about 0.1 s, exactly where it was. How it works](https://pethost.dev/sandboxes/pause-resume/)
- [A timeline of idle time: at 5 minutes the sandbox pauses at $0.0054 an hour, at 30 minutes it stops to object storage at $0.03 per GiB a month. Pauses itself when idle Five minutes without a call and a sandbox pauses; thirty and it stops to object storage. Every timer is set per sandbox, and 0 turns it off. How it works](https://pethost.dev/sandboxes/auto-pause/)
- [One running sandbox at step 41 of a task is forked into three copies in 0.25 s; each carries on from step 41 on its own. Fork, memory and all Copy a running sandbox, its memory, processes and disk, into new sandboxes in one call. Three copies take about a quarter of a second. How it works](https://pethost.dev/sandboxes/fork/)
- [Two lanes of seconds: a run of 37 seconds billed at $0.000005 a second, rounded up to the whole second, then paused seconds at 30%; creating it cost $0. Billed by the second Running time is billed per second at the size’s price, from $0.018 an hour; paused at 30%; stopped per GiB of data. Creating, forking and starting cost nothing. How it works](https://pethost.dev/sandboxes/per-second-billing/)
- [A program calls run_command and the test output streams back; it edits a file in place; it starts a dev server and the call answers once port 5173 listens. Commands, files and a terminal Run a command and wait for its port, stream its output, edit files by exact replacement, open a terminal in the browser: one API call each. How it works](https://pethost.dev/sandboxes/code-execution/)
- [A prompt to a coding agent in a sandbox, and its tool calls streaming back: it reads a file, edits it, runs the tests, and the turn ends done with its token count. Coding agents, installed Claude Code, Codex and OpenCode run in every sandbox at full autonomy: one call gives one a prompt, another streams each tool call it makes. How it works](https://pethost.dev/sandboxes/coding-agents/)
- [A desktop with Chrome in a sandbox: the pointer clicks a field, types an address, presses Enter, and a 1280×800 screenshot comes back. A desktop with Chrome Every sandbox has a 1280×800 screen with Chrome, started at first use: click, type and screenshot in one call, or watch it live. How it works](https://pethost.dev/sandboxes/computer-use/)
- [An ssh command to a paused sandbox on port 2222 wakes it and opens a shell; then a file copies over with scp and a port is forwarded with ssh -L. Plain SSH, scp and tunnels ssh, scp, sftp and ssh -L into any sandbox with a workspace key or a token as the password; a login wakes a paused one. How it works](https://pethost.dev/sandboxes/ssh/)
- [A visit to port 3000’s HTTPS address wakes a paused sandbox in 0.2 s and its page appears; a private port answers 200 to a request with its token and 401 to one without. A URL for every port A dev server on port 3000 answers at its own HTTPS address, public or behind a token, and a visit wakes a paused sandbox in about 0.2 s. How it works](https://pethost.dev/sandboxes/preview-urls/)
- [A sandbox with its packages and Docker images is saved as the template my-app@3 in 1.2 s, and three new sandboxes start from it on two servers. Save a sandbox as a template Save a sandbox’s disk, packages and Docker images included, as a template version, and start new sandboxes from it on any server. How it works](https://pethost.dev/sandboxes/templates/)
- [A 50 GiB volume on one server: a sandbox writes files to it at /data and is deleted; the volume and its files stay, and two new sandboxes mount it read-only. Volumes that outlive sandboxes Mount a volume at a path: read-write in one sandbox or read-only in any number. It stays when they are deleted, on its server’s disk. How it works](https://pethost.dev/sandboxes/volumes/)
- [A sandbox’s connections pass a gate that allows pypi.org and *.github.com and refuses example.com with 403; a DNS question for a name not on the list gets REFUSED, and UDP does not leave. Egress you allow, by name List the domains, wildcards, IPs and CIDRs a sandbox may reach; its DNS answers nothing else, no UDP leaves, and a change applies at once. How it works](https://pethost.dev/sandboxes/egress-allowlist/)
- [Inside the sandbox the API key is a placeholder; the egress proxy puts the real key into the request to api.anthropic.com, and a request to another host keeps the placeholder. Keys that never enter A sandbox sees a placeholder; the egress proxy swaps in the real API key in HTTPS request headers, only for the hosts you name. How it works](https://pethost.dev/sandboxes/secrets/)
- [A sandbox’s dashboard: a CPU line, memory in use, and a stream of events: created, a command that exited 0, the hosts it reached, an agent turn with its tokens, paused. Every command, host and turn CPU, memory, disk and network for 24 hours; every lifecycle change, command, host reached and agent turn, as a list or a live stream. How it works](https://pethost.dev/sandboxes/observability/)

## For your agent, your code and your terminal

Each drives sandboxes through the same API, and needs only your Pethost token: the server a sandbox runs on is found and signed in to for you.

- **MCP server** Add it to Claude, ChatGPT, Cursor or any MCP client. It signs in with your Pethost account, and your agent makes, starts, forks and pauses sandboxes with it. `https://mcp.pethost.dev/sandboxes`Copy
- **SDKs** Python, TypeScript, Go and Rust, generated from the API, each with the same methods.
- **CLI** `pethost sandbox` makes, runs, opens and forks sandboxes from your terminal.

Python

TypeScript

Go

Rust

CLI

Install `pip install pethost`

```
from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # reads PETHOST_TOKEN
box = sandboxes.create_sandbox("base")
result = sandboxes.run_command(box.sandbox_id, command="python3 -c 'print(6 * 7)'")
print(result.stdout)  # 42
```

Install `npm install pethost`

```
import { Sandboxes } from "pethost/sandboxes";

const sandboxes = new Sandboxes({ token: process.env.PETHOST_TOKEN! });
const box = await sandboxes.createSandbox({ template: "base" });
const result = await sandboxes.runCommand({ sandboxId: box.sandboxId, command: "node -p 6*7" });
console.log(result.stdout); // 42
```

Install `go get github.com/pethost-dev/sdk/go`

```
client := sandboxes.NewClient(sandboxes.Config{Token: os.Getenv("PETHOST_TOKEN")})
box, err := client.CreateSandbox(ctx, &sandboxes.CreateSandboxRequest{Template: "base"})
check(err)
result, err := client.RunCommand(ctx, &sandboxes.RunCommandRequest{
	SandboxID: box.SandboxID, Command: "echo $((6 * 7))",
})
check(err)
fmt.Println(result.Stdout) // 42
```

Install `cargo add pethost`

```
use pethost::sandboxes::{types::*, Client};

let client = Client::new(&std::env::var("PETHOST_TOKEN")?);
let base = CreateSandboxRequest { template: "base".into(), ..Default::default() };
let sandbox = client.create_sandbox(base).await?;
let command = RunCommandRequest { sandbox_id: sandbox.sandbox_id, command: "echo $((6 * 7))".into(), ..Default::default() };
let result = client.run_command(command).await?;
println!("{}", result.stdout); // 42
```

Install `curl -fsSL https://pethost.dev/install.sh | sh`

```
pethost sandbox new --name api-dev --size small
pethost sandbox run api-dev -- python3 -c 'print(6 * 7)'
pethost sandbox shell api-dev  # a shell inside
```

## How it compares

Prices and features as each vendor’s own pages stated them on 21 November 2026, for 2 vCPU and 4 GiB.

### What each one does

|  | Pethost | E2B | Daytona | Modal | Vercel Sandbox | boat.dev |
| --- | --- | --- | --- | --- | --- | --- |
| Isolation | Yes Firecracker microVM | Yes Firecracker | Partly containers; a Linux VM class1 | Partly gVisor; a VM runtime option2 | Yes Firecracker | Yes a VM per sandbox |
| Running, 2 vCPU · 4 GiB, an hour | $0.018 | $0.1656 | $0.1656 plus disk past 5 GiB | $0.2380 | $0.1104 at 10% CPU, $0.3408 at 100% CPU | $0.018 |
| Pause keeps memory and processes | Yes 30% of the running price | Yes free while paused | Partly VM class only, disk billed3 | Partly memory snapshots in alpha, kept 7 days4 | No filesystem only | No “There is no pause” |
| No start fee | Yes within the plan’s bounds | Yes | Yes | Yes | Partly $0.60 per million creations | No $0.03–$0.07 past included starts5 |
| Fork with memory | Yes 3 copies in 0.25 s | Yes | Partly VM class | Partly from a memory snapshot, in alpha | No the filesystem only | No from the last disk snapshot |
| Custom templates | Yes saved from a sandbox | Yes a template builder | Yes from an image or a Dockerfile | Yes images | Yes images, snapshots | Yes saved snapshots |
| Egress allow-list | Yes domains, IPs, CIDRs, ports | Yes | Partly tier 3 and up6 | Partly beta, TLS on port 443 | Yes | No |
| API keys kept out of the sandbox | Yes swapped in by the proxy | Yes | Not stated on the pages we read | Partly beta | Yes | Partly AI keys only, $1 a day + $1 per 1,000 requests |
| SSH, scp, tunnels | Yes | Partly through a WebSocket proxy | Not stated on the pages we read | Not stated on the pages we read | No its CLI only | Yes |
| Desktop for computer use | Yes Chrome, 1280×800 | Yes | Yes | Not stated on the pages we read | Not stated on the pages we read | Yes |
| MCP server for sandboxes | Yes | Partly a tool gateway inside the sandbox | Yes | Not stated on the pages we read | Not stated on the pages we read | Partly for its docs only |
| SDKs | Python, TypeScript, Go, Rust | Python, JS/TS | Python, TS, Ruby, Go, Java | Python, JS, Go | TypeScript | Python, TypeScript |
| Where | EU | US; EU on request | US, EU | regions at 1.15–1.75× the price | 19 regions | EU |
| Least monthly bill | $20, all of it usage | $0 on Hobby | $0 | $0, with $30 of credit a month | $0 on Hobby | $20, all of it usage |

Yes Partly No Not stated on the pages we read

1. Daytona runs containers by default; its Linux VM class pauses and forks.
2. Modal runs sandboxes in gVisor and offers a VM runtime option.
3. Daytona bills a paused VM for its disk only; the memory kept is not billed.
4. Modal’s memory snapshots are in alpha and expire 7 days after they are made.
5. boat.dev includes 12, 60 and 200 starts a minute, hour and day on its $20 plan, sells more at $0.03 to $0.07 each, and refuses past 6 times as many (3 times a minute).
6. Daytona’s tiers 1 and 2 restrict network access to essential services, and a sandbox cannot change that.

- E2B and Daytona have no monthly minimum: one light agent costs less there than our $20 plan. Four such agents cost more there than the plan.
- E2B charges nothing for a paused sandbox, and Daytona its disk only; ours costs 30% of the running price and keeps its room on its server. Over a month the running price weighs more.

### One hour of 2 vCPU and 4 GiB

- **Pethost**SMALL **$0.018**
- **boat.dev**small **$0.018**
- **Cloudflare Containers**2 vCPU · 4 GiB · 8 GB **$0.052** at 10% CPU $0.182 at 100% CPU
- **Northflank** **$0.0667**
- **Vercel Sandbox** **$0.1104** at 10% CPU $0.3408 at 100% CPU
- **E2B** **$0.1656**
- **Daytona** **$0.1656** plus disk past 5 GiB
- **Blaxel** **$0.1656** while active
- **Modal** **$0.2380**
- **Runloop**MEDIUM **$0.3195**

One hour running, 2 vCPU and 4 GiB, compute only, at each vendor’s list price on 21 November 2026.

### Two workloads, a month

#### An agent: one sandbox, 2 hours active and 22 kept idle a day

| Vendor | Kept idle as | Memory kept | Usage | Bill |
| --- | --- | --- | --- | --- |
| Pethost | paused | Yes | $4.64 | **$20**the plan, which covers about four such agents |
| E2B | paused, for free | Yes | $9.94 | **$9.94**on Hobby, with a pause every hour; $159.94 on Pro |
| Daytona | VM class, paused | Yes | $10.17 | **$10.17** |
| Blaxel | standby | Yes | $11.74 | **$11.74** |
| boat.dev | stopped | No | $1.08 | **$20** |
| Modal | a snapshot, 24 h at most | No | $14.28 | **$0**within the $30 monthly credit |

With memory kept, the agent’s month costs $4.64 here, less than half of E2B’s, Daytona’s or Blaxel’s. boat.dev costs less when memory may go. For one agent alone, E2B and Daytona bill less than our $20 plan; from four agents on, the plan is less.

#### Evals: 1,000 sandboxes a day, 60 seconds each

| Vendor | Compute | Start fees | Bill |
| --- | --- | --- | --- |
| Pethost | $9.00 | $0 | $20 |
| boat.dev | $9.00 | $144 on its $100 plan, or $1,500 on its $20 plan | $244 |
| E2B | $82.80 | $0 | $82.80 on Hobby |
| Daytona | $82.96 | $0 | $82.96 |
| Modal | $118.98 | $0 | $88.98 after the $30 credit |
| Vercel Sandbox | $55.22 at 10% CPU, $170.42 at 100% CPU | $0.02 | $55.22 at 10% CPU, $170.42 at 100% CPU |

Short, numerous sandboxes cost least here. At boat.dev the start fees are most of the bill.

On the $20 plan, 1,000 starts a day spread over the day (about 42 an hour) are inside its free starts, and 10 SMALL sandboxes run at once.

2 vCPU and 4 GiB everywhere, a 30-day month, 5 GiB of the sandbox’s own data kept while it is idle. Credits that run out are not counted; credits that come every month are.

### Every start boat.dev lets you buy, free

boat.dev includes some starts in each plan, sells more at $0.03 to $0.07 each, and refuses past six times its included count (three times a minute). Our plans cost the same, and their starts are free up to exactly those counts. Waking a paused sandbox is never a start.

| Plan | boat.dev includes | boat.dev sells up to, then refuses | Pethost, free |
| --- | --- | --- | --- |
| $20 | 12 · 60 · 200 | 36 · 360 · 1,200 | 36 · 360 · 1,200 |
| $100 | 30 · 210 · 840 | 90 · 1,260 · 5,040 | 90 · 1,260 · 5,040 |
| $500 | 65 · 420 · 1,680 | 195 · 2,520 · 10,080 | 195 · 2,520 · 10,080 |
| $2,000 | 90 · 600 · 2,400 | 270 · 3,600 · 14,400 | 270 · 3,600 · 14,400 |

Starts a minute · an hour · a day.

## The plan’s price is your usage

Each plan’s monthly price comes back in full as usage at the rates below. Past it, a balance you top up pays: from $10 to $1,000, and it never expires.

- **$20**a month Included usage$20vCPUs at once20running and paused sandboxes countLargest sizeLARGEVolumes100 GiBTemplates5 GiBFree starts36 · 360 · 1,200a minute · an hour · a day [Start the free trial](https://console.pethost.dev/welcome?kind=sandboxes)
- **$100**a month Included usage$100vCPUs at once128running and paused sandboxes countLargest sizeXLARGEVolumes600 GiBTemplates30 GiBFree starts90 · 1,260 · 5,040a minute · an hour · a day [Start the free trial](https://console.pethost.dev/welcome?kind=sandboxes)
- **$500**a month Included usage$500vCPUs at once700running and paused sandboxes countLargest sizeXLARGEVolumes3,500 GiBTemplates175 GiBFree starts195 · 2,520 · 10,080a minute · an hour · a day [Start the free trial](https://console.pethost.dev/welcome?kind=sandboxes)
- **$2,000**a month Included usage$2,000vCPUs at once3,000running and paused sandboxes countLargest sizeXLARGEVolumes16,000 GiBTemplates800 GiBFree starts270 · 3,600 · 14,400a minute · an hour · a day [Start the free trial](https://console.pethost.dev/welcome?kind=sandboxes)

### Free trial

7 days with $1 of usage, 4 vCPUs at once and sizes up to DEFAULT. A card is required, and the plan’s first payment comes when the trial ends or when you start the plan.

vCPUs at once4 Largest sizeDEFAULT Volumes10 GiB Free starts15 · 75 · 225a minute · an hour · a day

| Size | Running | Paused |
| --- | --- | --- |
| SMALL2 vCPU · 4 GiB · 10 GiB | **$0.018** an hour | $0.0054 an hour |
| DEFAULT4 vCPU · 8 GiB · 20 GiB | **$0.036** an hour | $0.0108 an hour |
| LARGE8 vCPU · 16 GiB · 40 GiB | **$0.072** an hour | $0.0216 an hour |
| XLARGE16 vCPU · 32 GiB · 80 GiB | **$0.144** an hour | $0.0432 an hour |

- Stopped: $0.03 per GiB a month of the sandbox’s own data, never empty space.
- Volumes: $0.20 per GiB a month of their size.
- Templates: free, within the plan’s room.
- $20 of usage is 1,111 hours of a SMALL sandbox running, or 3,704 hours paused.

Prices in US dollars, before tax. In the EU you pay the same numbers in euros, plus VAT.

## Questions

**How is one sandbox kept apart from another?**

Each sandbox is its own Firecracker microVM with its own Linux kernel, started inside Firecracker’s jailer: its own chroot, an unprivileged user, cgroup limits, a seccomp filter and its own network namespace. Inside you are root. Nested virtualization is off, and API keys bound as secrets never enter the VM.

**Are vCPUs and memory shared with other sandboxes?**

The hardware is shared, as at any cloud in this price range: many sandboxes run on one server, and each is held to its size, never more than its vCPUs’ time and its memory. A busy neighbour can slow a sandbox’s CPU, and a server short of memory pauses sandboxes that have been idle a minute or more early, which the next call wakes as usual.

**Where do sandboxes run, and where is my data?**

In the EU. Sandboxes run on our servers in the EU, and a stopped sandbox’s disk and your templates are kept in object storage in the EU, encrypted, each with a key of its own. There is one region, so there is nothing to pick. The [privacy policy](https://pethost.dev/privacy/) names who processes what.

**What happens when my agent goes quiet?**

After 5 minutes with no call, SSH session or web request, the sandbox pauses: memory and processes are kept at 30% of the running price, and the next call wakes it in about 0.1 s. After 30 minutes it stops: its disk goes to object storage at $0.03 per GiB a month, and its processes end. Nothing is deleted unless you set a timer for it. A command started with `keep_awake` holds it awake.

**Are there GPUs?**

No. The largest size is 16 vCPU, 32 GiB of memory and 80 GiB of disk.

**What are the limits?**

A plan sets how many vCPUs its running and paused sandboxes hold at once (20 on the $20 plan, that is 10 SMALL sandboxes), its largest size, and its free starts a minute, an hour and a day. Stopped sandboxes have no count limit, and no sandbox has a limit on how long it lives. A fork makes up to 100 copies in one call, as many as its sandbox’s server has room for, and a sandbox opens up to 20 public ports.

**How does billing work?**

A plan’s monthly price is usage it includes. A running sandbox is billed by the second at its size’s price, each run rounded up to a second with 10 s at least; a paused one at 30% of that; a stopped one by the GiB its own data takes. Creating, forking and starting cost nothing. Usage past the plan is paid from a balance you top up, from $10 to $1,000, which never expires.

If both run out, running and paused sandboxes are stopped and nothing new starts until money comes in; nothing is deleted.

**How is it different from E2B?**

Both run each sandbox in a Firecracker microVM, and both keep memory and processes when a sandbox pauses. 2 vCPU and 4 GiB cost $0.018 an hour running here and $0.1656 at E2B, which charges nothing while paused, where we charge 30%. E2B has a free Hobby plan with a one-time $100 credit; our plans start at $20 a month, all of it usage. Sandboxes here have plain SSH and run in the EU; E2B runs in the US unless you ask for its EU cluster. E2B’s figures are from its own pages on 21 November 2026.

**Is there a free trial?**

Yes: 7 days with $1 of usage, 4 vCPUs at once and sizes up to DEFAULT, which is 55 hours of a SMALL sandbox running. A card is required, and the plan’s first payment comes when the trial ends.

## Give your agent a computer in 0.15 s

[Start the free trial](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/templates/)
- [About](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Terms](https://pethost.dev/terms/)
- [Privacy](https://pethost.dev/privacy/)
- [Refunds](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Databases

- [Postgres](https://pethost.dev/postgres/)
- [Valkey](https://pethost.dev/valkey/)

Agent Sandboxes

- [Sandboxes](https://pethost.dev/sandboxes/)
- [Pricing](https://pethost.dev/sandboxes/#pricing)
- [Docs](https://pethost.dev/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Comparisons

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/blog/coolify-cloud-vs-dokploy-cloud/)
- [Railway vs Render vs Fly.io pricing](https://pethost.dev/blog/railway-vs-render-vs-fly-io-pricing/)
- [Managed Docker Compose hosting](https://pethost.dev/blog/managed-docker-compose-hosting/)

Alternatives

- [Railway alternatives](https://pethost.dev/blog/railway-alternatives/)
- [Heroku alternatives](https://pethost.dev/blog/heroku-alternatives/)
- [Dokploy alternatives](https://pethost.dev/blog/dokploy-alternatives/)
- [Coolify alternatives](https://pethost.dev/blog/coolify-alternatives/)
- [Render alternatives](https://pethost.dev/blog/render-alternatives/)
- [Sliplane alternatives](https://pethost.dev/blog/sliplane-alternatives/)
