What industries can use GPT-Realtime-2.1 API?

GPT-Realtime-2.1 is suitable for customer service, sales automation, healthcare assistants, education platforms, and smart device applications.

How large is the GPT-Realtime-2.1 context window?

GPT-Realtime-2.1 supports a 128,000 token context window and up to 32,000 output tokens.

Can GPT-Realtime-2.1 API create real-time voice assistants?

Yes. GPT-Realtime-2.1 is designed for speech-to-speech applications and enables developers to build low-latency conversational voice agents.

What input and output modalities does GPT-Realtime-2.1 support?

GPT-Realtime-2.1 supports text and audio input/output plus image input, but it does not support video input.

What improvements does GPT-Realtime-2.1 have over GPT-Realtime-2?

GPT-Realtime-2.1 improves alphanumeric recognition, silence handling, noise robustness, and interruption behavior while maintaining realtime reasoning and tool-use capabilities.

When should developers choose GPT-Realtime-2.1 instead of GPT-4o Realtime API?

Developers should choose GPT-Realtime-2.1 for advanced voice agents requiring stronger reasoning, tool execution, and complex conversational workflows.

OpenAI

可使用熱門

gpt-realtime-2.1

GPT-Realtime-2.1 API

Q: Does GPT-Realtime-2.1 support function calling?

Yes. GPT-Realtime-2.1 supports tool use and function calling, allowing voice agents to execute external actions during conversations.

GPT-Realtime-2.1 updates GPT-Realtime-2 with improved alphanumeric recognition, silence and noise handling, and interruption behavior. It supports speech-to-speech interactions with configurable reasoning effort, instruction following, and tool use for complex voice-agent workflows.

起始價格

$3.20 / 100 萬輸入 tokens

按使用量計費

API 健康狀態

可使用

正式環境端點

回應時間

支援非同步

實測 API 回應時間

發布時間

Aug 6, 2026

OpenAI

概覽

GPT-Realtime-2.1 的實用總覽,涵蓋重要行為與整合注意事項。

Technical Specifications of GPT-Realtime-2.1

Specification	Details
Model name	GPT-Realtime-2.1
Provider	OpenAI
Model family	GPT-Realtime series
Model type	Real-time multimodal voice reasoning model
Primary capability	Speech-to-speech AI agents
Input modalities	Text, Audio, Image
Output modalities	Text, Audio
Context window	128,000 tokens
Maximum output tokens	32,000 tokens
Reasoning support	Configurable reasoning effort
Function calling	Supported
Structured outputs	Not supported
Fine-tuning	Not supported
Video input	Not supported
Main API endpoint	Realtime API
Knowledge cutoff	September 30, 2024

Source: OpenAI GPT-Realtime-2.1 model documentation.

What is GPT-Realtime-2.1?

GPT-Realtime-2.1 is OpenAI's advanced real-time voice model designed for building conversational AI agents that can listen, reason, and respond naturally through audio.

Compared with traditional voice assistants that rely on separate speech recognition, language understanding, and text-to-speech pipelines, GPT-Realtime-2.1 provides native speech-to-speech interaction, enabling lower-latency conversations with better interruption handling and contextual understanding.

The model is optimized for production voice applications including customer service agents, AI assistants, sales automation, education platforms, and interactive voice experiences.

GPT-Realtime-2.1 Benchmark Performance

GPT-Realtime-2.1 improvements focus on practical realtime interaction metrics:

Capability	Improvement
Voice interruption handling	Improved
Noise robustness	Improved
Alphanumeric recognition	Improved
Tool-based voice workflows	Supported
Speech-to-speech interaction	Supported

Main Features of GPT-Realtime-2.1

1. Native Speech-to-Speech Interaction

GPT-Realtime-2.1 removes the need for separate speech recognition and text-to-speech pipelines.

Traditional voice architecture:

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

GPT-Realtime-2.1:

User Voice
 ↓
GPT-Realtime-2.1
 ↓
