DEV Community

Cover image for Qu'est-ce que GPT-Realtime-2 et Comment Utiliser l'API GPT-Realtime-2
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Qu'est-ce que GPT-Realtime-2 et Comment Utiliser l'API GPT-Realtime-2

OpenAI a lancé une nouvelle génération de modèles vocaux le 6 novembre 2026. La sortie principale est GPT-Realtime-2 : un modèle parole-à-parole avec raisonnement de classe GPT-5, fenêtre contextuelle de 128 000 tokens et effort de raisonnement configurable pour arbitrer entre latence et qualité. Il fonctionne avec l’API Realtime existante : si vous utilisez déjà gpt-realtime, la migration commence par remplacer l’ID du modèle et ajuster quelques champs de session.

Essayez Apidog aujourd’hui

Ce guide explique ce qu’est GPT-Realtime-2, ce qui change par rapport au modèle précédent, comment est structurée la tarification, puis comment l’appeler via WebSocket et SIP. Il inclut aussi une configuration de test avec Apidog pour rejouer des sessions Realtime sans réenregistrer l’audio à chaque exécution.

Pour situer GPT-Realtime-2 dans la gamme OpenAI 2026, consultez Qu’est-ce que GPT-5.5. Pour son équivalent multimodal côté image, voir Comment utiliser l’API GPT-Image-2.

En bref

  • Modèle : gpt-realtime-2
  • Type : parole-à-parole avec raisonnement de classe GPT-5
  • Contexte : 128k tokens
  • Sortie max : 32k tokens
  • Audio : 32 $ / million de tokens d’entrée, 64 $ / million de tokens de sortie
  • Entrée audio en cache : 0,40 $ / million
  • Voix exclusives Realtime : cedar, marin
  • Niveaux de raisonnement : minimal, low, medium, high, xhigh
  • Valeur par défaut : low, pour limiter la latence
  • WebSocket : wss://api.openai.com/v1/realtime?model=gpt-realtime-2
  • SIP : appels entrants via call_id
  • Modèles complémentaires :
    • GPT-Realtime-Translate : traduction en direct
    • GPT-Realtime-Whisper : transcription STT en streaming
  • Test recommandé : utiliser Apidog pour rejouer les frames WebSocket et comparer les événements audio.

Qu’est-ce que GPT-Realtime-2 ?

GPT-Realtime-2 est un modèle parole-à-parole. Vous envoyez de l’audio en streaming, le modèle renvoie de l’audio en streaming, et il gère en interne :

  • la transcription ;
  • le raisonnement ;
  • l’appel d’outils ;
  • la génération vocale.

Il ne s’agit donc pas d’un pipeline séparé du type :

STT -> LLM -> TTS
Enter fullscreen mode Exit fullscreen mode

Le modèle traite la conversation dans une seule interface Realtime.

GPT-Realtime-2

GPT-Realtime-2 accepte en entrée :

  • du texte ;
  • de l’audio ;
  • des images.

Il peut produire en sortie :

  • du texte ;
  • de l’audio.

L’entrée image est la nouveauté importante : vous pouvez injecter une capture d’écran ou une photo pendant une session vocale, puis demander au modèle de la commenter ou de guider l’utilisateur à voix haute.

Exemples de cas d’usage :

  • agent support qui analyse une capture d’écran d’erreur ;
  • assistant terrain qui examine une photo de câblage ;
  • copilote vocal qui décrit l’écran d’un utilisateur.

Spécifications

Attribut Valeur
ID du modèle gpt-realtime-2
Fenêtre de contexte 128 000 tokens
Sortie maximale 32 000 tokens
Modalités en entrée texte, audio, image
Modalités en sortie texte, audio
Date limite de connaissance 2024-09-30
Niveaux de raisonnement minimal, low, medium, high, xhigh
Appel de fonction oui
Serveurs MCP distants oui
Entrée image oui
Appels téléphoniques SIP oui

Ce qui change par rapport à gpt-realtime

Par rapport à gpt-realtime-1.5, GPT-Realtime-2 améliore notamment les scores suivants :

  • Big Bench Audio : 81,4 % → 96,6 %
  • Audio MultiChallenge : 34,7 % → 48,5 %

Ces résultats ont été obtenus avec des niveaux de raisonnement high et xhigh. En production, le niveau par défaut est low, afin de réduire la latence.

Les changements opérationnels les plus utiles côté implémentation sont les suivants.

1. Préambules vocaux

Le modèle peut prononcer une courte phrase pendant qu’il prépare sa réponse :

