---
title: "Sandboxes pour agents IA : microVM Firecracker · Pethost"
description: "Des microVM Firecracker pour agents IA : démarrage en 0,15 s environ, pause avec la mémoire pendant que l’agent réfléchit, réveil en 0,1 s. 2 vCPU pour 0,018 $/h, à la seconde."
---

Pethost Agent Sandboxes

# Des VM cloud pour agents IA, en pause pendant qu’ils réfléchissent

Chaque sandbox est une microVM Firecracker avec son propre noyau, et vous y êtes root. Elle démarre en 0,15 s environ, se met en pause avec sa mémoire et ses processus quand elle est inactive, et se réveille en 0,1 s environ au prochain appel, exactement là où elle en était ; une connexion SSH ou une requête web la réveille aussi.

Dès **0,018 $** de l’heure pour 2 vCPU et 4 GiB, facturés à la seconde. En pause, 30 % de ce prix. Le démarrage est gratuit.

[Démarrer l’essai gratuit](https://console.pethost.dev/welcome?kind=sandboxes) [Lire la documentation](https://pethost.dev/fr/docs/sandboxes/)

7 jours avec 1 $ de consommation. Une carte est demandée, et le premier paiement de l’offre a lieu à la fin de l’essai.

Douze sandboxes d’un même espace de travail : trois actives, sept en pause avec leur mémoire, deux arrêtées. Ensemble, elles coûtent environ 0,09 $ de l’heure.

- **~0,15 s** pour démarrer une sandbox depuis un template
- **~0,1 s** pour réveiller une sandbox en pause, mémoire et processus intacts
- **0,018 $/h** pour 2 vCPU, 4 GiB et 10 GiB quand elle tourne
- **1 s** de pas de facturation : chaque exécution est arrondie à la seconde supérieure, 10 s au moins
- **0 $** pour créer, dupliquer ou démarrer une sandbox

Mesuré sur nos serveurs le 18 novembre 2026, via une API à 16 ms : création en 123 ms (SMALL) à 158 ms (XLARGE) en médiane, reprise en 124 ms, commande vers une sandbox en pause en 80 ms.

## Ce que les équipes y font tourner

- [**Le code qu’écrit votre modèle** Un produit d’IA exécute le code de chaque utilisateur dans une sandbox à part : une commande et sa sortie en un appel, des fichiers modifiés sur place, un port à sa propre adresse.](https://pethost.dev/fr/sandboxes/code-execution/)
- [**Des agents de code dans le cloud** Claude Code, Codex et OpenCode sont installés dans chaque sandbox. Un appel donne un prompt à un agent, un autre diffuse chacun de ses appels d’outils en direct.](https://pethost.dev/fr/sandboxes/coding-agents/)
- [**RL et évaluations** Dupliquez un environnement préparé, mémoire comprise, en un appel : trois copies prennent environ 0,25 s. Lancez mille exécutions par jour sans frais de démarrage.](https://pethost.dev/fr/sandboxes/fork/)
- [**Piloter un ordinateur** Chrome sur un bureau 1280×800 dans chaque sandbox : cliquer, taper du texte et prendre une capture d’écran en un appel, ou suivre en direct.](https://pethost.dev/fr/sandboxes/computer-use/)

## Trois états, trois prix

La VM d’un agent passe surtout son temps à attendre qu’il réfléchisse. Ses processus ne doivent pas s’arrêter : elle se met donc en pause avec sa mémoire, à 30 % du prix, et se réveille au prochain appel.

Une sandbox active passe en pause après 5 minutes d’inactivité et s’arrête après 30 ; le prochain appel réveille une sandbox en pause en 0,1 s.

- En mémoire Elle travaille, facturée à la seconde au prix de sa taille : 0,018 $ de l’heure pour 2 vCPU et 4 GiB. Chaque exécution est arrondie à la seconde supérieure, 10 s au moins. **0,018 $ de l’heure**
- Sur le disque de son serveur Mémoire, processus et disque conservés, à 30 % du prix d’exécution. Le prochain appel la réveille en 0,1 s environ (une requête web en 0,2 s environ), et un réveil n’est jamais refusé faute de place. **0,0054 $ de l’heure**
- En stockage objet Son disque est conservé, chiffré, à 0,03 $ par GiB et par mois de ses propres données ; ses processus s’arrêtent. Une reprise la redémarre depuis son disque en 0,2 s environ, ou en 10 s environ par GiB s’il a fallu rapatrier son disque. **0,03 $ par GiB et par mois**

Par défaut, une sandbox se met en pause après 5 minutes d’inactivité, s’arrête après 30, et n’est jamais supprimée. Chaque délai se règle par sandbox, et 0 le désactive.

## Tout ce que fait l’ordinateur d’un agent

Quinze choses que fait une sandbox, chacune avec une page qui explique comment elle marche.

- [Trois sandboxes sur un serveur, chacune une microVM avec son propre noyau et son propre shell root ; une quatrième démarre en 0,12 s. Une microVM par sandbox Chaque sandbox est une microVM Firecracker avec son propre noyau Linux, root à l’intérieur et son propre réseau, démarrée depuis un snapshot en 0,15 s environ. Comment ça marche](https://pethost.dev/fr/sandboxes/firecracker-microvm/)
- [Une sandbox se met en pause : sa mémoire passe sur le disque de son serveur et son prix tombe à 30 % ; une requête arrive et elle se réveille en 0,08 s, avec le même processus toujours en marche. La pause garde la mémoire Une sandbox en pause garde sa mémoire et ses processus sur son serveur à 30 % du prix, et le prochain appel la réveille en 0,1 s environ, exactement là où elle en était. Comment ça marche](https://pethost.dev/fr/sandboxes/pause-resume/)
- [Une frise du temps d’inactivité : à 5 minutes, la sandbox se met en pause à 0,0054 $ de l’heure ; à 30 minutes, elle s’arrête en stockage objet à 0,03 $ par GiB et par mois. Se met en pause toute seule Cinq minutes sans appel et une sandbox se met en pause ; trente, et elle s’arrête en stockage objet. Chaque délai se règle par sandbox, et 0 le désactive. Comment ça marche](https://pethost.dev/fr/sandboxes/auto-pause/)
- [Une sandbox active, à l’étape 41 d’une tâche, est dupliquée en trois copies en 0,25 s ; chacune poursuit seule depuis l’étape 41. Duplication, mémoire comprise Copiez une sandbox active, sa mémoire, ses processus et son disque, dans de nouvelles sandboxes en un appel. Trois copies prennent environ un quart de seconde. Comment ça marche](https://pethost.dev/fr/sandboxes/fork/)
- [Deux rangées de secondes : une exécution de 37 secondes facturée 0,000005 $ la seconde, arrondie à la seconde entière, puis des secondes en pause à 30 % ; la créer a coûté 0 $. Facturé à la seconde L’exécution est facturée à la seconde au prix de la taille, dès 0,018 $ de l’heure ; en pause à 30 % ; arrêtée au GiB de données. Créer, dupliquer et démarrer ne coûtent rien. Comment ça marche](https://pethost.dev/fr/sandboxes/per-second-billing/)
- [Un programme appelle run_command et la sortie des tests revient en direct ; il modifie un fichier sur place ; il lance un serveur de développement et l’appel répond dès que le port 5173 écoute. Commandes, fichiers et terminal Lancez une commande et attendez son port, suivez sa sortie en direct, modifiez des fichiers par remplacement exact, ouvrez un terminal dans le navigateur : un appel d’API chacun. Comment ça marche](https://pethost.dev/fr/sandboxes/code-execution/)
- [Un prompt à un agent de code dans une sandbox, et ses appels d’outils qui reviennent en direct : il lit un fichier, le modifie, lance les tests, et le tour se termine avec son nombre de tokens. Agents de code installés Claude Code, Codex et OpenCode tournent dans chaque sandbox en pleine autonomie : un appel donne un prompt à l’un d’eux, un autre diffuse chacun de ses appels d’outils. Comment ça marche](https://pethost.dev/fr/sandboxes/coding-agents/)
- [Un bureau avec Chrome dans une sandbox : le pointeur clique dans un champ, tape une adresse, appuie sur Entrée, et une capture d’écran 1280×800 revient. Un bureau avec Chrome Chaque sandbox a un écran 1280×800 avec Chrome, lancé à la première utilisation : cliquer, taper et capturer l’écran en un appel, ou suivre en direct. Comment ça marche](https://pethost.dev/fr/sandboxes/computer-use/)
- [Une commande ssh vers une sandbox en pause, sur le port 2222, la réveille et ouvre un shell ; puis un fichier est copié avec scp et un port redirigé avec ssh -L. SSH, scp et tunnels standard ssh, scp, sftp et ssh -L vers n’importe quelle sandbox, avec une clé de l’espace de travail ou un token comme mot de passe ; une connexion réveille une sandbox en pause. Comment ça marche](https://pethost.dev/fr/sandboxes/ssh/)
- [Une visite à l’adresse HTTPS du port 3000 réveille une sandbox en pause en 0,2 s et sa page s’affiche ; un port privé répond 200 à une requête avec son token et 401 à une requête sans. Une URL pour chaque port Un serveur de développement sur le port 3000 répond à sa propre adresse HTTPS, publique ou derrière un token, et une visite réveille une sandbox en pause en 0,2 s environ. Comment ça marche](https://pethost.dev/fr/sandboxes/preview-urls/)
- [Une sandbox avec ses paquets et ses images Docker est enregistrée comme template my-app@3 en 1,2 s, et trois nouvelles sandboxes en démarrent sur deux serveurs. Enregistrer une sandbox comme template Enregistrez le disque d’une sandbox, paquets et images Docker compris, comme version de template, et démarrez de nouvelles sandboxes à partir d’elle sur n’importe quel serveur. Comment ça marche](https://pethost.dev/fr/sandboxes/templates/)
- [Un volume de 50 GiB sur un serveur : une sandbox y écrit des fichiers dans /data puis est supprimée ; le volume et ses fichiers restent, et deux nouvelles sandboxes le montent en lecture seule. Des volumes qui survivent aux sandboxes Montez un volume sur un chemin : en lecture-écriture dans une sandbox, ou en lecture seule dans plusieurs. Il reste quand elles sont supprimées, sur le disque de son serveur. Comment ça marche](https://pethost.dev/fr/sandboxes/volumes/)
- [Les connexions d’une sandbox passent une barrière qui autorise pypi.org et *.github.com et refuse example.com avec un 403 ; une question DNS pour un nom absent de la liste reçoit REFUSED, et l’UDP ne sort pas. Trafic sortant autorisé, par nom Listez les domaines, wildcards, IP et CIDR qu’une sandbox peut atteindre ; son DNS ne répond à rien d’autre, aucun UDP ne sort, et un changement s’applique aussitôt. Comment ça marche](https://pethost.dev/fr/sandboxes/egress-allowlist/)
- [Dans la sandbox, la clé d’API est un marqueur ; le proxy de sortie met la vraie clé dans la requête vers api.anthropic.com, et une requête vers un autre hôte garde le marqueur. Des clés qui n’entrent jamais Une sandbox voit un marqueur ; le proxy de sortie le remplace par la vraie clé d’API dans les en-têtes des requêtes HTTPS, seulement pour les hôtes que vous nommez. Comment ça marche](https://pethost.dev/fr/sandboxes/secrets/)
- [Le tableau de bord d’une sandbox : une courbe de CPU, la mémoire utilisée et un flux d’événements : créée, une commande terminée avec le code 0, les hôtes atteints, un tour d’agent avec ses tokens, en pause. Chaque commande, hôte et tour CPU, mémoire, disque et réseau sur 24 heures ; chaque changement d’état, commande, hôte atteint et tour d’agent, en liste ou en flux direct. Comment ça marche](https://pethost.dev/fr/sandboxes/observability/)

## Pour votre agent, votre code et votre terminal

Chacun pilote les sandboxes par la même API et n’a besoin que de votre token Pethost : le serveur où tourne une sandbox est trouvé pour vous, et la connexion établie.

- **Serveur MCP** Ajoutez-le à Claude, ChatGPT, Cursor ou tout client MCP. Il se connecte avec votre compte Pethost, et votre agent s’en sert pour créer, démarrer, dupliquer et mettre en pause des sandboxes. `https://mcp.pethost.dev/sandboxes`Copier
- **SDK** Python, TypeScript, Go et Rust, générés à partir de l’API, chacun avec les mêmes méthodes.
- **CLI** `pethost sandbox` crée, exécute, ouvre et duplique des sandboxes depuis votre terminal.

Python

TypeScript

Go

Rust

CLI

Installer `pip install pethost`

```
from pethost.sandboxes import Sandboxes

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

Installer `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
```

Installer `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
```

Installer `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
```

Installer `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  # un shell dedans
```

## Face aux autres

Prix et fonctionnalités tels que les pages de chaque fournisseur les indiquaient le 21 novembre 2026, pour 2 vCPU et 4 GiB.

### Ce que fait chacun

|  | Pethost | E2B | Daytona | Modal | Vercel Sandbox | boat.dev |
| --- | --- | --- | --- | --- | --- | --- |
| Isolement | Oui microVM Firecracker | Oui Firecracker | En partie conteneurs ; une classe de VM Linux1 | En partie gVisor ; un runtime VM en option2 | Oui Firecracker | Oui une VM par sandbox |
| Exécution, 2 vCPU · 4 GiB, à l’heure | 0,018 $ | 0,1656 $ | 0,1656 $ plus le disque au-delà de 5 GiB | 0,2380 $ | 0,1104 $ à 10 % de CPU, 0,3408 $ à 100 % de CPU | 0,018 $ |
| La pause garde mémoire et processus | Oui 30 % du prix d’exécution | Oui gratuite en pause | En partie classe VM seulement, disque facturé3 | En partie snapshots mémoire en alpha, gardés 7 jours4 | Non système de fichiers seulement | Non « Il n’y a pas de pause » |
| Pas de frais de démarrage | Oui dans les limites de l’offre | Oui | Oui | Oui | En partie 0,60 $ par million de créations | Non 0,03–0,07 $ au-delà des démarrages inclus5 |
| Duplication avec la mémoire | Oui 3 copies en 0,25 s | Oui | En partie classe VM | En partie depuis un snapshot mémoire, en alpha | Non le système de fichiers seulement | Non depuis le dernier snapshot du disque |
| Templates personnalisés | Oui enregistrés depuis une sandbox | Oui un outil qui construit les templates | Oui depuis une image ou un Dockerfile | Oui des images | Oui images et snapshots | Oui snapshots enregistrés |
| Filtrage du trafic sortant | Oui domaines, IP, CIDR, ports | Oui | En partie à partir du niveau 36 | En partie bêta, TLS sur le port 443 | Oui | Non |
| Clés d’API tenues hors de la sandbox | Oui insérées par le proxy | Oui | Pas indiqué sur les pages lues | En partie bêta | Oui | En partie clés d’IA seulement, 1 $ par jour + 1 $ pour 1 000 requêtes |
| SSH, scp et tunnels | Oui | En partie via un proxy WebSocket | Pas indiqué sur les pages lues | Pas indiqué sur les pages lues | Non sa CLI seulement | Oui |
| Bureau pour le computer use | Oui Chrome, 1280×800 | Oui | Oui | Pas indiqué sur les pages lues | Pas indiqué sur les pages lues | Oui |
| Serveur MCP pour les sandboxes | Oui | En partie une passerelle d’outils dans la sandbox | Oui | Pas indiqué sur les pages lues | Pas indiqué sur les pages lues | En partie pour sa documentation seulement |
| SDK | Python, TypeScript, Go, Rust | Python, JS/TS | Python, TS, Ruby, Go, Java | Python, JS, Go | TypeScript | Python, TypeScript |
| Où | UE | États-Unis ; UE sur demande | États-Unis, UE | régions à 1,15–1,75× le prix | 19 régions | UE |
| Facture mensuelle minimale | 20 $, entièrement en consommation | 0 $ sur Hobby | 0 $ | 0 $, avec 30 $ de crédit par mois | 0 $ sur Hobby | 20 $, entièrement en consommation |

Oui En partie Non Pas indiqué sur les pages lues

1. Daytona exécute des conteneurs par défaut ; sa classe de VM Linux sait se mettre en pause et se dupliquer.
2. Modal exécute les sandboxes dans gVisor et propose un runtime VM en option.
3. Daytona ne facture d’une VM en pause que son disque ; la mémoire conservée n’est pas facturée.
4. Les snapshots mémoire de Modal sont en alpha et expirent 7 jours après leur création.
5. boat.dev inclut 12, 60 et 200 démarrages par minute, par heure et par jour dans son offre à 20 $, vend les suivants de 0,03 à 0,07 $ pièce, et refuse au-delà de 6 fois ce nombre (3 fois par minute).
6. Aux niveaux 1 et 2 de Daytona, l’accès réseau se limite aux services essentiels, et une sandbox ne peut pas le changer.

- E2B et Daytona n’ont pas de minimum mensuel : un agent peu actif y coûte moins que notre offre à 20 $. Quatre agents de ce genre y coûtent plus que l’offre.
- E2B ne facture rien pour une sandbox en pause, et Daytona seulement son disque ; la nôtre coûte 30 % du prix d’exécution et garde sa place sur son serveur. Sur un mois, c’est le prix d’exécution qui pèse le plus.

### Une heure de 2 vCPU et 4 GiB

- **Pethost**SMALL **0,018 $**
- **boat.dev**small **0,018 $**
- **Cloudflare Containers**2 vCPU · 4 GiB · 8 GB **0,052 $** à 10 % de CPU 0,182 $ à 100 % de CPU
- **Northflank** **0,0667 $**
- **Vercel Sandbox** **0,1104 $** à 10 % de CPU 0,3408 $ à 100 % de CPU
- **E2B** **0,1656 $**
- **Daytona** **0,1656 $** plus le disque au-delà de 5 GiB
- **Blaxel** **0,1656 $** en activité
- **Modal** **0,2380 $**
- **Runloop**MEDIUM **0,3195 $**

Une heure d’exécution, 2 vCPU et 4 GiB, calcul seul, au prix public de chaque fournisseur le 21 novembre 2026.

### Deux usages, sur un mois

#### Un agent : une sandbox, 2 heures d’activité et 22 au repos par jour

| Fournisseur | Au repos | Mémoire gardée | Consommation | Facture |
| --- | --- | --- | --- | --- |
| Pethost | en pause | Oui | 4,64 $ | **20 $**l’offre, qui couvre environ quatre agents de ce genre |
| E2B | en pause, gratuitement | Oui | 9,94 $ | **9,94 $**sur Hobby, avec une pause toutes les heures ; 159,94 $ sur Pro |
| Daytona | classe VM, en pause | Oui | 10,17 $ | **10,17 $** |
| Blaxel | en veille | Oui | 11,74 $ | **11,74 $** |
| boat.dev | arrêtée | Non | 1,08 $ | **20 $** |
| Modal | un snapshot, 24 h au plus | Non | 14,28 $ | **0 $**dans le crédit mensuel de 30 $ |

Mémoire gardée, le mois de l’agent coûte ici 4,64 $, moins de la moitié de ce que facturent E2B, Daytona ou Blaxel. boat.dev coûte moins quand la mémoire peut être perdue. Pour un seul agent, E2B et Daytona facturent moins que notre offre à 20 $ ; à partir de quatre agents, c’est l’offre qui coûte moins.

#### Évaluations : 1 000 sandboxes par jour, 60 secondes chacune

| Fournisseur | Calcul | Frais de démarrage | Facture |
| --- | --- | --- | --- |
| Pethost | 9,00 $ | 0 $ | 20 $ |
| boat.dev | 9,00 $ | 144 $ sur son offre à 100 $, ou 1 500 $ sur son offre à 20 $ | 244 $ |
| E2B | 82,80 $ | 0 $ | 82,80 $ sur Hobby |
| Daytona | 82,96 $ | 0 $ | 82,96 $ |
| Modal | 118,98 $ | 0 $ | 88,98 $ après le crédit de 30 $ |
| Vercel Sandbox | 55,22 $ à 10 % de CPU, 170,42 $ à 100 % de CPU | 0,02 $ | 55,22 $ à 10 % de CPU, 170,42 $ à 100 % de CPU |

Des sandboxes courtes et nombreuses coûtent le moins ici. Chez boat.dev, les frais de démarrage font l’essentiel de la facture.

Avec l’offre à 20 $, 1 000 démarrages par jour répartis sur la journée (environ 42 par heure) restent dans ses démarrages gratuits, et 10 sandboxes SMALL tournent en même temps.

2 vCPU et 4 GiB partout, un mois de 30 jours, 5 GiB de données propres à la sandbox conservées pendant l’inactivité. Les crédits qui s’épuisent ne sont pas comptés ; ceux qui reviennent chaque mois le sont.

### Chaque démarrage que boat.dev vend, gratuit ici

boat.dev inclut des démarrages dans chaque offre, vend les suivants de 0,03 à 0,07 $ pièce, et refuse au-delà de six fois le nombre inclus (trois fois par minute). Nos offres coûtent le même prix, et leurs démarrages sont gratuits jusqu’à exactement ces nombres. Réveiller une sandbox en pause n’est jamais un démarrage.

| Offre | boat.dev inclut | boat.dev vend jusqu’à, puis refuse | Pethost, gratuits |
| --- | --- | --- | --- |
| 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 |

Démarrages par minute · par heure · par jour.

## Le prix de l’offre, c’est votre consommation

Le prix mensuel de chaque offre vous revient en entier en consommation, aux tarifs ci-dessous. Au-delà, c’est un solde que vous créditez qui paie : de 10 $ à 1 000 $, et il n’expire jamais.

- **20 $**par mois Consommation incluse20 $vCPU en même temps20les sandboxes actives et en pause comptentPlus grande tailleLARGEVolumes100 GiBTemplates5 GiBDémarrages gratuits36 · 360 · 1 200par minute · par heure · par jour [Démarrer l’essai gratuit](https://console.pethost.dev/welcome?kind=sandboxes)
- **100 $**par mois Consommation incluse100 $vCPU en même temps128les sandboxes actives et en pause comptentPlus grande tailleXLARGEVolumes600 GiBTemplates30 GiBDémarrages gratuits90 · 1 260 · 5 040par minute · par heure · par jour [Démarrer l’essai gratuit](https://console.pethost.dev/welcome?kind=sandboxes)
- **500 $**par mois Consommation incluse500 $vCPU en même temps700les sandboxes actives et en pause comptentPlus grande tailleXLARGEVolumes3 500 GiBTemplates175 GiBDémarrages gratuits195 · 2 520 · 10 080par minute · par heure · par jour [Démarrer l’essai gratuit](https://console.pethost.dev/welcome?kind=sandboxes)
- **2 000 $**par mois Consommation incluse2 000 $vCPU en même temps3 000les sandboxes actives et en pause comptentPlus grande tailleXLARGEVolumes16 000 GiBTemplates800 GiBDémarrages gratuits270 · 3 600 · 14 400par minute · par heure · par jour [Démarrer l’essai gratuit](https://console.pethost.dev/welcome?kind=sandboxes)

### Essai gratuit

7 jours avec 1 $ de consommation, 4 vCPU en même temps et des tailles jusqu’à DEFAULT. Une carte est demandée, et le premier paiement de l’offre a lieu à la fin de l’essai ou quand vous démarrez l’offre.

vCPU en même temps4 Plus grande tailleDEFAULT Volumes10 GiB Démarrages gratuits15 · 75 · 225par minute · par heure · par jour

| Taille | Active | En pause |
| --- | --- | --- |
| SMALL2 vCPU · 4 GiB · 10 GiB | **0,018 $** de l’heure | 0,0054 $ de l’heure |
| DEFAULT4 vCPU · 8 GiB · 20 GiB | **0,036 $** de l’heure | 0,0108 $ de l’heure |
| LARGE8 vCPU · 16 GiB · 40 GiB | **0,072 $** de l’heure | 0,0216 $ de l’heure |
| XLARGE16 vCPU · 32 GiB · 80 GiB | **0,144 $** de l’heure | 0,0432 $ de l’heure |

- Arrêtée : 0,03 $ par GiB et par mois des données propres à la sandbox, jamais pour l’espace vide.
- Volumes : 0,20 $ par GiB et par mois de leur taille.
- Templates : gratuits, dans la place que donne l’offre.
- 20 $ de consommation, c’est 1 111 heures d’une sandbox SMALL active, ou 3 704 heures en pause.

Prix en dollars US, hors taxes. Dans l’UE, vous payez les mêmes montants en euros, plus la TVA.

## Questions

**Comment une sandbox est-elle isolée des autres ?**

Chaque sandbox est une microVM Firecracker à part, avec son propre noyau Linux, lancée dans le jailer de Firecracker : son propre chroot, un utilisateur sans privilèges, des limites cgroup, un filtre seccomp et son propre namespace réseau. À l’intérieur, vous êtes root. La virtualisation imbriquée est désactivée, et les clés d’API liées comme secrets n’entrent jamais dans la VM.

**Les vCPU et la mémoire sont-ils partagés avec d’autres sandboxes ?**

Le matériel est partagé, comme chez tout cloud de cette gamme de prix : de nombreuses sandboxes tournent sur un même serveur, et chacune est tenue à sa taille, jamais plus que le temps de ses vCPU et sa mémoire. Un voisin chargé peut ralentir le CPU d’une sandbox, et un serveur à court de mémoire met en pause plus tôt les sandboxes inactives depuis une minute ou plus, que le prochain appel réveille comme d’habitude.

**Où tournent les sandboxes, et où sont mes données ?**

Dans l’UE. Les sandboxes tournent sur nos serveurs dans l’UE, et le disque d’une sandbox arrêtée comme vos templates sont gardés en stockage objet dans l’UE, chiffrés, chacun avec sa propre clé. Il n’y a qu’une région, donc rien à choisir. La [politique de confidentialité](https://pethost.dev/privacy/) indique qui traite quoi.

**Que se passe-t-il quand mon agent ne fait plus rien ?**

Après 5 minutes sans appel, session SSH ni requête web, la sandbox se met en pause : mémoire et processus sont gardés, à 30 % du prix d’exécution, et le prochain appel la réveille en 0,1 s environ. Après 30 minutes, elle s’arrête : son disque part en stockage objet à 0,03 $ par GiB et par mois, et ses processus prennent fin. Rien n’est supprimé, sauf si vous réglez un délai pour cela. Une commande lancée avec `keep_awake` la garde éveillée.

**Y a-t-il des GPU ?**

Non. La plus grande taille a 16 vCPU, 32 GiB de mémoire et 80 GiB de disque.

**Quelles sont les limites ?**

Une offre fixe combien de vCPU ses sandboxes actives et en pause occupent en même temps (20 avec l’offre à 20 $, soit 10 sandboxes SMALL), sa plus grande taille, et ses démarrages gratuits par minute, par heure et par jour. Le nombre de sandboxes arrêtées n’est pas limité, et aucune sandbox n’a de durée de vie limitée. Une duplication crée jusqu’à 100 copies en un appel, autant que le serveur de la sandbox a de place, et une sandbox ouvre jusqu’à 20 ports publics.

**Comment fonctionne la facturation ?**

Le prix mensuel d’une offre est de la consommation incluse. Une sandbox active est facturée à la seconde au prix de sa taille, chaque exécution arrondie à la seconde supérieure, 10 s au moins ; une sandbox en pause, à 30 % de ce prix ; une sandbox arrêtée, selon les GiB qu’occupent ses propres données. Créer, dupliquer et démarrer ne coûtent rien. La consommation au-delà de l’offre est payée par un solde que vous créditez, de 10 $ à 1 000 $, et qui n’expire jamais.

Si les deux sont épuisés, les sandboxes actives et en pause sont arrêtées, et rien de nouveau ne démarre tant que l’argent n’arrive pas ; rien n’est supprimé.

**En quoi est-ce différent d’E2B ?**

Les deux exécutent chaque sandbox dans une microVM Firecracker, et les deux gardent mémoire et processus quand une sandbox se met en pause. 2 vCPU et 4 GiB coûtent ici 0,018 $ de l’heure en exécution, et 0,1656 $ chez E2B, qui ne facture rien en pause, là où nous facturons 30 %. E2B a une offre Hobby gratuite avec un crédit unique de 100 $ ; nos offres commencent à 20 $ par mois, entièrement en consommation. Ici, les sandboxes ont un SSH standard et tournent dans l’UE ; E2B tourne aux États-Unis, sauf si vous demandez son cluster européen. Les chiffres d’E2B viennent de ses propres pages, au 21 novembre 2026.

**Y a-t-il un essai gratuit ?**

Oui : 7 jours avec 1 $ de consommation, 4 vCPU en même temps et des tailles jusqu’à DEFAULT, soit 55 heures d’une sandbox SMALL active. Une carte est demandée, et le premier paiement de l’offre a lieu à la fin de l’essai.

## Donnez un ordinateur à votre agent en 0,15 s

[Démarrer l’essai gratuit](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/fr/templates/)
- [À propos](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/fr/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Conditions](https://pethost.dev/terms/)
- [Confidentialité](https://pethost.dev/privacy/)
- [Remboursements](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bases de données

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

Agent Sandboxes

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

Comparatifs

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

Alternatives

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