−25%

auf Windows bei Jahreszahlung, bis 31.10. Zu den Tarifen

EQVPS
Loslegen
Code-Sandboxes

Firecracker-Sandboxes für KI-Agenten

Führen Sie ungeprüften, KI-generierten Code in einer isolierten Linux-MicroVM aus, die in etwa einer Sekunde startet. Aufrufbar aus Python, TypeScript oder jedem MCP-Client. Sekundengenau vom Krypto-Guthaben abgerechnet — kein Abo, kein Minimum, kein KYC.

$1 gratis zum Testen — E-Mail bestätigen, dann wird es Ihrer ersten Sandbox angerechnet, ohne Aufladung

pip install eqvps
export EQVPS_API_KEY="<your API token>"
python -c "from eqvps import Sandbox; s = Sandbox.create(); print(s.run('print(2+2)').stdout); s.kill()"

TypeScript: npm i @eqvps/sdk · MCP: https://mcp.eqvps.com/mcp

Warum nicht Docker oder der eigene Server?

Eine Sandbox ist dafür da, nicht vertrauenswürdigen Code auszuführen — ein fremdes GitHub-Repo, ein ungeprüftes Paket, Code, den eine KI gerade geschrieben hat — dort, wo er nichts von Ihnen erreicht.

Auf Ihrem Laptop oder Server

  • Läuft neben Ihren SSH-Schlüsseln, API-Tokens und .env-Dateien
  • Kann Ihre Datenbanken, Ihren Quellcode und Ihre Browser-Sitzungen lesen
  • Ein Container teilt den Kernel mit dem Host — ein Ausbruch, und er ist auf Ihrer Maschine
  • Was er installiert oder laufen lässt, bleibt bei Ihnen

In einer EQVPS-Sandbox

  • Eigene Firecracker-MicroVM: separater Kernel, CPU, RAM und Datenträger
  • Nichts von Ihnen darin — nur die Dateien und Variablen, die Sie übergeben
  • Ausgehendes Internet für pip, npm und git; kein SSH, keine eingehenden Ports
  • kill() löscht die VM samt Datenträger — es bleibt nichts zurück

Faustregel: Wenn Sie den Code nicht geschrieben und nicht gelesen haben, führen Sie ihn zuerst in einer Sandbox aus.

Anwendungsfälle

KI-Code ausführen und Code isoliert testen — jeder Fall braucht nur ein paar SDK-Zeilen oder MCP-Aufrufe.

Ein unbekanntes GitHub-Projekt prüfen

Klonen, Abhängigkeiten installieren, Tests laufen lassen. Ist der Code bösartig, sieht er nur eine leere VM.

Python SDK
sb = Sandbox.create(tariff="standard")
r = sb.exec(
    "git clone https://github.com/owner/repo app"
    " && cd app && pip install -r requirements.txt"
    " && pytest -q", background=True).wait()
print(r.exit_code); sb.kill()

Tests laufen lassen, ohne die Produktion anzufassen

PHP mit Composer und PHPUnit, Python mit pytest, Node mit npm test — auf einer sauberen Maschine statt auf Ihrem Server. Root und apt sind verfügbar.

Python SDK
# app/ = your repo (git clone or sb.upload)
sb.exec("apt-get update -qq && apt-get install -y -qq"
        " php-cli php-xml php-mbstring composer",
        background=True).wait()
sb.exec("cd app && composer install -q"
        " && vendor/bin/phpunit", background=True).wait()

Ein Wegwerf-PostgreSQL oder -Node für Migration oder Build

Datenbank per apt installieren, Migration testen, Frontend bauen — und alles mit einem Aufruf löschen. Für eine Datenbank standard oder größer wählen.

Python SDK
sb = Sandbox.create(tariff="standard")
sb.exec("apt-get update -qq && apt-get install -y -qq"
        " postgresql", background=True).wait()
sb.exec("runuser -u postgres -- createdb app")
sb.exec("cd app && npm ci && npm run migrate"
        " && npm run build", background=True).wait()

Ein KI-Programmierer, der seine Arbeit selbst testet

Der Agent erstellt eine Sandbox, schreibt den Code, startet die Tests, behebt Fehler und löscht die Sandbox, sobald alles grün ist.

MCP
create_sandbox  {"tariff": "small"}
upload_file     app/main.py, app/test_main.py
exec_command    "cd app && pytest -q"   → 2 failed
upload_file     app/main.py             (fixed)
exec_command    "cd app && pytest -q"   → passed
kill_sandbox

Ihre erste Sandbox in 4 Schritten

  1. 01

    Registrieren

    Nur E-Mail — oder Ihr Agent ruft register_account über MCP auf. Keine Karte, kein KYC.

  2. 02

    API-Token erstellen

    Dashboard → Einstellungen → API-Tokens.

  3. 03

    SDK installieren

    pip install eqvps oder npm i @eqvps/sdk, dann EQVPS_API_KEY setzen.

  4. 04

    Code ausführen

    Sandbox.create() → run() → kill(). Ihr Test-Dollar deckt die ersten Läufe.

Was Sie bekommen

Firecracker-Isolation

Jede Sandbox ist eine eigene MicroVM mit eigenem Kernel, eigener Festplatte und CPU/RAM-Limits — kein geteilter Container.

In etwa einer Sekunde bereit

Python 3.12 mit pip, Node.js 22 mit npm, bash, git und curl. Ausgehendes Internet funktioniert, keine eingehenden Ports.

Sekundengenau, ohne Mindestbetrag

Sie zahlen nur für zugewiesene vCPU und RAM, solange sie läuft. Kein Abo, kein monatliches Minimum.

MCP-Sandbox integriert

create_sandbox, run_code und exec_command sind MCP-Tools — Claude Code, Cursor und andere Clients nutzen sie direkt.