« Je vérifie cela. »
« Laissez-moi consulter votre dossier. »
Enter fullscreen mode Exit fullscreen mode

Cela permet de masquer une partie de la latence perçue.

2. Appels d’outils parallèles

GPT-Realtime-2 peut déclencher plusieurs appels de fonction en parallèle et expliquer ce qu’il fait pendant leur résolution.

Exemple :

« Je vérifie votre solde et vos trois dernières transactions. »
Enter fullscreen mode Exit fullscreen mode

3. Meilleure récupération conversationnelle

Les tours ambigus ou incomplets sont mieux gérés, ce qui évite de redémarrer le flux conversationnel au moindre échec.

4. Ton plus stable sur les domaines spécialisés

Le modèle conserve mieux les termes métier sur des sessions longues et peut adapter sa voix selon vos instructions :

  • formelle ;
  • décontractée ;
  • lente ;
  • pédagogique ;
  • orientée support.

Benchmarks GPT-Realtime-2

Le passage de 32k à 128k tokens est particulièrement utile pour les sessions longues : support client, banque, tutorat, diagnostic technique ou centre d’appels.

Tarification

GPT-Realtime-2 est facturé par token, avec des tarifs distincts pour le texte, l’audio et les images.

Type de token Entrée Entrée en cache Sortie
Texte $4.00 / 1M $0.40 / 1M $24.00 / 1M
Audio $32.00 / 1M $0.40 / 1M $64.00 / 1M
Image $5.00 / 1M $0.50 / 1M n/a

L’entrée en cache réduit fortement le coût des contextes répétés. Pour un agent vocal, gardez le cache actif lorsque vous réutilisez :

  • un prompt système stable ;
  • une politique de support ;
  • une base documentaire injectée dans le contexte ;
  • des instructions métier longues.

Pour comparer avec les autres modèles OpenAI, voir la tarification de GPT-5.5.

Modèles complémentaires

Les modèles complémentaires sont facturés à la minute :

  • GPT-Realtime-Translate : 0,034 $ / minute

    Traduction en direct avec 70 langues d’entrée et 13 langues de sortie.

  • GPT-Realtime-Whisper : 0,017 $ / minute

    Transcription parole-texte en streaming, utile pour les sous-titres en direct et la transcription continue.

Choisissez :

  • GPT-Realtime-2 pour le raisonnement + la voix ;
  • GPT-Realtime-Translate pour l’interprétation multilingue en direct ;
  • GPT-Realtime-Whisper pour la transcription seule.

Points d’accès et authentification

GPT-Realtime-2 est accessible via plusieurs endpoints :

POST https://api.openai.com/v1/chat/completions
POST https://api.openai.com/v1/responses
WSS  wss://api.openai.com/v1/realtime?model=gpt-realtime-2
WSS  wss://api.openai.com/v1/realtime?call_id={call_id}
POST https://api.openai.com/v1/realtime/translations
POST https://api.openai.com/v1/realtime/transcription_sessions
Enter fullscreen mode Exit fullscreen mode

Pour un agent vocal interactif, utilisez le WebSocket :

wss://api.openai.com/v1/realtime?model=gpt-realtime-2
Enter fullscreen mode Exit fullscreen mode

Ajoutez les en-têtes suivants :

Authorization: Bearer $OPENAI_API_KEY
OpenAI-Beta: realtime=v1
Enter fullscreen mode Exit fullscreen mode

Définissez votre clé API dans l’environnement :

export OPENAI_API_KEY="sk-proj-..."
Enter fullscreen mode Exit fullscreen mode

Connexion via WebSocket

Voici un client Node.js minimal.

import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.openai.com/v1/realtime?model=gpt-realtime-2",
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "OpenAI-Beta": "realtime=v1",
    },
  }
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      voice: "cedar",
      instructions: "You are a friendly support agent for a fintech app.",
      input_audio_format: "pcm16",
      output_audio_format: "pcm16",
      turn_detection: { type: "server_vad" },
      reasoning: { effort: "low" },
    },
  }));
});

ws.on("message", (raw) => {
  const event = JSON.parse(raw.toString());

  if (event.type === "response.audio.delta") {
    // Chunk audio PCM16 encodé en base64.
    // À router vers un haut-parleur, un navigateur ou un flux téléphonique.
    process.stdout.write(Buffer.from(event.delta, "base64"));
  }
});
Enter fullscreen mode Exit fullscreen mode

Le flux est piloté par événements.

Côté client, vous envoyez notamment :

session.update
input_audio_buffer.append
response.create
conversation.item.create
Enter fullscreen mode Exit fullscreen mode

Côté serveur, vous recevez par exemple :