Voice Response

This reduces latency and improves conversational flow.

2. Improved Voice Conversation Quality

GPT-Realtime-2.1 improves several real-world voice challenges:

Better interruption handling

Users can interrupt the AI naturally while it is speaking.

Example:

User:

"Book me a flight to—actually change that to Tokyo."

The model can recover from conversational changes without restarting the interaction.

Better silence and noise handling

The model is optimized for environments where audio quality is imperfect:

Call centers
Mobile devices
Public spaces
Smart devices

3. Advanced Voice Agent Tool Use

GPT-Realtime-2.1 supports tool calling, allowing voice agents to perform actions.

Examples:

Customer service:

User:
"Where is my order?"

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

Enterprise workflow:

Voice command
↓
Reasoning
↓
API execution
↓
Voice confirmation

This makes GPT-Realtime-2.1 suitable for autonomous voice agents.

4. Configurable Reasoning Capability

Unlike earlier realtime voice models optimized primarily for speed, GPT-Realtime-2.1 introduces configurable reasoning effort.

Developers can balance:

Response latency
Accuracy
Task complexity

Low reasoning:

Simple conversations
FAQ assistants

Higher reasoning:

Complex customer requests
Multi-step workflows
Business operations

5. Better Recognition of Numbers and Technical Information

Voice agents often struggle with:

Account numbers
Serial numbers
Addresses
Product codes
Financial information

GPT-Realtime-2.1 improves alphanumeric recognition, making it more suitable for enterprise voice systems.

6. Multimodal Input Support

GPT-Realtime-2.1 supports:

Input	Support
Text	✅
Audio	✅
Image	✅
Video	❌

Image input enables scenarios such as:

Visual customer support
Document interpretation
Camera-based assistants

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

Model	Strength	Best Use
GPT-Realtime-2.1	Best realtime reasoning + voice agent capability	Production voice agents
GPT-Realtime-2	Strong realtime voice reasoning	Advanced conversational apps
GPT-4o Realtime	Fast multimodal interaction	General voice assistants

GPT-Realtime-2.1 vs GPT-Realtime-2

GPT-Realtime-2.1 improves:

Voice interruption recovery
Noise handling
Recognition accuracy
Conversational robustness

Both models share:

Speech-to-speech architecture
Tool calling
Reasoning support
Realtime API access

GPT-Realtime-2.1 vs GPT-4o Realtime

GPT-Realtime-2.1 is positioned for more advanced agent workflows.

Compared with GPT-4o Realtime:

Capability	GPT-Realtime-2.1	GPT-4o Realtime
Reasoning	Stronger	General
Context	128K	32K
Tool use	Supported	Supported
Voice agents	Advanced	General
Complex workflows	Better suited	Suitable

How to Use GPT-Realtime-2.1 API with CometAPI

GPT-Realtime-2.1 is designed for low-latency voice agent applications. It supports real-time speech-to-speech interaction, audio input/output, image input, configurable reasoning effort, and function calling for tool-enabled voice workflows. OpenAI exposes it through the Realtime API, including WebRTC, WebSocket, and SIP-based real-time communication methods.

CometAPI provides a unified API layer for integrating advanced AI models, allowing developers to access GPT-Realtime-2.1-style workflows without maintaining separate provider authentication, SDK logic, and infrastructure.

Step 1: Get Your CometAPI API Key

Create a CometAPI account and generate an API token from the developer console.

Your API request should include:

Authorization: Bearer YOUR_COMETAPI_API_KEY
Content-Type: application/json

The API key authenticates your requests and allows your application to call available AI models through CometAPI.

Step 2: Create a GPT-Realtime-2.1 Session

GPT-Realtime-2.1 works through a persistent realtime session instead of traditional request-response chat completion.

A realtime session maintains:

Audio input stream
Model responses
Conversation state
Tool calls
Interruptions

OpenAI's Realtime API supports real-time communication through WebRTC, WebSocket, and SIP interfaces.

