API d'ordinateur agent

Essayez-le dans l’API Playground.

URL de base

https://api.rebyte.ai/v1

Authentification

Chaque requête nécessite un en-tête API_KEY. Obtenez votre clé depuis Paramètres > Clés API.

curl https://api.rebyte.ai/v1/tasks \
  -H "API_KEY: rbk_your_key_here"

Le nom de l’en-tête est insensible à la casse. API_KEY, api-key et x-api-key fonctionnent tous.

---

Points de terminaison

Méthode	Chemin	Description
POST	/tasks	Créer une tâche
GET	/tasks	Lister les tâches
GET	/tasks/:id	Obtenir une tâche avec son statut et l’historique des invites
POST	/tasks/:id/prompts	Envoyer une invite de suivi
PATCH	/tasks/:id/visibility	Changer la visibilité de la tâche
DELETE	/tasks/:id	Supprimer (logiquement) une tâche
GET	/tasks/:id/events	Flux SSE des événements d’exécution
POST	/files	Obtenir une URL de téléchargement de fichier signée
POST	/webhooks	Enregistrer un webhook
GET	/webhooks	Lister les webhooks
GET	/webhooks/:id	Obtenir les détails du webhook
DELETE	/webhooks/:id	Supprimer un webhook
Tous les chemins sont relatifs à l’URL de base (https://api.rebyte.ai/v1).

---

Tâches

Créer une tâche

POST /tasks

Crée une nouvelle tâche. Par défaut, provisionne une nouvelle VM (ordinateur agent). Passez workspaceId pour exécuter la tâche sur un espace de travail existant à la place — cela évite le provisionnement et est significativement plus rapide.

L’appel est bloquant jusqu’à ce que la VM soit provisionnée et que la première invite soit soumise.

Corps de la requête :

Champ	Type	Requis	Description
prompt	string	Oui	Description de la tâche (max 100 000 caractères)
executor	string	Non	claude (par défaut), gemini, codex, opencode
model	string	Non	Niveau de modèle pour l’exécuteur. Voir Modèles.
workspaceId	string	Non	UUID d’un espace de travail existant à réutiliser
files	object[]	Non	Fichiers de POST /files. Chaque : {"id": "...", "filename": "..."}
skills	string[]	Non	Slugs de compétences (par exemple, ["deep-research", "pdf"])
githubUrl	string	Non	Dépôt GitHub au format propriétaire/dépôt
branchName	string	Non	Nom de la branche (par défaut : main)

curl -X POST https://api.rebyte.ai/v1/tasks \
  -H "API_KEY: rbk_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Build a REST API with Express and add tests",
    "executor": "claude",
    "skills": ["deep-research"],
    "githubUrl": "your-org/your-repo"
  }'

Réponse (201) :

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "workspaceId": "660e8400-e29b-41d4-a716-446655440001",
  "url": "https://app.rebyte.ai/run/550e8400-e29b-41d4-a716-446655440000",
  "status": "running",
  "createdAt": "2026-01-28T12:00:00.000Z"
}

Enregistrez le workspaceId de la réponse pour créer des tâches de suivi sur le même ordinateur agent :

# First task -- provisions a new VM
RESP=$(curl -s -X POST https://api.rebyte.ai/v1/tasks \
  -H "API_KEY: rbk_xxx" -H "Content-Type: application/json" \
  -d '{"prompt": "Set up the project"}')
WS_ID=$(echo $RESP | jq -r '.workspaceId')

# Second task -- reuses the same VM (much faster)
curl -s -X POST https://api.rebyte.ai/v1/tasks \
  -H "API_KEY: rbk_xxx" -H "Content-Type: application/json" \
  -d "{\"prompt\": \"Now add tests\", \"workspaceId\": \"$WS_ID\"}"

Modèles

Les modèles disponibles dépendent de l’exécuteur :

Exécuteur	Modèles disponibles	Par défaut
claude	claude-sonnet-4.6, claude-opus-4.6, gemini-3.1-pro, gpt-5.3-codex, gpt-5.4, minimax-m2.7, kimi-k2.5, glm-5, gemini-3-flash	claude-sonnet-4.6
codex	gpt-5.4, gpt-5.3-codex	gpt-5.4
gemini	auto-gemini-3 (auto-routes between flash and pro)	auto-gemini-3
opencode	Same as claude	gemini-3.1-pro

Avec BYOK (apportez votre propre clé API), seuls les modèles du fournisseur natif de l’exécuteur sont disponibles (par exemple, l’exécuteur claude avec BYOK n’obtient que claude-sonnet-4.6 et claude-opus-4.6).

Lister les tâches

GET /tasks?limit=50&offset=0

Retourne les tâches créées via l’API, triées par date de création (les plus récentes en premier).