response.audio.delta
response.done
response.function_call_arguments.delta
Enter fullscreen mode Exit fullscreen mode

Le format PCM16 à 24 kHz est un choix sûr. Les formats G.711 mu-law et A-law sont aussi pris en charge, ce qui simplifie l’intégration avec des systèmes téléphoniques.

Pour comparer l’API Realtime avec l’API Responses, voir Comment utiliser l’API GPT-5.5.

Configurer la voix

Deux nouvelles voix sont incluses :

  • Cedar : voix masculine chaude, adaptée aux agents généralistes.
  • Marin : voix féminine claire, adaptée aux annonces et à la traduction.

Les deux sont exclusives à l’API Realtime.

Les voix existantes restent disponibles :

alloy
ash
ballad
coral
echo
sage
shimmer
verse
Enter fullscreen mode Exit fullscreen mode

Pour changer de voix pendant une session, envoyez un nouveau session.update :

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    voice: "marin"
  }
}));
Enter fullscreen mode Exit fullscreen mode

Ajouter une image à une session vocale

Vous pouvez joindre une image à un tour utilisateur avec conversation.item.create.

ws.send(JSON.stringify({
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_image",
        image_url: "https://example.com/screenshot.png"
      },
      {
        type: "input_text",
        text: "What does this error mean?"
      }
    ],
  },
}));

ws.send(JSON.stringify({
  type: "response.create"
}));
Enter fullscreen mode Exit fullscreen mode

Cas d’usage typiques :

  • QA vocale : un testeur montre une interface défectueuse et dicte le rapport.
  • Support terrain : un technicien partage une photo d’équipement.
  • Accessibilité : l’agent décrit l’écran pendant un appel de support.

Pour approfondir la partie image, voir Comment utiliser l’API GPT-Image-2.

Appel de fonction et MCP

GPT-Realtime-2 prend en charge :

  • les fonctions déclarées dans la session ;
  • les serveurs MCP distants.

Appel de fonction standard

Le fonctionnement est similaire aux Chat Completions :

  1. Déclarez vos outils dans session.update.
  2. Le modèle émet des événements response.function_call_arguments.delta.
  3. Votre application exécute l’outil.
  4. Vous renvoyez un item function_call_output.

Le point important avec GPT-Realtime-2 est la possibilité de lancer plusieurs outils en parallèle tout en gardant une narration vocale.

Serveurs MCP distants

Avec MCP, vous pouvez déclarer un serveur d’outils distant directement dans la session.

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [
      {
        type: "mcp",
        server_url: "https://mcp.example.com/sse",
        allowed_tools: [
          "lookup_account",
          "list_transactions"
        ],
      }
    ],
  },
}));
Enter fullscreen mode Exit fullscreen mode

Cette approche évite de gérer vous-même tous les allers-retours d’appel de fonction dans votre boucle WebSocket.

Elle devient utile lorsque votre agent vocal doit accéder à un catalogue d’outils large : comptes, transactions, tickets, CRM, historique utilisateur, etc.

Pour tester des serveurs MCP avant de les brancher à un agent vocal, consultez tester des serveurs MCP dans Apidog.

Appels téléphoniques SIP

GPT-Realtime-2 peut être utilisé avec de vrais appels téléphoniques.

Le flux général :

  1. Vous dirigez votre trunk SIP vers la passerelle SIP d’OpenAI.
  2. Un appel entrant crée un call_id.
  3. Votre application se connecte à : 
wss://api.openai.com/v1/realtime?call_id={call_id}
Enter fullscreen mode Exit fullscreen mode

Le modèle accepte directement :

  • G.711 mu-law ;
  • G.711 A-law.

Cela évite d’ajouter une étape de transcodage dans votre passerelle.

Cette intégration est utile pour les centres d’appels, surtout lorsque l’agent vocal combine :

  • raisonnement ;
  • appels d’outils parallèles ;
  • MCP ;
  • récupération conversationnelle ;
  • génération vocale en temps réel.

Choisir le niveau de raisonnement

GPT-Realtime-2 expose cinq niveaux de raisonnement.

Niveau Cas d’usage Coût de latence approximatif
minimal Réponses simples oui/non aucun
low Support courant, chat vocal général faible
medium Désambiguïsation, outils multiples modéré
high Raisonnement multi-étapes, revue de code vocale élevé
xhigh Benchmarks, questions analytiques difficiles le plus élevé

Le niveau par défaut est low.

Recommandation pratique :

  1. Commencez avec low.
  2. Mesurez la qualité des réponses.
  3. Passez à medium uniquement si nécessaire.
  4. Réservez high et xhigh aux tâches où la qualité justifie la latence.

