Voix en temps réel

Créez des agents vocaux bidirectionnels avec gpt-realtime — le modèle écoute la parole et répond de vive voix en temps réel (comme un appel téléphonique), via une connexion WebSocket vers /v1/realtime. Votre SDK OpenAI Realtime existant fonctionne sans modification ; pointez-le simplement vers notre endpoint et utilisez votre clé Synthorai.

Endpoint et authentification

Ouvrez un WebSocket vers /v1/realtime en indiquant votre modèle dans la chaîne de requête. L'authentification s'exécute avant l'upgrade, donc une clé rejetée n'ouvre jamais de socket.

# WebSocket, server-side (Node / Python / Go — anything that can set headers)
GET wss://synthorai.io/v1/realtime?model=gpt-realtime
Authorization: Bearer $YOUR_KEY
# Send only the Authorization header. Do NOT send OpenAI-Beta: realtime=v1
# (the beta protocol is retired; it makes the upstream reject the session).

• Votre clé sk-syn ne quitte jamais notre passerelle — l'identifiant en amont est substitué de notre côté.
• Conçu pour les clients côté serveur (Node, Python, Go — tout ce qui peut définir un en-tête Authorization). Les jetons éphémères de navigateur ne sont pas pris en charge.
• WebSocket uniquement. Le SIP (téléphonie) et le WebRTC connectent le client directement au service en amont et ne sont pas relayés — faites plutôt transiter l'audio téléphonique dans un WebSocket.

Configurer la session

Une fois la connexion ouverte, vous recevez session.created. Envoyez un session.update pour définir la voix, les modalités, le format audio et la détection de tour. Utilisez le format GA (session.type: "realtime", l'audio sous audio.input / audio.output) — l'ancien format plat en beta est abandonné.

{
  "type": "session.update",
  "session": {
    "type": "realtime",
    "output_modalities": ["audio"],
    "instructions": "You are a concise customer-support agent.",
    "audio": {
      "input":  { "format": { "type": "audio/pcm", "rate": 24000 },
                  "turn_detection": { "type": "server_vad" } },
      "output": { "format": { "type": "audio/pcm", "rate": 24000 } }
    }
  }
}

Un tour de conversation minimal :

1. Diffusez l'audio du microphone avec input_audio_buffer.append (PCM en base64).
2. Validez le tour avec input_audio_buffer.commit, puis response.create.
3. Recevez les deltas audio (response.output_audio.delta) et la transcription textuelle, puis response.done avec l'usage.
4. Avec le server VAD activé, le modèle détecte les tours à votre place ; les mêmes événements circulent sans commit manuel.

Outils, appels de fonctions et connaissances

Déclarez des fonctions dans session.update. Le modèle les appelle en cours de conversation — c'est ainsi que vous connectez la recherche de commandes, la billetterie ou n'importe quel système métier. Renvoyez le résultat et le modèle poursuit la conversation en s'appuyant dessus :

// 1. Declare tools in session.update: "tools": [{ "type": "function", ... }]
// 2. The model emits a function_call in response.done.
// 3. Return the result, then ask the model to continue:
{ "type": "conversation.item.create",
  "item": { "type": "function_call_output",
            "call_id": "call_abc",
            "output": "{\"status\":\"shipped\"}" } }
{ "type": "response.create" }

Les serveurs MCP distants sont également pris en charge ("type": "mcp") — le service en amont se connecte directement au serveur MCP. Pour une base de connaissances, injectez des faits via instructions, un outil de fonction adossé à votre RAG, ou MCP ; les connaissances intégrées au modèle ne sont pas une source fiable pour des faits métier.

Facturation

Facturé selon l'usage de chaque response.done au prix catalogue officiel (sans majoration) — audio et texte, entrée et sortie, avec un tarif d'entrée en cache. Chaque session écrit une ligne de registre à la fin.

Les prix indiqués concernent gpt-realtime / gpt-realtime-2.1 ; gpt-realtime-2.1-mini coûte environ un tiers. L'entrée audio est de ~10 tokens/second, la sortie de ~20 tokens/second. Conserver l'historique de conversation en ajout seul permet au tarif en cache ($0.40/1M) d'absorber l'essentiel d'un long appel.

Durée de session et bascule à chaud

• Pour les appels susceptibles de durer, effectuez la bascule à chaud bien avant la limite (par ex. à 50 minutes) : ouvrez une nouvelle session et rejouez la conversation sous forme de texte avec conversation.item.create (l'utilisateur en input_text, l'assistant en output_text — l'audio de l'assistant ne peut pas être rejoué).
• Il n'y a pas de reprise de session : si le WebSocket tombe, l'état en amont est perdu. La reconnexion emprunte le même chemin de relecture textuelle, alors intégrez la reconnexion dès le premier jour.
• Le contexte est de 128K pour gpt-realtime-2.1 / -mini (≈3.5 hours d'audio d'entrée) ; l'ancien gpt-realtime est à 32K — ne l'utilisez pas pour de longs appels.

Accès

gpt-realtime est en beta sur invitation. Il apparaît dans le catalogue et la tarification, mais son utilisation nécessite que votre espace de travail y ait accès — contactez-nous pour l'activer.