Paramètre	Type	Par défaut	Description
limit	number	50	Résultats par page (max 100)
offset	number	0	Décalage de pagination

curl "https://api.rebyte.ai/v1/tasks?limit=10" \
  -H "API_KEY: rbk_xxx"

Réponse :

{
  "data": [
    {
      "id": "550e8400-...",
      "url": "https://app.rebyte.ai/run/550e8400-...",
      "title": "Build REST API with Express",
      "executor": "claude",
      "model": "claude-sonnet-4.6",
      "createdAt": "2026-01-28T12:00:00.000000+00:00",
      "completedAt": "2026-01-28T12:05:00.000000+00:00"
    }
  ],
  "total": 42,
  "limit": 10,
  "offset": 0
}

Obtenir une tâche

GET /tasks/:id

Retourne les détails complets de la tâche, y compris l’historique des invites et le statut dérivé.

curl https://api.rebyte.ai/v1/tasks/550e8400-... \
  -H "API_KEY: rbk_xxx"

Réponse :

{
  "id": "550e8400-...",
  "url": "https://app.rebyte.ai/run/550e8400-...",
  "status": "running",
  "title": "Build REST API with Express",
  "executor": "claude",
  "model": "claude-sonnet-4.6",
  "createdAt": "2026-01-28T12:00:00.000000+00:00",
  "completedAt": null,
  "prompts": [
    {
      "id": "660e8400-...",
      "status": "running",
      "submittedAt": "2026-01-28T12:05:00.000000+00:00",
      "completedAt": null
    },
    {
      "id": "550e8400-...",
      "status": "succeeded",
      "submittedAt": "2026-01-28T12:00:01.000000+00:00",
      "completedAt": "2026-01-28T12:03:00.000000+00:00"
    }
  ]
}

Le statut de la tâche est dérivé des états des invites :

Statut	Condition
running	Toute invite est pending ou running
completed	Toutes les invites sont terminales, la dernière est succeeded
failed	Toutes les invites sont terminales, la dernière est failed
canceled	Toutes les invites sont terminales, la dernière est canceled

Envoyer un suivi

POST /tasks/:id/prompts

Envoyer une invite de suivi à une tâche en cours ou terminée. Si la VM est arrêtée, elle est automatiquement redémarrée.

Champ	Type	Requis	Description
prompt	string	Oui	Invite de suivi (max 100 000 caractères)
skills	string[]	Non	Slugs de compétences supplémentaires pour cette invite

curl -X POST https://api.rebyte.ai/v1/tasks/550e8400-.../prompts \
  -H "API_KEY: rbk_xxx" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Now add authentication with JWT"}'

Réponse (201) :

{
  "promptId": "770f9500-..."
}

Diffuser les événements (SSE)

GET /tasks/:id/events

Ouvre un flux d’événements envoyés par le serveur (Server-Sent Events) pour la dernière invite de la tâche. Les événements incluent la sortie de l’agent (stdout, stderr), les appels d’outils et les signaux de complétion.

curl -N https://api.rebyte.ai/v1/tasks/550e8400-.../events \
  -H "API_KEY: rbk_xxx"

Le flux émet deux types d’événements :

• event — événements d’exécution (sortie de l’agent, appels d’outils)
• done — événement final avec le statut de complétion, puis le flux se ferme

Changer la visibilité

PATCH /tasks/:id/visibility

Champ	Type	Requis	Description
visibility	string	Oui	private, shared, ou public

Niveau	Qui peut voir
private	Seul le propriétaire de la clé API
shared	Tous les membres de l’organisation (par défaut)
public	Toute personne ayant le lien (lecture seule)

curl -X PATCH https://api.rebyte.ai/v1/tasks/550e8400-.../visibility \
  -H "API_KEY: rbk_xxx" \
  -H "Content-Type: application/json" \
  -d '{"visibility": "public"}'

Lorsqu’il est défini sur public, la réponse inclut une shareUrl pour un accès non authentifié.

Supprimer une tâche

DELETE /tasks/:id

Supprime (logiquement) la tâche. Retourne 204 No Content.

curl -X DELETE https://api.rebyte.ai/v1/tasks/550e8400-... \
  -H "API_KEY: rbk_xxx"

---

Fichiers

Téléchargez des fichiers à joindre aux tâches. Utilise un flux d’URL signée en deux étapes.

Étape 1 : Obtenir l’URL de téléchargement

POST /files

Champ	Type	Requis	Description
filename	string	Oui	Nom du fichier (max 255 caractères)
contentType	string	Non	Type MIME (par défaut : application/octet-stream)

Réponse (201) :

{
  "id": "550e8400-...",
  "filename": "data.csv",
  "uploadUrl": "https://storage.googleapis.com/...",
  "maxFileSize": 52428800
}

