GPT-Realtime-2.1 API

gpt-audio-1.5

Het beste stemmodel voor audio-invoer, audio-uitvoer met Chat Completions.

GPT-Realtime-2

GPT-Realtime-2 is ons meest capabele realtime spraakmodel. Het ondersteunt spraak-naar-spraak-interacties met een instelbare mate van redeneren, betere opvolging van instructies en betrouwbaarder gebruik van tools voor complexe spraakagent-workflows.

gpt-realtime-1.5

Het beste spraakmodel voor audio-in, audio-uit.

TTS

OpenAI Tekst-naar-spraak

Kling TTS

[Spraaksynthese] Zojuist gelanceerd: tekst-naar-audio van uitzendkwaliteit online, met voorvertoning ● Kan tegelijkertijd een audio_id genereren, te gebruiken met elke Keling API.

Kling video-to-audio

Kling video-naar-audio

Modelvergelijking openen →

Uptime

Bekijk live heartbeat-gegevens, eindpuntbeschikbaarheid en waargenomen reactietijden voordat u naar productie gaat.

Versies

Bekijk beschikbare modelidentificatoren voordat u een productie-integratie vastlegt.

gpt-realtime-2.1

gpt-realtime-2.1-mini

Blijf verkennen

Vergelijk modellen en ga verder met uw onderzoek

OpenAI

Beschikbaar

gpt-realtime-2.1

GPT-Realtime-2.1 API

Startprijs

$3.20 / 1M invoertokens

Facturering op basis van gebruik

API-status

Beschikbaar

Productie-eindpunt

Reactietijd

Klaar voor async

Waargenomen API-reactietijd

Uitgebracht

Aug 6, 2026

OpenAI

Overzicht

Een praktisch overzicht van GPT-Realtime-2.1, met belangrijk gedrag en aandachtspunten bij integratie.

Technische specificaties van GPT-Realtime-2.1

Specificatie	Details
Modelnaam	GPT-Realtime-2.1
Aanbieder	OpenAI
Modelfamilie	GPT-Realtime-serie
Modeltype	Realtime multimodaal spraakredeneermodel
Primaire capaciteit	Spraak-naar-spraak AI-agenten
Invoermodaliteiten	Tekst, Audio, Afbeelding
Uitvoermodaliteiten	Tekst, Audio
Contextvenster	128,000 tokens
Maximaal aantal outputtokens	32,000 tokens
Ondersteuning voor redeneren	Instelbare redeneringinspanning
Functieaanroepen	Ondersteund
Gestructureerde outputs	Niet ondersteund
Fijn-afstemming	Niet ondersteund
Video-invoer	Niet ondersteund
Hoofd-API-eindpunt	Realtime API
Kennisafkapdatum	30 september 2024

Bron: documentatie van het OpenAI GPT-Realtime-2.1-model.

Wat is GPT-Realtime-2.1?

GPT-Realtime-2.1 is OpenAI’s geavanceerde realtime stemmodel, ontworpen voor het bouwen van conversationele AI-agenten die via audio kunnen luisteren, redeneren en natuurlijk reageren.

Benchmarkprestaties van GPT-Realtime-2.1

De verbeteringen in GPT-Realtime-2.1 richten zich op praktische realtime interactiemetingen:

Capaciteit	Verbetering
Afhandeling van spraakonderbrekingen	Verbeterd
Ruisbestendigheid	Verbeterd
Alfanumerieke herkenning	Verbeterd
Toolgebaseerde stemworkflows	Ondersteund
Spraak-naar-spraakinteractie	Ondersteund

Belangrijkste functies van GPT-Realtime-2.1

1. Native spraak-naar-spraakinteractie

GPT-Realtime-2.1 elimineert de noodzaak van afzonderlijke spraakherkennings- en tekst-naar-spraakpijplijnen.

Traditionele spraakarchitectuur:

User Voice
 ↓
Speech-to-Text
 ↓
LLM Processing
 ↓
Text-to-Speech
 ↓
Voice Response

GPT-Realtime-2.1:

User Voice
 ↓
GPT-Realtime-2.1
 ↓