Ohne KYC, Krypto-Guthaben

Konto nur per E-Mail und Prepaid-Guthaben in USDC, USDT, BTC, XMR und mehr — dasselbe Guthaben wie für Ihre VPS.

Temporär oder dauerhaft

Wegwerf-Sandboxes für eine Aufgabe oder dauerhafte, die ihre Festplatte bis zu 30 Tage behalten. Umgebungsvariablen und Ausgabenlimits inklusive.

Preise

$0.040 pro vCPU-Stunde + $0.013 pro GiB-Stunde, sekundengenau (mindestens 60 s). Dauerhafte Sandboxes werden pro angefangener Stunde abgerechnet, und ein Monat kostet nie mehr als die Obergrenze in der letzten Spalte.

TarifvCPURAMFestplatteNetzwerkPro StundePersistent, max. pro Monat
micro0.25512 MB3 GB50 Mbit/s$0.0165$9.03
small0.51 GB5 GB100 Mbit/s$0.0330$18.07
standard12 GB10 GB200 Mbit/s$0.0660$36.14
plus24 GB15 GB300 Mbit/s$0.1320$72.27
pro48 GB20 GB400 Mbit/s$0.2640$144.54
max816 GB40 GB500 Mbit/s$0.5280$289.08

Die letzte Spalte ist eine Obergrenze, kein Festpreis: Eine persistente Sandbox, die nur einen Teil des Monats läuft, kostet weniger.

Persistente Sandbox: eine KI-Entwicklungsumgebung

Für lange Agenten-Aufgaben und Projekte, zu denen Sie zurückkehren: Datenträger, installierte Pakete und Dateien bleiben bis zu 30 Tage erhalten, Sie verbinden sich per Sandbox-ID wieder.

So funktioniert die Obergrenze: Eine laufende persistente Sandbox wird pro angefangener Stunde abgerechnet, und ein Kalendermonat kostet nie mehr als Stundenpreis × 730 h − 25 %. Beispiel standard: $0.0660/h, also höchstens $36.14 im Monat — 10 Tage rund um die Uhr kosten $15.84.

sb = Sandbox.create(mode="persistent", tariff="standard")
print(sb.id)          # keep it — disk lives up to 30 days
# … tomorrow, from any machine:
sb = Sandbox.connect("sb_…")
sb.exec("cd app && git pull && pytest -q")

Eine Ergänzung zum VPS, kein Ersatz

Gleiches Konto, gleiches Guthaben — jedes für seinen Zweck.

VPS — ein Server, der bleibt

SSH, öffentliche IP, offene Ports und Dienste, die monatelang laufen: eine Website, ein Bot, eine Datenbank.

Sandbox — Wegwerf-Rechenleistung für KI

Erstellen → ausführen → löschen. Kein SSH und keine eingehenden Ports, mit Absicht: Befehle und Dateien laufen über API, MCP oder SDK.

SSH und offene Ports nötig? Zu den VPS-Tarifen →

Aus Ihrem MCP-Client

Einmal verbinden, dann den Agenten in normalen Worten bitten — er erstellt die Sandbox, führt den Code aus und löscht sie.

claude mcp add --transport http eqvps https://mcp.eqvps.com/mcp \
  --header "Authorization: Bearer $EQVPS_API_KEY"
Erstelle eine kleine Sandbox, führe in Python print(2 + 2) aus, zeig mir die Ausgabe und lösch die Sandbox.

FAQ

Was ist eine EQVPS-Sandbox?

Eine kleine Linux-MicroVM (Firecracker), die Sie per API, SDK oder MCP erstellen, um Code auszuführen, der nicht auf Ihren eigenen Rechner gehört — KI-generierte Skripte, Tests, Datenjobs. Sie startet in etwa einer Sekunde und wird gelöscht, wenn Sie fertig sind.

Wie ist sie isoliert?

Jede Sandbox ist eine separate Firecracker-MicroVM mit eigenem Kernel, eigener Festplatte und CPU- und Speicherlimits. Ausgehendes Internet ist offen; es gibt keine eingehenden Ports und kein SSH — Befehle und Dateien laufen über die API.

Was kostet es? Gibt es eine kostenlose Testphase?

$0.040 pro vCPU-Stunde plus $0.013 pro GiB-Stunde, sekundengenau; der kleinste Tarif kostet $0.0165 pro Stunde. Ein neues Konto erhält bei seiner ersten Sandbox $1 Sandbox-Guthaben gratis (einmal pro Person), gültig 14 Tage. Die Testphase wird gutgeschrieben, nachdem Sie Ihre E-Mail mit einem 6-stelligen Code bestätigt haben.

Brauche ich KYC oder eine Karte?

Nein. Mit E-Mail registrieren und Prepaid-Guthaben in Krypto aufladen (oder per Karte auf der Zahlungsseite). Dasselbe Guthaben bezahlt Sandboxes und VPS.

Kann mein KI-Agent sie selbstständig nutzen?

Ja. Über MCP kann ein Agent sich registrieren, Preise mit sandbox_pricing abfragen, eine Sandbox erstellen und Code ausführen — ohne Menschen. Aus Code nutzen Sie das Python- oder TypeScript-SDK.

Kann ich per SSH in eine Sandbox oder einen Port öffnen?

Nein, mit Absicht: Eine Sandbox hat kein SSH und keine eingehenden Ports — Befehle und Dateien laufen über API, MCP oder SDK, ausgehendes Internet funktioniert. Für SSH, eine öffentliche IP und dauerhafte Dienste nehmen Sie einen EQVPS-VPS mit demselben Guthaben.

Jetzt testen — der erste Dollar geht auf uns

Kein Abo, kein KYC. Registrieren, Token erstellen und die erste Sandbox in wenigen Minuten starten.