L’URL de téléchargement expire dans 1 heure.

Étape 2 : Télécharger le fichier

curl -X PUT "UPLOAD_URL_FROM_STEP_1" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @data.csv

Étape 3 : Joindre à la tâche

Passez id et filename de l’Étape 1 lors de la création d’une tâche :

{
  "prompt": "Analyze the uploaded data",
  "files": [
    {"id": "550e8400-...", "filename": "data.csv"}
  ]
}

Les fichiers sont automatiquement copiés dans la VM de la tâche lorsque l’exécution commence.

---

Webhooks

Recevez des notifications HTTP POST lorsque des événements de tâche se produisent. Les webhooks sont universels — ils se déclenchent pour toutes les tâches de votre organisation, qu’elles soient créées via l’API, l’interface utilisateur ou tout autre canal.

Événements

Événement	Se déclenche quand
task.created	Une nouvelle tâche est créée
task.running	L’agent commence l’exécution
task.completed	La tâche se termine avec succès
task.failed	La tâche échoue
task.canceled	La tâche est annulée par l’utilisateur

Créer un webhook

POST /webhooks

Champ	Type	Requis	Description
url	string	Oui	URL du point de terminaison HTTPS
events	string[]	Oui	Événements auxquels s’abonner
description	string	Non	Libellé lisible par l’homme (max 500 caractères)
secret	string	Non	Secret pré-partagé (max 500 caractères). Lorsqu’il est défini, inclus comme en-tête X-Webhook-Secret dans chaque livraison.

# Webhook without secret
curl -X POST https://api.rebyte.ai/v1/webhooks \
  -H "API_KEY: rbk_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/webhook",
    "events": ["task.completed", "task.failed"]
  }'

# Webhook with pre-shared secret
curl -X POST https://api.rebyte.ai/v1/webhooks \
  -H "API_KEY: rbk_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/webhook",
    "events": ["task.completed", "task.failed"],
    "secret": "my-shared-secret-value"
  }'

Réponse (201) :

{
  "id": "880e8400-...",
  "url": "https://your-server.com/webhook",
  "events": ["task.completed", "task.failed"],
  "description": null,
  "hasSecret": true,
  "isActive": true,
  "createdAt": "2026-01-28T12:00:00.000Z",
  "lastTriggeredAt": null,
  "failureCount": 0
}

Notes de comportement :

• URLs en double : l’enregistrement de la même URL deux fois renvoie le webhook existant (idempotent)
• Limite : maximum 3 webhooks par organisation. Le 4ème renvoie limit_exceeded.
• Stockage du secret : la valeur du secret n’est jamais renvoyée dans aucune réponse. Seul hasSecret: true/false est exposé.

Lister les webhooks

GET /webhooks

Retourne tous les webhooks de votre organisation avec les informations de statut (lastTriggeredAt, failureCount, isActive). Les secrets ne sont jamais exposés.

Obtenir un webhook

GET /webhooks/:id

Supprimer un webhook

DELETE /webhooks/:id

Retourne 204 No Content. Les webhooks supprimés cessent immédiatement de recevoir des livraisons.

Livraison

Lorsqu’un événement de tâche correspond aux événements souscrits par un webhook, Rebyte envoie une requête HTTP POST à l’URL du webhook.

Charge utile :

{
  "event": "task.completed",
  "taskId": "550e8400-e29b-41d4-a716-446655440000",
  "timestamp": 1706443200,
  "data": {
    "status": "succeeded",
    "taskUrl": "https://app.rebyte.ai/run/550e8400-...",
    "result": "Created CSV file with 10 Hacker News posts..."
  }
}

• status — statut de l’invite : pending (task.created), running (task.running), succeeded (task.completed), failed (task.failed), canceled (task.canceled)
• taskUrl — lien direct vers la tâche dans l’interface utilisateur de Rebyte (toujours présent)
• result — texte de sortie final de l’IA (présent sur les événements terminaux : task.completed, task.failed, task.canceled ; absent sur task.created et task.running)

Appelez GET /tasks/:id pour obtenir les détails complets de la tâche, y compris l’historique des invites.

En-têtes de livraison :

En-tête	Toujours présent	Description
Content-Type	Oui	application/json
X-Webhook-Signature	Oui	Signature RSA-SHA256 encodée en Base64
X-Webhook-Timestamp	Oui	Horodatage Unix (secondes)
X-Webhook-Secret	Seulement si le secret est configuré	La valeur du secret pré-partagé que vous avez définie lors de la création

Délai d’attente : les livraisons expirent après 10 secondes.

Gestion des échecs :

• La livraison est en mode fire-and-forget — pas de tentatives automatiques en cas d’échec
• Les réponses non-2xx incrémentent failureCount
• Après 10 échecs consécutifs, le webhook est automatiquement désactivé (isActive: false)
• Les livraisons réussies réinitialisent failureCount à 0

