---
title: "Schnellstart: deine erste Sandbox | Pethost Agent Sandboxes"
description: "Sandbox erstellen, Befehl ausführen, Datei schreiben, Port öffnen, aufräumen: mit Python, TypeScript, Go, Rust, der pethost-CLI oder deinem Agenten."
---

[Doku zu Agent Sandboxes](https://pethost.dev/de/docs/sandboxes/) · Einstieg

# Schnellstart: deine erste Sandbox

Aktualisiert 22. November 2026 · 11 Min. Lesezeit

Deine erste Sandbox in ein paar Minuten: ein SDK installieren, ein API-Token erstellen, eine Sandbox erstellen, darin einen Befehl ausführen, eine Datei schreiben, einen Port fürs Internet öffnen, sie pausieren lassen und sie löschen. Jeder Schritt ist ein Aufruf, in Python, TypeScript, Go oder Rust, und dieselben Schritte folgen mit der `pethost`-CLI.

**Kurz gesagt**

- **Ein Paket:** das SDK, das du von Pethost schon kennst, mit einem Client für Sandboxes daneben: `pethost.sandboxes`, `pethost/sandboxes`, `github.com/pethost-dev/sdk/go/sandboxes`, `pethost::sandboxes`.
- **Ein Token:** ein API-Token in `PETHOST_TOKEN`. Der Client findet den Server jeder Sandbox und ihr Token selbst.
- **Eine ID:** Jeder Aufruf nennt seine Sandbox über `sandbox_id`.
- **Nichts von Hand aufzuräumen:** Eine Sandbox, die du vergisst, pausiert nach 5 Minuten und stoppt nach 30.

## SDK installieren

Der Client für Sandboxes ist Teil des Pethost-SDK jeder Sprache, also bekommst du mit einer Installation beides. Python 3.10, Node 22 (oder Bun oder Deno), Go 1.26 und Rust 1.88 oder neuer.

Python

```
pip install pethost
```

TypeScript

```
npm install pethost          # or: bun add pethost
deno add jsr:@pethost/sdk    # Deno: import from "@pethost/sdk/sandboxes"
```

Go

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

Rust

```
cargo add pethost
cargo add tokio --features macros,rt-multi-thread,time
```

CLI

```
curl -fsSL https://pethost.dev/install.sh | sh    # macOS, Linux
irm https://pethost.dev/install.ps1 | iex         # Windows, in PowerShell
```

## API-Token erstellen

### Step 1: Workspace für Agent Sandboxes anlegen

Melde dich unter [console.pethost.dev](https://console.pethost.dev/) an und leg einen Workspace an, mit Agent Sandboxes als Art. Der erste eines neuen Kontos beginnt mit einer Testphase: 7 Tage mit 1 $ Verbrauch und 4 vCPUs, eine Karte ist nötig.

### Step 2: Token dafür erstellen

Öffne im Workspace **Agenten oder deinen Code verbinden** und drück **API-Token erstellen**. Das Token beginnt mit `pth_`, erreicht nur diesen Workspace und wird einmal gezeigt. Deine Tokens findest und löschst du in den Einstellungen deines Kontos.

### Step 3: Token an dein Programm geben

```
export PETHOST_TOKEN=pth_...
```

Der Python-Client und die CLI lesen es aus der Umgebung; die Programme unten geben es an die Clients für TypeScript, Go und Rust weiter. Halte es aus deinem Code heraus: Es handelt als dein Konto.

## Sandbox erstellen

Eine Sandbox startet aus einer Vorlage. Unsere, `base`, ist Ubuntu 24.04 mit Python, Node.js, Docker, drei Coding-Agenten und Chrome. `CreateSandbox` antwortet, sobald die Sandbox läuft, in etwa 0,15 s auf der Seite des Servers, plus deinem Weg zum Panel und zurück.

Python

```
from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # reads PETHOST_TOKEN
sandbox = sandboxes.create_sandbox("base")
print(sandbox.sandbox_id, sandbox.state.name)  # 5a4c9z5zw58mvqww RUNNING
```

TypeScript

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

const sandboxes = new Sandboxes({ token: process.env.PETHOST_TOKEN! });
const sandbox = await sandboxes.createSandbox({ template: "base" });
const sandboxId = sandbox.sandboxId;
console.log(sandboxId, sandbox.state);
```

Go

```
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/pethost-dev/sdk/go/sandboxes"
)

func main() {
	ctx := context.Background()
	client := sandboxes.NewClient(sandboxes.Config{Token: os.Getenv("PETHOST_TOKEN")})

	sandbox, err := client.CreateSandbox(ctx, &sandboxes.CreateSandboxRequest{Template: "base"})
	if err != nil {
		log.Fatal(err)
	}
	id := sandbox.SandboxID
	fmt.Println(id, sandbox.State)

	// The next steps go on here.
}
```

Rust

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sandboxes = Client::new(&std::env::var("PETHOST_TOKEN")?);
    let sandbox = sandboxes
        .create_sandbox(CreateSandboxRequest { template: "base".into(), ..Default::default() })
        .await?;
    let id = sandbox.sandbox_id.clone();
    println!("{id} {:?}", sandbox.state);

    // The next steps go on here.
    Ok(())
}
```

HTTP

```
curl -s https://console.pethost.dev/pethost.sandboxes.v1.SandboxService/CreateSandbox \
  -H "Authorization: Bearer $PETHOST_TOKEN" -H "Content-Type: application/json" \
  -d '{"template": "base"}'
# {"sandbox_id": "w86eeaozgndh3gj2", "state": "SANDBOX_STATE_RUNNING", "template": "base@17", …,
#  "connection": {"url": "https://sbx1.sandboxes.pethost.network", "token": "…", …}}
```

Behalte die ID: Jeder andere Aufruf nennt die Sandbox damit. Du kannst einer Sandbox auch einen `name` geben, eindeutig im Workspace, über den `ListSandboxes` sie findet.

## Befehl ausführen

`RunCommand` führt einen Shell-Befehl als Benutzer `user` in `/home/user` aus und antwortet, wenn er endet, mit seinem Exit-Code und den letzten 32 KiB seiner Ausgabe. Ein Befehl, der länger als 45 s dauert, antwortet mit RUNNING und läuft weiter: [Befehle und Dateien](https://pethost.dev/de/docs/sandboxes/commands-and-files/) sagt, wie du ihm folgst.

Python

```
command = sandboxes.run_command(sandbox.sandbox_id, command="python3 -c 'print(6 * 7)'")
print(command.exit_code, command.stdout)  # 0 42
```

TypeScript

```
const command = await sandboxes.runCommand({ sandboxId, command: "python3 -c 'print(6 * 7)'" });
console.log(command.exitCode, command.stdout); // 0 42
```

Go

```
command, err := client.RunCommand(ctx, &sandboxes.RunCommandRequest{SandboxID: id, Command: "python3 -c 'print(6 * 7)'"})
if err != nil {
	log.Fatal(err)
}
fmt.Println(*command.ExitCode, command.Stdout) // 0 42
```

Rust

```
let command = sandboxes
    .run_command(RunCommandRequest {
        sandbox_id: id.clone(),
        command: "python3 -c 'print(6 * 7)'".into(),
        ..Default::default()
    })
    .await?;
println!("{:?} {}", command.exit_code, command.stdout); // Some(0) 42
```

HTTP

```
# URL and TOKEN: connection.url and connection.token of the create's answer
curl -s "$URL/pethost.sandboxes.v1.SandboxRuntimeService/RunCommand" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"sandbox_id": "'"$ID"'", "command": "python3 -c '\''print(6 * 7)'\''"}'
# {"commandId": "efpe95t24evu", "state": "COMMAND_STATE_EXITED", "exitCode": 0, "stdout": "42\n", …}
```

Der Befehl ging an den eigenen Server der Sandbox, nicht an das Panel. Das SDK hat die Adresse des Servers und ein Token für diese Sandbox aus der Antwort des Erstellens genommen und holt selbst neue, wenn sie ablaufen.

## Datei schreiben und lesen

`WriteFiles` macht Änderungen der Reihe nach, in einem Aufruf: Es schreibt ganze Dateien, bearbeitet eine durch exaktes Ersetzen, verschiebt und löscht. Pfade sind absolut oder relativ zu `/home/user`, und fehlende Verzeichnisse werden angelegt.

Python

```
from pethost.sandboxes import FileChange, TextEdit

sandboxes.write_files(sandbox.sandbox_id, changes=[
    FileChange(path="app/hello.py", text="print('hello')\n"),
    FileChange(path="app/hello.py", edit=TextEdit(old_text="hello", new_text="hello, sandbox")),
])
print(sandboxes.read_file(sandbox.sandbox_id, path="app/hello.py").text)  # print('hello, sandbox')
```

TypeScript

```
await sandboxes.writeFiles({
  sandboxId,
  changes: [
    { path: "app/hello.py", text: "print('hello')\n" },
    { path: "app/hello.py", edit: { oldText: "hello", newText: "hello, sandbox" } },
  ],
});
const file = await sandboxes.readFile({ sandboxId, path: "app/hello.py" });
console.log(file.text);
```

Go

```
_, err = client.WriteFiles(ctx, &sandboxes.WriteFilesRequest{SandboxID: id, Changes: []sandboxes.FileChange{
	{Path: "app/hello.py", Change: sandboxes.FileChangeText("print('hello')\n")},
	{Path: "app/hello.py", Change: sandboxes.FileChangeEdit{OldText: "hello", NewText: "hello, sandbox"}},
}})
if err != nil {
	log.Fatal(err)
}
file, err := client.ReadFile(ctx, &sandboxes.ReadFileRequest{SandboxID: id, Path: "app/hello.py"})
if err != nil {
	log.Fatal(err)
}
if text, ok := file.Content.(sandboxes.FileText); ok {
	fmt.Print(string(text))
}
```

Rust

```
let write = |change| FileChange { path: "app/hello.py".into(), change: Some(change), ..Default::default() };
sandboxes
    .write_files(WriteFilesRequest {
        sandbox_id: id.clone(),
        changes: vec![
            write(FileChangeChange::Text("print('hello')\n".into())),
            write(FileChangeChange::Edit(TextEdit { old_text: "hello".into(), new_text: "hello, sandbox".into() })),
        ],
    })
    .await?;
let file = sandboxes
    .read_file(ReadFileRequest { sandbox_id: id.clone(), path: "app/hello.py".into(), ..Default::default() })
    .await?;
if let Some(FileContent::Text(text)) = file.content {
    print!("{text}");
}
```

Eine Änderung, die scheitert, beendet den Stapel, und die Antwort sagt, wie viele erledigt wurden und warum die nächste scheiterte (`failure`): Eine Bearbeitung, deren `old_text` nicht in der Datei steht oder zweimal darin, ändert nichts.

## Port fürs Internet öffnen

Starte einen Server mit `wait_for_port`: Der Aufruf antwortet, sobald etwas auf dem Port lauscht, während der Server weiterläuft. Dann mach den Port öffentlich. Er bekommt eine eigene Adresse, `https://<port>-<sandbox id>.<server>`, die jede Person öffnen kann.

Python

```
from pethost.sandboxes import Ingress, PublicPort, SandboxSettings

sandboxes.run_command(sandbox.sandbox_id, command="python3 -m http.server 8000", wait_for_port=8000)
sandbox = sandboxes.update_sandbox(
    sandbox.sandbox_id,
    settings=SandboxSettings(ingress=Ingress(public_ports=[PublicPort(port=8000)])),
)
print(sandbox.settings.ingress.public_ports[0].url)
# https://8000-5a4c9z5zw58mvqww.sbx1.sandboxes.pethost.network
```

TypeScript

```
await sandboxes.runCommand({ sandboxId, command: "python3 -m http.server 8000", waitForPort: 8000 });
const updated = await sandboxes.updateSandbox({
  sandboxId,
  settings: { ingress: { publicPorts: [{ port: 8000 }] } },
});
console.log(updated.settings?.ingress?.publicPorts[0]?.url);
```

Go

```
_, err = client.RunCommand(ctx, &sandboxes.RunCommandRequest{SandboxID: id, Command: "python3 -m http.server 8000", WaitForPort: 8000})
if err != nil {
	log.Fatal(err)
}
updated, err := client.UpdateSandbox(ctx, &sandboxes.UpdateSandboxRequest{SandboxID: id, Settings: &sandboxes.SandboxSettings{
	Ingress: &sandboxes.Ingress{PublicPorts: []sandboxes.PublicPort{{Port: 8000}}},
}})
if err != nil {
	log.Fatal(err)
}
fmt.Println(updated.Settings.Ingress.PublicPorts[0].URL)
```

Rust

```
sandboxes
    .run_command(RunCommandRequest {
        sandbox_id: id.clone(),
        command: "python3 -m http.server 8000".into(),
        wait_for_port: 8000,
        ..Default::default()
    })
    .await?;
let ingress = Ingress { public_ports: vec![PublicPort { port: 8000, ..Default::default() }] };
let updated = sandboxes
    .update_sandbox(UpdateSandboxRequest {
        sandbox_id: id.clone(),
        settings: Some(SandboxSettings { ingress: Some(ingress), ..Default::default() }),
        ..Default::default()
    })
    .await?;
if let Some(ingress) = updated.settings.and_then(|settings| settings.ingress) {
    println!("{}", ingress.public_ports[0].url);
}
```

MCP

```
UpdateSandbox {"sandbox_id": "…", "settings": {"ingress": {"public_ports": [{"port": 8000}]}}}
```

Öffne die Adresse in einem Browser oder mit `curl`: Das Verzeichnislisting von `/home/user` kommt zurück. Ein Port, der nicht öffentlich ist, beantwortet nur Requests mit einem Token dafür: [Ports und Vorschauen](https://pethost.dev/de/docs/sandboxes/ports-and-previews/).

## Pausieren lassen

Lass die Sandbox 5 Minuten in Ruhe, und sie pausiert: RAM, Prozesse und Disk bleiben auf ihrem Server, zu 30 % des Preises im Betrieb. Der nächste Aufruf, SSH-Login oder Request an ihren Port weckt sie in etwa 0,1 s, dort, wo sie war. Hier wird sie sofort pausiert, und der Webserver ist nach dem Aufwachen noch da:

Python

```
print(sandboxes.pause_sandbox(sandbox.sandbox_id).state.name)  # PAUSED
check = sandboxes.run_command(sandbox.sandbox_id, command="curl -s -o /dev/null -w '%{http_code}' localhost:8000")
print(check.stdout)  # 200: the server ran on through the pause
print(sandboxes.get_sandbox(sandbox.sandbox_id).state.name)  # RUNNING
```

TypeScript

```
console.log((await sandboxes.pauseSandbox({ sandboxId })).state); // PAUSED
const check = await sandboxes.runCommand({
  sandboxId,
  command: "curl -s -o /dev/null -w '%{http_code}' localhost:8000",
});
console.log(check.stdout); // 200: the server ran on through the pause
console.log((await sandboxes.getSandbox({ sandboxId })).state); // RUNNING
```

Go

```
paused, err := client.PauseSandbox(ctx, &sandboxes.PauseSandboxRequest{SandboxID: id})
if err != nil {
	log.Fatal(err)
}
fmt.Println(paused.State) // PAUSED
check, err := client.RunCommand(ctx, &sandboxes.RunCommandRequest{
	SandboxID: id,
	Command:   "curl -s -o /dev/null -w '%{http_code}' localhost:8000",
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(check.Stdout) // 200: the server ran on through the pause
```

Rust

```
let paused = sandboxes
    .pause_sandbox(PauseSandboxRequest { sandbox_id: id.clone(), ..Default::default() })
    .await?;
println!("{:?}", paused.state); // Paused
let check = sandboxes
    .run_command(RunCommandRequest {
        sandbox_id: id.clone(),
        command: "curl -s -o /dev/null -w '%{http_code}' localhost:8000".into(),
        ..Default::default()
    })
    .await?;
println!("{}", check.stdout); // 200: the server ran on through the pause
```

MCP

```
PauseSandbox {"sandbox_id": "…"}
```

Nach 30 Minuten Leerlauf stoppt sie: Die Prozesse enden, und die Disk geht in den Objektspeicher, wo sie 0,03 $ pro GiB und Monat dessen kostet, was sie hält. `ResumeSandbox` startet sie wieder. [Lebenszyklus und Leerlauf](https://pethost.dev/de/docs/sandboxes/lifecycle/) hat die Timer und wie du sie änderst.

## Löschen

`DeleteSandbox` verwirft RAM und Disk der Sandbox endgültig und antwortet mit ihrem letzten Eintrag, samt dem, was sie verbraucht hat.

Python

```
gone = sandboxes.delete_sandbox(sandbox.sandbox_id)
print(gone.state.name, gone.usage)
# DELETED Usage(running_seconds=11, paused_seconds=0, stored_gib_hours=0.0, cost_micros=0)
# cost_micros is what was charged so far: its last seconds are charged a moment later,
# and get_sandbox(sandbox.sandbox_id).usage then says cost_micros=110
```

TypeScript

```
const gone = await sandboxes.deleteSandbox({ sandboxId });
console.log(gone.state, gone.usage);
```

Go

```
gone, err := client.DeleteSandbox(ctx, &sandboxes.DeleteSandboxRequest{SandboxID: id})
if err != nil {
	log.Fatal(err)
}
fmt.Println(gone.State, *gone.Usage)
```

Rust

```
let gone = sandboxes
    .delete_sandbox(DeleteSandboxRequest { sandbox_id: id, ..Default::default() })
    .await?;
println!("{:?} {:?}", gone.state, gone.usage);
```

MCP

```
DeleteSandbox {"sandbox_id": "…"}
```

## Dasselbe mit der pethost-CLI

`pethost sandbox` oder `pethost sbx` macht jeden dieser Schritte aus einem Terminal, über das Go-SDK. Der Name einer Sandbox funktioniert überall, wo ihre ID funktioniert.

### Step 1: Anmelden

```
$ pethost login
```

Die Anmeldung läuft in deinem Browser. In einem Skript setzt du stattdessen `PETHOST_TOKEN`.

### Step 2: Sandbox erstellen

```
$ pethost sandbox new --name api-dev
✓ Made sandbox api-dev (exdei47yr5je70v5): default, running, from base@17, in <1 s
exdei47yr5je70v5
Next:   pethost sandbox run exdei47yr5je70v5 -- <command>   ·   pethost sandbox shell exdei47yr5je70v5
```

Die ID steht allein auf stdout, also behält `id=$(pethost sandbox new)` sie.

### Step 3: Befehl ausführen und Dateien hineinkopieren

```
$ pethost sandbox run api-dev -- python3 -c 'print(6 * 7)'
42
$ pethost sandbox cp ./app api-dev:app
✓ Copied ./app to exdei47yr5je70v5:app · 2 KB in <1 s
```

### Step 4: Port öffnen

```
$ pethost sandbox run api-dev -d --wait-for-port 8000 -- python3 -m http.server 8000
It runs on in the sandbox. Its output so far:  pethost api GetCommand '{"sandbox_id": "exdei47yr5je70v5", "command_id": "5f2mo5wikluq"}'
5f2mo5wikluq
$ pethost sandbox ports api-dev --open 8000
8000   https://8000-exdei47yr5je70v5.sbx1.sandboxes.pethost.network
```

### Step 5: Pausieren und löschen

```
$ pethost sandbox pause api-dev
exdei47yr5je70v5   paused
$ pethost sandbox rm api-dev --yes
exdei47yr5je70v5   deleted
```

Mit mehreren Workspaces für Sandboxes nennst du einen mit `-w`. [Die Referenz der CLI](https://pethost.dev/docs/cli/) hat jeden Befehl.

## Dasselbe aus deinem Agenten

Ein Agent, der MCP spricht, bekommt Sandboxes als Tools: Füg `https://mcp.pethost.dev/sandboxes` zu Claude Code, Codex, Cursor oder Claude hinzu, melde dich in deinem Browser an und bitte ihn, etwas in einer Sandbox auszuführen. [Agenten verbinden](https://pethost.dev/de/docs/sandboxes/connect-an-agent/) hat die Schritte für jeden.

## Was der Client für dich tut

Zwei Services antworten. Das Panel, unter `console.pethost.dev`, führt den Eintrag jeder Sandbox: Erstellen, Einstellungen, Pause, Fork, Löschen. Der eigene Server der Sandbox führt aus, was in ihr passiert: Befehle, Dateien, den Desktop, Links und Coding-Agenten. Ein Aufruf der zweiten Art braucht die Adresse dieses Servers und ein Token für diese eine Sandbox. Der Client nimmt beides aus der Antwort von `CreateSandbox` oder `ForkSandbox` oder fragt `ConnectSandbox` danach, behält es bis kurz vor dem Ablauf und fragt einmal neu, wenn ein Server es ablehnt. Dein API-Token geht nie an den Server einer Sandbox.

Ein Aufruf, der etwas erstellt, nimmt eine `request_id`. Der TypeScript-Client gibt jedem Aufruf eine, wenn du sie weglässt, und behält sie, wenn er den Aufruf an einer neuen Verbindung wiederholt, also führt der Server ihn einmal aus. Schick deine eigene und schick sie noch einmal, wenn du nach einer verlorenen Antwort wiederholst: Die Wiederholung antwortet 24 Stunden lang mit dem, was der erste Aufruf getan hat.

## In welchem Workspace ein Aufruf handelt

Ein Aufruf, der eine Sandbox nennt, handelt im Workspace dieser Sandbox. Jeder andere Aufruf handelt im Workspace, den sein Request nennt (`workspace`, über ID oder Namen), sonst in dem, mit dem der Client erstellt wurde, sonst in deinem einzigen Workspace für Sandboxes. Ein Token, das mehrere erreicht, und ein Aufruf, der keinen nennt, werden mit `WorkspaceChoice` abgelehnt, das sie auflistet.

## Wenn es nicht funktioniert

- **`FAILED_PRECONDITION` mit `WorkspaceChoice`:** Das Token erreicht mehrere Workspaces für Sandboxes. Nenn einen: `Sandboxes(workspace="...")`, `workspace` im Request oder `-w` bei der CLI.
- **`PERMISSION_DENIED` bei `CreateSandbox`:** Das Token hat keinen Zugriff auf diesen Workspace. Erstell eins unter **Agenten oder deinen Code verbinden** im Workspace selbst oder gib ihm den Zugriff in den Einstellungen.
- **`UNAUTHENTICATED`:** Das Token fehlt, ist vertippt oder gelöscht. Prüf `PETHOST_TOKEN` in der Shell, die das Programm ausführt.
- **`RESOURCE_EXHAUSTED` mit `LimitReached`, `vcpus`:** Die Sandboxes des Workspace halten alle seine vCPUs, laufende wie pausierte. Die Testphase hat 4: eine DEFAULT-Sandbox oder zwei SMALL. Lösch oder stopp eine, oder frag nach `SMALL`.
- **`RESOURCE_EXHAUSTED` mit `LimitReached`, `starts_per_minute`, `_hour` oder `_day`:** zu viele Starts in diesem Zeitfenster. Starts sind kostenlos und begrenzt: `retry_time` sagt, wann der Aufruf passt. [Limits](https://pethost.dev/de/docs/sandboxes/limits/#starts) hat die jedes Tarifs.
- **Der Befehl antwortet mit RUNNING:** Er hat länger als 45 s gedauert und läuft weiter. `GetCommand` mit seiner `command_id` wartet erneut.

[Fehler](https://pethost.dev/de/docs/sandboxes/errors/) listet jede Ablehnung und was zu tun ist.

## Fragen

### Brauche ich ein eigenes SDK für Sandboxes?

Nein. Der Client für Sandboxes ist Teil des Pethost-SDK in Python, TypeScript, Go und Rust: Installier `pethost` und importier sein Modul für Sandboxes.

### Wo bekomme ich ein API-Token?

In der Konsole, in deinem Workspace für Sandboxes: Agenten oder deinen Code verbinden, dann API-Token erstellen. Es beginnt mit `pth_` und wird einmal gezeigt.

### Gibt es eine kostenlose Testphase?

Ja: 7 Tage mit 1 $ Verbrauch und 4 vCPUs, für den ersten Workspace für Sandboxes eines neuen Kontos. Eine Karte ist nötig.

### Was passiert, wenn ich eine Sandbox vergesse?

Sie pausiert nach 5 Minuten Leerlauf und stoppt nach 30, kostet dann also nur ihre gespeicherten Daten. Sie wird nie gelöscht, außer du löschst sie oder setzt `delete_after_idle_seconds`.

### Kann ich die API ohne SDK aufrufen?

Ja. Beide Services sprechen Connect, gRPC und gRPC-Web: Ein POST mit JSON an `/pethost.sandboxes.v1.SandboxService/<Method>` mit deinem Token funktioniert, und die [API-Referenz](https://pethost.dev/docs/sandboxes/api/) hat jedes Feld.

[ZurückSo funktionieren Pethost Agent Sandboxes](https://pethost.dev/de/docs/sandboxes/how-it-works/) [WeiterEinen Agenten über MCP mit Sandboxes verbinden](https://pethost.dev/de/docs/sandboxes/connect-an-agent/)

## Pethost Agent Sandboxes ausprobieren

Eine Testphase von 7 Tagen mit 1 $ Verbrauch und 4 vCPUs, mit Karte. Danach ein Tarif ab 20 $ im Monat, der genauso viel Verbrauch enthält.

[Testphase starten](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Vorlagen](https://pethost.dev/de/templates/)
- [Über uns](https://pethost.dev/about/)
- [Doku](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/de/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [AGB](https://pethost.dev/terms/)
- [Datenschutz](https://pethost.dev/privacy/)
- [Erstattung](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Datenbanken

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

Agent Sandboxes

- [Sandboxes](https://pethost.dev/de/sandboxes/)
- [Preise](https://pethost.dev/de/sandboxes/#pricing)
- [Doku](https://pethost.dev/de/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Vergleiche

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

Alternativen

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