Voice Response

Dit vermindert de latentie en verbetert het gespreksverloop.

2. Verbeterde kwaliteit van spraakgesprekken

GPT-Realtime-2.1 verbetert verschillende praktijkuitdagingen bij spraak:

Betere onderbrekingsafhandeling

Gebruikers kunnen de AI op natuurlijke wijze onderbreken terwijl deze spreekt.

Voorbeeld:

Gebruiker:

"Boek een vlucht naar—nee, verander dat naar Tokio."

Het model kan herstellen van veranderingen in het gesprek zonder de interactie opnieuw te starten.

Betere omgang met stilte en ruis

Het model is geoptimaliseerd voor omgevingen waar de audiokwaliteit niet perfect is:

Callcenters
Mobiele apparaten
Openbare ruimtes
Slimme apparaten

3. Geavanceerd gebruik van tools door stemagenten

GPT-Realtime-2.1 ondersteunt het aanroepen van tools, waardoor stemagenten acties kunnen uitvoeren.

Voorbeelden:

Klantenservice:

User:
"Where is my order?"

AI:
→ Calls order database API
→ Retrieves status
→ Responds by voice

Enterprise-workflow:

Voice command
↓
Reasoning
↓
API execution
↓
Voice confirmation

Dit maakt GPT-Realtime-2.1 geschikt voor autonome stemagenten.

4. Instelbare redeneercapaciteit

In tegenstelling tot eerdere realtime stemmodellen die primair voor snelheid zijn geoptimaliseerd, introduceert GPT-Realtime-2.1 een instelbare redeneringinspanning.

Ontwikkelaars kunnen een balans vinden tussen:

Reactielatentie
Nauwkeurigheid
Taakcomplexiteit

Lage redenering:

Eenvoudige gesprekken
FAQ-assistenten

Hogere redenering:

Complexe klantverzoeken
Meertrapsworkflows
Bedrijfsprocessen

5. Betere herkenning van nummers en technische informatie

Stemagenten hebben vaak moeite met:

Rekeningnummers
Serienummers
Adressen
Productcodes
Financiële informatie

GPT-Realtime-2.1 verbetert alfanumerieke herkenning, waardoor het beter geschikt is voor zakelijke stemsystemen.

6. Ondersteuning voor multimodale invoer

GPT-Realtime-2.1 ondersteunt:

Invoer	Ondersteuning
Tekst	✅
Audio	✅
Afbeelding	✅
Video	❌

Afbeeldingsinvoer maakt scenario’s mogelijk zoals:

Visuele klantenondersteuning
Documentinterpretatie
Cameragebaseerde assistenten

GPT-Realtime-2.1 vs GPT-Realtime-2 vs GPT-4o Realtime

Model	Sterkte	Beste gebruik
GPT-Realtime-2.1	Beste realtime redenering + mogelijkheden voor stemagenten	Productie-stemagenten
GPT-Realtime-2	Sterke realtime spraakredenering	Geavanceerde conversational-apps
GPT-4o Realtime	Snelle multimodale interactie	Algemene stemassistenten

GPT-Realtime-2.1 vs GPT-Realtime-2

GPT-Realtime-2.1 verbetert:

Herstel na spraakonderbrekingen
Ruisafhandeling
Herkenningsnauwkeurigheid
Gespreksrobuustheid

Beide modellen bieden:

Spraak-naar-spraakarchitectuur
Het aanroepen van tools
Ondersteuning voor redeneren
Toegang tot de Realtime API

GPT-Realtime-2.1 vs GPT-4o Realtime

GPT-Realtime-2.1 is gepositioneerd voor meer geavanceerde agent-workflows.

Vergeleken met GPT-4o Realtime:

Capaciteit	GPT-Realtime-2.1	GPT-4o Realtime
Redenering	Sterker	Algemeen
Context	128K	32K
Toolgebruik	Ondersteund	Ondersteund
Stemagenten	Geavanceerd	Algemeen
Complexe workflows	Beter geschikt	Geschikt

Hoe de GPT-Realtime-2.1-API te gebruiken met CometAPI