Example:

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."
}
'

Example response:

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

Step 3: Send Audio Input to GPT-Realtime-2.1

After creating a session, stream user audio.

Example workflow:

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

Audio input can include:

Phone conversations
Voice commands
Customer support calls
Interactive assistants

GPT-Realtime-2.1 improves speech interaction with better silence detection, noise handling, and interruption behavior compared with earlier realtime models.

Step 4: Receive Real-Time Audio Responses

The model returns generated audio responses through the realtime connection.

Example event:

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

Your application can immediately play received audio chunks.

Typical implementations:

WebRTC voice applications
Browser-based assistants
Mobile voice apps
AI phone agents

Step 5: Add Function Calling for Voice Agents

GPT-Realtime-2.1 supports function calling, allowing voice agents to execute external actions.

Example:

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

Possible voice-agent workflows:

"Where is my package?"
"Book me a meeting tomorrow."
"Cancel my subscription."
"Check my account balance."

The model can recognize the request, call the appropriate tool, and continue the conversation naturally.

Step 6: Configure Reasoning and Instructions

GPT-Realtime-2.1 supports configurable reasoning effort.

Example:

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

Recommended settings:

Application	Reasoning Level
Simple voice commands	Low
Customer support	Medium
Complex workflow agents	High

常見問題

定價

先參考上方的單次執行預估,再查看完整的 CometAPI 與官方價格比較。

第一次請求

—

預估 CometAPI 使用費用

十次請求

—

預估 CometAPI 使用費用

十五次請求

—

預估 CometAPI 使用費用

GPT-Realtime-2.1 的定價

探索 GPT-Realtime-2.1 的競爭性定價，專為滿足各種預算和使用需求而設計。我們靈活的方案確保您只需為實際使用量付費，讓您能夠隨著需求增長輕鬆擴展。了解 GPT-Realtime-2.1 如何在保持成本可控的同時提升您的專案效果。

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

API

複製可用的端點與程式碼範例,需要完整參數時再開啟完整 API 參考文件。

一個 API,直接對接正式環境模型

只需驗證一次,即可呼叫模型端點,並在各供應商間維持一致的計費與監控流程。

GET/v1/realtime

GPT-Realtime-2.1 的範例程式碼和 API

存取完整的範例程式碼和 API 資源，以簡化您的 GPT-Realtime-2.1 整合流程。我們詳盡的文件提供逐步指引，協助您在專案中充分發揮 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;
});

功能

在選擇架構或評估正式環境負載前,先掌握模型的關鍵資訊。

支援的功能

現有模型 API 回傳的功能。

text-to-speech

輸入與輸出

輸入

text

輸出

audio

正式環境資訊

供應商: OpenAI
上下文: 依模型而定
商業使用: 支援

應用場景

將 GPT-Realtime-2.1 用於符合其 audio 能力的正式工作流程,並在長期整合前比較其他選項。

語音、音樂與音訊生成

語音體驗與媒體製作

大規模自動化音訊工作流程

其他模型

比較 CometAPI 提供的其他模型,在品質、延遲、功能與價格間取得平衡。

開啟模型比較 →

OpenAI

gpt-audio-1.5

The best voice model for audio in, audio out with Chat Completions.

查看模型

OpenAI

GPT-Realtime-2

GPT-Realtime-2 is our most capable realtime voice model. It supports speech-to-speech interactions with configurable reasoning effort, stronger instruction following, and more reliable tool use for complex voice-agent workflows

查看模型

OpenAI

gpt-realtime-1.5

The best voice model for audio in, audio out.

OpenAI 文字轉語音

[語音合成] 全新上線：線上文字轉廣播級音訊，支援預覽功能 ● 可同時生成 audio_id，適用於任何 Keling API。

Uptime

在正式上線前,查看即時心跳資料、端點可用性與實測回應時間。

版本