Exemple :

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    reasoning: {
      effort: "medium"
    }
  }
}));
Enter fullscreen mode Exit fullscreen mode

Tester l’API Realtime dans Apidog

Les WebSockets sont plus difficiles à déboguer que les requêtes HTTP classiques, car la session est stateful. Avec Apidog, vous pouvez enregistrer et rejouer une session Realtime.

Test WebSocket dans Apidog

Workflow recommandé :

  1. Créez une nouvelle requête WebSocket.
  2. Utilisez l’URL : 
wss://api.openai.com/v1/realtime?model=gpt-realtime-2
Enter fullscreen mode Exit fullscreen mode
  1. Ajoutez les en-têtes : 
Authorization: Bearer {{OPENAI_API_KEY}}
OpenAI-Beta: realtime=v1
Enter fullscreen mode Exit fullscreen mode

  1. Préparez une séquence de messages JSON :

    • session.update
    • conversation.item.create
    • input_audio_buffer.append
    • response.create

  2. Rejouez la séquence sur une seule connexion.

  3. Capturez les événements serveur.

  4. Comparez plusieurs exécutions côte à côte.

C’est utile pour comparer :

  • différentes voix ;
  • différents niveaux de raisonnement ;
  • le volume de tokens audio ;
  • les erreurs d’appel d’outils ;
  • les variations de latence.

Téléchargez Apidog, créez une requête WebSocket, puis stockez OPENAI_API_KEY comme variable d’environnement.

Vous pouvez aussi définir des variables pour :

model = gpt-realtime-2
voice = cedar
reasoning_effort = low
Enter fullscreen mode Exit fullscreen mode

Pour comparer avec un autre modèle multimodal rapide, voir Comment utiliser l’API Gemini 3 Flash Preview.

FAQ

Quel ID de modèle utiliser ?

Utilisez :

gpt-realtime-2
Enter fullscreen mode Exit fullscreen mode

Le modèle précédent reste disponible sous :

gpt-realtime
Enter fullscreen mode Exit fullscreen mode

La version allégée est :

gpt-realtime-2-mini
Enter fullscreen mode Exit fullscreen mode

Puis-je envoyer de l’audio pendant que le modèle parle ?

Oui. L’API Realtime utilise par défaut la détection d’activité vocale côté serveur, ou VAD.

Si l’utilisateur commence à parler, le modèle peut s’interrompre. Vous pouvez aussi désactiver la VAD et gérer les tours côté client.

Le contexte de 128k inclut-il l’audio ?

Oui. L’audio est tokenisé.

Une seconde d’audio représente environ 50 tokens selon le format. Un appel de support long peut donc consommer le contexte rapidement.

Le fine-tuning est-il supporté ?

Pas encore. D’après la fiche du modèle, GPT-Realtime-2 ne prend pas encore en charge :

  • le fine-tuning ;
  • les sorties prédites ;
  • le streaming texte sur Chat Completions.

Le endpoint Realtime diffuse l’audio nativement.

Quelle différence avec GPT-5.5 + TTS ?

GPT-Realtime-2 raisonne directement sur la voix. Il peut prendre en compte :

  • le ton ;
  • l’hésitation ;
  • l’emphase ;
  • les interruptions.

Un modèle textuel avec TTS ne traite pas ces signaux de la même manière.

Pour du raisonnement purement textuel, voir Comment utiliser l’API GPT-5.5.

Quelles sont les limites de débit ?

Le niveau 1 commence à 40 000 tokens par minute et monte à 15 millions de tokens par minute au niveau 5.

Les limites sont appliquées par modèle. Le quota GPT-5 existant n’est donc pas automatiquement reporté.

Conclusion

GPT-Realtime-2 permet de construire des agents vocaux plus proches des agents textuels avancés : contexte 128k, raisonnement de classe GPT-5, entrée image, MCP natif et support SIP.

Pour une première implémentation :

  1. Connectez-vous au WebSocket gpt-realtime-2.
  2. Configurez voice, instructions, formats audio et VAD.
  3. Commencez avec reasoning.effort = "low".
  4. Ajoutez les outils nécessaires.
  5. Testez les sessions dans Apidog.
  6. Augmentez le niveau de raisonnement uniquement si vos mesures montrent un gain qualité clair.

Le chemin le plus rapide vers la production consiste à figer votre prompt système, votre liste d’outils et vos scénarios de test, puis à rejouer les mêmes sessions WebSocket pour comparer latence, qualité et coût.

Top comments (0)