Stap 1: Verkrijg je CometAPI-API-sleutel

Maak een CometAPI-account aan en genereer een API-token via de ontwikkelaarsconsole.

Je API-aanvraag moet het volgende bevatten:

Authorization: Bearer YOUR_COMETAPI_API_KEY
Content-Type: application/json

De API-sleutel verifieert je verzoeken en stelt je applicatie in staat beschikbare AI-modellen via CometAPI aan te roepen.

Stap 2: Maak een GPT-Realtime-2.1-sessie

GPT-Realtime-2.1 werkt via een persistente realtime sessie in plaats van traditionele request-response chatcompletions.

Een realtime sessie behoudt:

Audio-invoerstream
Modelreacties
Gespreksstatus
Tool-aanroepen
Onderbrekingen

De Realtime API van OpenAI ondersteunt realtime communicatie via WebRTC-, WebSocket- en SIP-interfaces.

Voorbeeld:

curl https://api.cometapi.com/v1/realtime/sessions \
-H "Authorization: Bearer YOUR_COMETAPI_API_KEY" \
-H "Content-Type: application/json" \
-d '
{
  "model": "gpt-realtime-2.1",
  "modalities": [
    "audio",
    "text"
  ],
  "voice": "alloy",
  "instructions": "You are a helpful customer support voice assistant."
}
'

Voorbeeldrespons:

{
  "id": "sess_xxxxx",
  "model": "gpt-realtime-2.1",
  "status": "active"
}

Stap 3: Stuur audio-invoer naar GPT-Realtime-2.1

Stream na het maken van een sessie de gebruikersaudio.

Voorbeeldworkflow:

User microphone
        |
        ↓
Audio stream
        |
        ↓
GPT-Realtime-2.1
        |
        ↓
Generated voice response

Audio-invoer kan het volgende omvatten:

Telefoongesprekken
Spraakopdrachten
Klantenservicegesprekken
Interactieve assistenten

GPT-Realtime-2.1 verbetert spraakinteractie met betere stilte-detectie, ruisafhandeling en onderbrekingsgedrag ten opzichte van eerdere realtime modellen.

Stap 4: Ontvang realtime audiorespons

Het model levert gegenereerde audiorespons via de realtime verbinding.

Voorbeeldevent:

{
  "type": "response.audio.delta",
  "delta": "base64_audio_chunk"
}

Je applicatie kan ontvangen audiofragmenten direct afspelen.

Typische implementaties:

WebRTC-stemapplicaties
Browsergebaseerde assistenten
Mobiele stemapps
AI-telefoonagenten

Stap 5: Voeg functieaanroepen toe voor stemagenten

GPT-Realtime-2.1 ondersteunt functieaanroepen, waardoor stemagenten externe acties kunnen uitvoeren.

Voorbeeld:

{
  "tools": [
    {
      "type": "function",
      "name": "check_order_status",
      "description": "Retrieve customer order information",
      "parameters": {
        "type": "object",
        "properties": {
          "order_id": {
            "type": "string"
          }
        }
      }
    }
  ]
}

Mogelijke workflows voor stemagenten:

"Waar is mijn pakket?"
"Plan morgen een vergadering voor mij."
"Annuleer mijn abonnement."
"Controleer mijn saldo."

Het model kan het verzoek herkennen, de juiste tool aanroepen en het gesprek op natuurlijke wijze voortzetten.

Stap 6: Configureer redenering en instructies

GPT-Realtime-2.1 ondersteunt een instelbare redeneringinspanning.

Voorbeeld:

{
  "model": "gpt-realtime-2.1",
  "reasoning": {
    "effort": "medium"
  },
  "instructions": "Act as a professional travel assistant."
}

Aanbevolen instellingen:

Applicatie	Redeneringsniveau
Eenvoudige spraakopdrachten	Laag
Klantenondersteuning	Gemiddeld
Complexe workflow-agenten	Hoog

FAQ

Prijzen

Gebruik de snelle schatting hierboven voor één run en bekijk vervolgens de volledige vergelijking tussen CometAPI en de officiële prijs.