在鎖定正式環境整合版本前,先查看可用的模型識別碼。

gpt-realtime-2.1

gpt-realtime-2.1-mini

持續探索

比較模型,繼續你的研究

OpenAI

可使用熱門

gpt-realtime-2.1

GPT-Realtime-2.1 API

起始價格

$3.20 / 100 萬輸入 tokens

按使用量計費

API 健康狀態

可使用

正式環境端點

回應時間

支援非同步

實測 API 回應時間

發布時間

Aug 6, 2026

OpenAI

概覽

GPT-Realtime-2.1 的實用總覽,涵蓋重要行為與整合注意事項。

Technical Specifications of GPT-Realtime-2.1

Specification	Details
Model name	GPT-Realtime-2.1
Provider	OpenAI
Model family	GPT-Realtime series
Model type	Real-time multimodal voice reasoning model
Primary capability	Speech-to-speech AI agents
Input modalities	Text, Audio, Image
Output modalities	Text, Audio
Context window	128,000 tokens
Maximum output tokens	32,000 tokens
Reasoning support	Configurable reasoning effort
Function calling	Supported
Structured outputs	Not supported
Fine-tuning	Not supported
Video input	Not supported
Main API endpoint	Realtime API
Knowledge cutoff	September 30, 2024

Source: OpenAI GPT-Realtime-2.1 model documentation.

What is GPT-Realtime-2.1?

GPT-Realtime-2.1 is OpenAI's advanced real-time voice model designed for building conversational AI agents that can listen, reason, and respond naturally through audio.

The model is optimized for production voice applications including customer service agents, AI assistants, sales automation, education platforms, and interactive voice experiences.

GPT-Realtime-2.1 Benchmark Performance

GPT-Realtime-2.1 improvements focus on practical realtime interaction metrics:

Capability	Improvement
Voice interruption handling	Improved
Noise robustness	Improved
Alphanumeric recognition	Improved
Tool-based voice workflows	Supported
Speech-to-speech interaction	Supported

Main Features of GPT-Realtime-2.1

1. Native Speech-to-Speech Interaction

GPT-Realtime-2.1 removes the need for separate speech recognition and text-to-speech pipelines.

Traditional voice architecture:

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

GPT-Realtime-2.1:

User Voice
 ↓
GPT-Realtime-2.1
 ↓
Voice Response

This reduces latency and improves conversational flow.

2. Improved Voice Conversation Quality

GPT-Realtime-2.1 improves several real-world voice challenges:

Better interruption handling

Users can interrupt the AI naturally while it is speaking.

Example:

User:

"Book me a flight to—actually change that to Tokyo."

The model can recover from conversational changes without restarting the interaction.

Better silence and noise handling

The model is optimized for environments where audio quality is imperfect:

Call centers
Mobile devices
Public spaces
Smart devices

3. Advanced Voice Agent Tool Use

GPT-Realtime-2.1 supports tool calling, allowing voice agents to perform actions.

Examples:

Customer service:

User:
"Where is my order?"

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

Enterprise workflow:

Voice command
↓
Reasoning
↓
API execution
↓
Voice confirmation

This makes GPT-Realtime-2.1 suitable for autonomous voice agents.

4. Configurable Reasoning Capability

Unlike earlier realtime voice models optimized primarily for speed, GPT-Realtime-2.1 introduces configurable reasoning effort.

Developers can balance:

Response latency
Accuracy
Task complexity

Low reasoning:

Simple conversations
FAQ assistants

Higher reasoning:

Complex customer requests
Multi-step workflows
Business operations

5. Better Recognition of Numbers and Technical Information

Voice agents often struggle with:

Account numbers
Serial numbers
Addresses
Product codes
Financial information

GPT-Realtime-2.1 improves alphanumeric recognition, making it more suitable for enterprise voice systems.

6. Multimodal Input Support

GPT-Realtime-2.1 supports:

Input	Support
Text	✅
Audio	✅
Image	✅
Video	❌