Vérification de la signature

Chaque livraison est signée avec la paire de clés RSA-2048 de votre organisation, qu’un secret pré-partagé soit configuré ou non.

Comment ça marche :

1. Rebyte concatène {timestamp}.{body} (par exemple, 1706443200.{"event":"task.completed",...})
2. Signe la chaîne avec RSA-SHA256 en utilisant la clé privée de votre organisation
3. Envoie la signature encodée en base64 dans X-Webhook-Signature

Obtenez votre clé publique : contactez le support ou récupérez-la depuis le tableau de bord Rebyte. La paire de clés RSA-2048 est générée automatiquement lors de la première création de webhook et persiste pour l’organisation.

Exemple de vérification (Node.js) :

const crypto = require('crypto');

function verifyWebhook(rawBody, timestamp, signature, publicKey) {
  const payload = `${timestamp}.${rawBody}`;
  const verifier = crypto.createVerify('RSA-SHA256');
  verifier.update(payload);
  return verifier.verify(publicKey, signature, 'base64');
}

// In your webhook handler:
app.post('/webhook', (req, res) => {
  const rawBody = req.body; // must be raw string, not parsed JSON
  const timestamp = req.headers['x-webhook-timestamp'];
  const signature = req.headers['x-webhook-signature'];

  if (!verifyWebhook(rawBody, timestamp, signature, PUBLIC_KEY)) {
    return res.status(401).send('Invalid signature');
  }

  const event = JSON.parse(rawBody);
  console.log(`Task ${event.taskId}: ${event.event}`);
  res.status(200).send('OK');
});

Exemple de vérification (Python) :

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
import base64

def verify_webhook(raw_body: str, timestamp: str, signature: str, public_key_pem: str) -> bool:
    public_key = serialization.load_pem_public_key(public_key_pem.encode())
    payload = f"{timestamp}.{raw_body}".encode()
    try:
        public_key.verify(
            base64.b64decode(signature),
            payload,
            padding.PKCS1v15(),
            hashes.SHA256()
        )
        return True
    except Exception:
        return False

Sécurité à deux niveaux

Les webhooks prennent en charge deux méthodes de vérification indépendantes qui peuvent être utilisées ensemble :

Méthode	En-tête	Comment ça marche	Cas d’utilisation
Signature RSA	X-Webhook-Signature	Preuve cryptographique que la charge utile provient de Rebyte	Vérification anti-falsification
Secret pré-partagé	X-Webhook-Secret	Chaîne statique que vous définissez lors de la création, renvoyée dans chaque livraison	Simple vérification par secret partagé

Les signatures RSA sont toujours présentes. Le secret pré-partagé est facultatif — définissez-le lors de la création du webhook si vous souhaitez un chemin de vérification plus simple.

---

Exemple de sondage

Exemple complet : créer une tâche, sonder jusqu’à la complétion, puis envoyer un suivi.

# Create task
TASK_ID=$(curl -s -X POST https://api.rebyte.ai/v1/tasks \
  -H "API_KEY: rbk_xxx" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Write a Python CLI that converts CSV to JSON"}' | jq -r '.id')

echo "Task: https://app.rebyte.ai/run/$TASK_ID"

# Poll until done
while true; do
  STATUS=$(curl -s https://api.rebyte.ai/v1/tasks/$TASK_ID \
    -H "API_KEY: rbk_xxx" | jq -r '.status')
  echo "Status: $STATUS"
  [[ "$STATUS" == "completed" || "$STATUS" == "failed" ]] && break
  sleep 5
done

# Send a follow-up
curl -s -X POST https://api.rebyte.ai/v1/tasks/$TASK_ID/prompts \
  -H "API_KEY: rbk_xxx" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Now add support for nested JSON objects"}'

---

Format d’erreur

Toutes les erreurs suivent cette structure :

{
  "error": {
    "code": "validation_error",
    "message": "Invalid request body"
  }
}

Code	Statut HTTP	Description
missing_api_key	401	En-tête API_KEY non fourni
invalid_api_key	401	Clé API invalide ou expirée
validation_error	400	Le corps de la requête n’a pas passé la validation
not_found	404	La ressource n’existe pas ou n’est pas accessible
limit_exceeded	400	Limite de l’organisation atteinte (par exemple, nombre max de webhooks)
agent_disabled	403	L’exécuteur demandé est désactivé pour cette organisation
internal_error	500	Échec côté serveur

Limitation de débit

L’API n’applique pas actuellement de limites de débit par clé. Chaque POST /tasks provisionne une VM réelle, donc les coûts augmentent avec l’utilisation. Utilisez les webhooks au lieu d’un sondage agressif pour réduire les requêtes inutiles.