Eerste aanvraag

—

Geschatte CometAPI-gebruikskosten

Tien aanvragen

—

Geschatte CometAPI-gebruikskosten

Vijftien aanvragen

—

Geschatte CometAPI-gebruikskosten

Prijzen voor GPT-Realtime-2.1

Model	Comet Price (USD / M Tokens)	Official Price (USD / M Tokens)	Discount
gpt-realtime-2.1	Invoer:$3.2/M Uitvoer:$19.2/M	Invoer:$4/M Uitvoer:$24/M	-20%
gpt-realtime-2.1-mini	Invoer:$0.48/M Uitvoer:$2.88/M	Invoer:$0.6/M Uitvoer:$3.6/M	-20%

API

Kopieer een werkend eindpunt en codevoorbeeld, en open de volledige API-referentie wanneer u alle parameters nodig heeft.

Eén API, productieklare modeltoegang

Eén keer authenticeren, het model-eindpunt aanroepen en dezelfde facturerings- en observeerbaarheidsworkflow behouden bij alle aanbieders.

GET/v1/realtime

Voorbeeldcode en API voor GPT-Realtime-2.1

GET

/v1/realtime

#!/usr/bin/env bash
set -euo pipefail

# curl can perform the HTTP Upgrade handshake and print the Realtime WebSocket
# byte stream. Use the Python or JavaScript example to send framed events.
MODEL="gpt-realtime-2.1"
COMETAPI_KEY="${COMETAPI_KEY:-<YOUR_COMETAPI_KEY>}"
WEBSOCKET_KEY="$(openssl rand -base64 16)"

curl --http1.1 --include --no-buffer \
  --request GET \
  --header "Authorization: Bearer ${COMETAPI_KEY}" \
  --header "OpenAI-Beta: realtime=v1" \
  --header "Connection: Upgrade" \
  --header "Upgrade: websocket" \
  --header "Sec-WebSocket-Version: 13" \
  --header "Sec-WebSocket-Key: ${WEBSOCKET_KEY}" \
  "https://api.cometapi.com/v1/realtime""?model=${MODEL}"

cURL Code Example

#!/usr/bin/env bash
set -euo pipefail

# curl can perform the HTTP Upgrade handshake and print the Realtime WebSocket
# byte stream. Use the Python or JavaScript example to send framed events.
MODEL="gpt-realtime-2.1"
COMETAPI_KEY="${COMETAPI_KEY:-<YOUR_COMETAPI_KEY>}"
WEBSOCKET_KEY="$(openssl rand -base64 16)"

curl --http1.1 --include --no-buffer \
  --request GET \
  --header "Authorization: Bearer ${COMETAPI_KEY}" \
  --header "OpenAI-Beta: realtime=v1" \
  --header "Connection: Upgrade" \
  --header "Upgrade: websocket" \
  --header "Sec-WebSocket-Version: 13" \
  --header "Sec-WebSocket-Key: ${WEBSOCKET_KEY}" \
  "https://api.cometapi.com/v1/realtime""?model=${MODEL}"

Python Code Example

"""Send one text turn to gpt-realtime-2.1 over the Realtime WebSocket API.

Install the client with: pip install websocket-client
"""

import json
import os
from urllib.parse import urlencode

from websocket import create_connection


MODEL = "gpt-realtime-2.1"
BASE_URL = "wss://api.cometapi.com"
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"


def get(path: str) -> str:
    """Build a WebSocket URL for the API's GET route."""

    return f"{BASE_URL}{path}?{urlencode({'model': MODEL})}"


socket = create_connection(
    get("/v1/realtime"),
    header=[
        f"Authorization: Bearer {COMETAPI_KEY}",
        "OpenAI-Beta: realtime=v1",
    ],
    timeout=30,
)