Image input enables scenarios such as:

Visual customer support
Document interpretation
Camera-based assistants

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

Model	Strength	Best Use
GPT-Realtime-2.1	Best realtime reasoning + voice agent capability	Production voice agents
GPT-Realtime-2	Strong realtime voice reasoning	Advanced conversational apps
GPT-4o Realtime	Fast multimodal interaction	General voice assistants

GPT-Realtime-2.1 vs GPT-Realtime-2

GPT-Realtime-2.1 improves:

Voice interruption recovery
Noise handling
Recognition accuracy
Conversational robustness

Both models share:

Speech-to-speech architecture
Tool calling
Reasoning support
Realtime API access

GPT-Realtime-2.1 vs GPT-4o Realtime

GPT-Realtime-2.1 is positioned for more advanced agent workflows.

Compared with GPT-4o Realtime:

Capability	GPT-Realtime-2.1	GPT-4o Realtime
Reasoning	Stronger	General
Context	128K	32K
Tool use	Supported	Supported
Voice agents	Advanced	General
Complex workflows	Better suited	Suitable

How to Use GPT-Realtime-2.1 API with CometAPI

Step 1: Get Your CometAPI API Key

Create a CometAPI account and generate an API token from the developer console.

Your API request should include:

Authorization: Bearer YOUR_COMETAPI_API_KEY
Content-Type: application/json

The API key authenticates your requests and allows your application to call available AI models through CometAPI.

Step 2: Create a GPT-Realtime-2.1 Session

GPT-Realtime-2.1 works through a persistent realtime session instead of traditional request-response chat completion.

A realtime session maintains:

Audio input stream
Model responses
Conversation state
Tool calls
Interruptions

OpenAI's Realtime API supports real-time communication through WebRTC, WebSocket, and SIP interfaces.

Example:

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."
}
'

Example response:

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

Step 3: Send Audio Input to GPT-Realtime-2.1

After creating a session, stream user audio.

Example workflow:

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

Audio input can include:

Phone conversations
Voice commands
Customer support calls
Interactive assistants

GPT-Realtime-2.1 improves speech interaction with better silence detection, noise handling, and interruption behavior compared with earlier realtime models.

Step 4: Receive Real-Time Audio Responses

The model returns generated audio responses through the realtime connection.

Example event:

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

Your application can immediately play received audio chunks.

Typical implementations:

WebRTC voice applications
Browser-based assistants
Mobile voice apps
AI phone agents

Step 5: Add Function Calling for Voice Agents

GPT-Realtime-2.1 supports function calling, allowing voice agents to execute external actions.

Example:

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

Possible voice-agent workflows:

"Where is my package?"
"Book me a meeting tomorrow."
"Cancel my subscription."
"Check my account balance."

The model can recognize the request, call the appropriate tool, and continue the conversation naturally.

Step 6: Configure Reasoning and Instructions

GPT-Realtime-2.1 supports configurable reasoning effort.

Example:

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

Recommended settings:

Application	Reasoning Level
Simple voice commands	Low
Customer support	Medium
Complex workflow agents	High

常見問題

定價

先參考上方的單次執行預估,再查看完整的 CometAPI 與官方價格比較。

第一次請求

—

預估 CometAPI 使用費用

十次請求

—

預估 CometAPI 使用費用

十五次請求

—

預估 CometAPI 使用費用

GPT-Realtime-2.1 的定價

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

API

複製可用的端點與程式碼範例,需要完整參數時再開啟完整 API 參考文件。

一個 API,直接對接正式環境模型

只需驗證一次,即可呼叫模型端點,並在各供應商間維持一致的計費與監控流程。

GET/v1/realtime

GPT-Realtime-2.1 的範例程式碼和 API

存取完整的範例程式碼和 API 資源，以簡化您的 GPT-Realtime-2.1 整合流程。我們詳盡的文件提供逐步指引，協助您在專案中充分發揮 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;
});