API WebSocket OpenAI : streaming en temps réel à 75 % de coût en moins

Le streaming WebSocket est le moyen le plus rapide d'interagir avec des modèles d'IA. Contrairement aux requêtes HTTP traditionnelles ou même à Server-Sent Events (SSE), WebSocket maintient une connexion persistante et bidirectionnelle entre votre application et l'API. Pas d'établissement de connexion à chaque requête, pas de surcharge HTTP, pas de limitations half-duplex.

Smart AIPI prend désormais en charge ce protocole sur wss://api.smartaipi.com/v1/realtime — entièrement compatible avec l'API WebSocket d'OpenAI, pour un coût inférieur de 75 %.

Pourquoi WebSocket plutôt que SSE ?

Server-Sent Events a été le standard pour le streaming IA, mais il implique des compromis que WebSocket élimine :

Pour les boucles d'agents qui enchaînent des dizaines d'appels API, le gain de latence cumulé apporté par une connexion WebSocket persistante est significatif.

Comment ça fonctionne

L'API WebSocket suit un protocole orienté événements. Vous envoyez des événements JSON au serveur et recevez des événements JSON en retour — le tout via une seule connexion persistante.

1. Se connecter et s'authentifier

Ouvrez une connexion WebSocket avec votre API key dans les en-têtes :

wss://api.smartaipi.com/v1/realtime
Authorization: Bearer sk-proj-your-smart-aipi-key
OpenAI-Beta: realtime=v1

2. Envoyer une requête

Envoyez un événement response.create avec votre prompt :

{
  "type": "response.create",
  "response": {
    "model": "gpt-5.3-codex",
    "store": false,
    "instructions": "You are a helpful assistant.",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "What is WebSocket?" }
        ]
      }
    ]
  }
}

3. Recevoir les événements de streaming

Le serveur renvoie une séquence d'événements à mesure que la réponse est générée :

Exemples de code

Node.js

import WebSocket from "ws";

const ws = new WebSocket("wss://api.smartaipi.com/v1/realtime", {
  headers: {
    "Authorization": "Bearer sk-proj-your-key",
    "OpenAI-Beta": "realtime=v1",
  },
});

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "response.create",
    response: {
      model: "gpt-5.3-codex",
      store: false,
      input: [{
        type: "message",
        role: "user",
        content: [{ type: "input_text", text: "Hello!" }],
      }],
    },
  }));
});

ws.on("message", (data) => {
  const event = JSON.parse(data);
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  }
  if (event.type === "response.completed") {
    console.log("\n\nDone. Usage:", event.response.usage);
    ws.close();
  }
});

Python

import asyncio
import json
import websockets

async def main():
    headers = {
        "Authorization": "Bearer sk-proj-your-key",
        "OpenAI-Beta": "realtime=v1",
    }

    async with websockets.connect(
        "wss://api.smartaipi.com/v1/realtime",
        extra_headers=headers,
    ) as ws:
        await ws.send(json.dumps({
            "type": "response.create",
            "response": {
                "model": "gpt-5.3-codex",
                "store": False,
                "input": [{
                    "type": "message",
                    "role": "user",
                    "content": [{"type": "input_text", "text": "Hello!"}],
                }],
            },
        }))

        async for message in ws:
            event = json.loads(message)
            if event["type"] == "response.output_text.delta":
                print(event["delta"], end="", flush=True)
            if event["type"] == "response.completed":
                print(f"\n\nUsage: {event['response']['usage']}")
                break

asyncio.run(main())

cURL (test rapide)

Vérifiez que le handshake WebSocket réussit avec une seule commande :

curl -isN --http1.1 \
  -H "Connection: Upgrade" \
  -H "Upgrade: websocket" \
  -H "Sec-WebSocket-Version: 13" \
  -H "Sec-WebSocket-Key: dGVzdA==" \
  -H "Authorization: Bearer sk-proj-your-key" \
  -H "OpenAI-Beta: realtime=v1" \
  https://api.smartaipi.com/v1/realtime

Une connexion réussie renvoie HTTP/1.1 101 Switching Protocols.

Quand utiliser WebSocket ou SSE

Les deux protocoles fonctionnent via Smart AIPI. Choisissez en fonction de votre cas d'usage :

• Utilisez SSE pour des intégrations simples, des requêtes ponctuelles et lorsque vous voulez l'implémentation la plus simple possible. Définissez stream: true sur n'importe quel appel API standard.
• Utilisez WebSocket pour les boucles d'agents, les applications interactives, les schémas de requêtes à haute fréquence et partout où vous avez besoin de la latence la plus faible possible entre des appels consécutifs.

Tarification

Les requêtes WebSocket sont facturées comme les requêtes API standard — selon l'usage des token. La remise de 75 % s'applique :

Premiers pas

1. Obtenez une API key — Inscrivez-vous sur smartaipi.com (crédits gratuits inclus, aucune carte bancaire requise)
2. Connectez-vous — Ouvrez un WebSocket vers wss://api.smartaipi.com/v1/realtime
3. Envoyez des événements — Utilisez l'enveloppe response.create avec votre modèle et votre prompt
4. Streamez les réponses — Traitez les événements response.output_text.delta à mesure qu'ils arrivent

Si vous utilisez déjà l'API WebSocket d'OpenAI, le seul changement est l'URL. Tout le reste — authentification, événements, format de payload — est identique.

Questions fréquentes

Est-ce que Smart AIPI prend en charge l'API WebSocket d'OpenAI ?

Oui. Connectez-vous à wss://api.smartaipi.com/v1/realtime avec votre API key dans l'en-tête Authorization. Le protocole est entièrement compatible avec l'API WebSocket Responses d'OpenAI.

WebSocket est-il plus rapide que SSE ?

Pour des requêtes consécutives, oui. WebSocket maintient une connexion persistante, ce qui élimine la surcharge des handshakes TCP et TLS que SSE subit à chaque nouvelle requête. Pour une requête ponctuelle unique, la différence est négligeable.

Quels modèles fonctionnent avec WebSocket ?

Tous les modèles disponibles via l'API Responses : GPT-5.3 Codex, GPT-5.2, Codex Mini et d'autres. Spécifiez le modèle dans l'événement response.create.

Le function calling et l'utilisation d'outils fonctionnent-ils avec WebSocket ?

Oui. Tout l'ensemble de fonctionnalités de l'API Responses est disponible — function calling, utilisation d'outils, sorties structurées et conversations multi-tour fonctionnent tous via la connexion WebSocket.

Y a-t-il une limite de temps de connexion ?

Les connexions inactives sont fermées après 15 minutes. Envoyez des messages périodiques ou reconnectez-vous si nécessaire. Les connexions actives qui streament des données ne sont pas interrompues.

Puis-je envoyer plusieurs requêtes sur une seule connexion ?

Oui. C'est l'un des principaux avantages. Une fois qu'une réponse est terminée, envoyez un autre événement response.create sur la même connexion sans vous reconnecter.