try:
    socket.send(
        json.dumps(
            {
                "type": "session.update",
                "session": {
                    "modalities": ["text"],
                    "instructions": "Answer clearly and concisely.",
                },
            }
        )
    )
    socket.send(
        json.dumps(
            {
                "type": "conversation.item.create",
                "item": {
                    "type": "message",
                    "role": "user",
                    "content": [
                        {
                            "type": "input_text",
                            "text": "Give me one tip for a productive meeting.",
                        }
                    ],
                },
            }
        )
    )
    socket.send(json.dumps({"type": "response.create"}))

    while True:
        event = json.loads(socket.recv())
        event_type = event.get("type")
        if event_type in {
            "response.text.delta",
            "response.output_text.delta",
            "response.audio_transcript.delta",
            "response.output_audio_transcript.delta",
        }:
            print(event.get("delta", ""), end="", flush=True)
        elif event_type == "error":
            raise RuntimeError(json.dumps(event.get("error", event), indent=2))
        elif event_type == "response.done":
            print()
            break
finally:
    socket.close()

JavaScript Code Example

// Send one text turn to gpt-realtime-2.1 over the Realtime WebSocket API.
// Requires Node.js 22 or newer, which includes a global WebSocket client.

const model = "gpt-realtime-2.1";
const baseUrl = "wss://api.cometapi.com";
const apiKey = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";

function get(path) {
  const url = new URL(`${baseUrl}${path}`);
  url.searchParams.set("model", model);
  return url;
}

const socket = new WebSocket(get("/v1/realtime"), [
  "realtime",
  `openai-insecure-api-key.${apiKey}`,
  "openai-beta.realtime-v1",
]);

socket.addEventListener("open", () => {
  socket.send(
    JSON.stringify({
      type: "session.update",
      session: {
        modalities: ["text"],
        instructions: "Answer clearly and concisely.",
      },
    }),
  );
  socket.send(
    JSON.stringify({
      type: "conversation.item.create",
      item: {
        type: "message",
        role: "user",
        content: [
          {
            type: "input_text",
            text: "Give me one tip for a productive meeting.",
          },
        ],
      },
    }),
  );
  socket.send(JSON.stringify({ type: "response.create" }));
});

socket.addEventListener("message", ({ data }) => {
  const event = JSON.parse(data.toString());
  if (
    [
      "response.text.delta",
      "response.output_text.delta",
      "response.audio_transcript.delta",
      "response.output_audio_transcript.delta",
    ].includes(event.type)
  ) {
    process.stdout.write(event.delta || "");
  } else if (event.type === "error") {
    console.error(JSON.stringify(event.error || event, null, 2));
    socket.close();
    process.exitCode = 1;
  } else if (event.type === "response.done") {
    process.stdout.write("\n");
    socket.close();
  }
});

socket.addEventListener("error", (error) => {
  console.error("WebSocket error:", error.message || error);
  process.exitCode = 1;
});

Mogelijkheden

Bekijk de belangrijkste modelgegevens voordat u een architectuur kiest of de productiebelasting inschat.

Ondersteunde mogelijkheden

Functies die door de bestaande model-API worden geretourneerd.

text-to-speech

Invoer en uitvoer

Invoer

text

Uitvoer

audio

Productieprofiel

Aanbieder: OpenAI
Context: Afhankelijk van model
Commercieel gebruik: Ondersteund

Toepassingen

Gebruik GPT-Realtime-2.1 voor productieworkflows die passen bij de audio-mogelijkheden, en vergelijk vervolgens alternatieven voordat u zich vastlegt op een langetermijnintegratie.

Genereren van spraak, muziek en audio

Spraakervaringen en mediaproductie

Geautomatiseerde audioworkflows op schaal

Andere modellen

Vergelijk andere modellen die via CometAPI beschikbaar zijn op basis van kwaliteit, latentie, mogelijkheden en prijs.

gpt-audio-1.5

Het beste stemmodel voor audio-invoer, audio-uitvoer met Chat Completions.

Het beste spraakmodel voor audio-in, audio-uit.

TTS

OpenAI Tekst-naar-spraak

Kling TTS

[Spraaksynthese] Zojuist gelanceerd: tekst-naar-audio van uitzendkwaliteit online, met voorvertoning ● Kan tegelijkertijd een audio_id genereren, te gebruiken met elke Keling API.

Kling video-to-audio

Kling video-naar-audio