# OpenAI Realtime API — OpenAI's own speech-to-speech model API for voice agents: WebRTC, WebSocket or native SIP telephony, billed purely on audio tokens with no platform fee.

> Source: The Agents Index — https://theagentsindex.com/openai-realtime-api (structured, researched, re-verified)
> Facts last verified: 2026-08-23

The OpenAI Realtime API is OpenAI's own speech-to-speech model API for building real-time voice agents: one model call handles listening, reasoning, tool use and speaking, rather than chaining separate speech-to-text, LLM and text-to-speech services together. OpenAI first previewed it at DevDay in October 2024. The original `gpt-realtime` model reached general availability on August 28, 2025, alongside native SIP telephony, remote MCP server support and image input. A second-generation `gpt-realtime-2` with configurable reasoning effort shipped May 7, 2026, with `gpt-realtime-translate` and `gpt-realtime-whisper` added on dedicated `/v1/realtime/translations` and `/v1/realtime/transcription_sessions` endpoints at the same time. The current-generation `gpt-realtime-2.1` and the smaller `gpt-realtime-2.1-mini` shipped July 6, 2026. The API connects over WebRTC for browser and mobile clients, WebSocket for server-side pipelines, or SIP for real phone calls, and bills purely on audio and text tokens rather than a platform subscription or a per-minute rate.

| Fact | Value |
| --- | --- |
| Website | https://developers.openai.com/api/docs/guides/realtime |
| Pricing | Purely usage-based, billed on audio and text tokens (and on audio duration for the translation and transcription endpoints). No monthly platform fee and no dedicated free tier for the Realtime API itself. `gpt-realtime-2.1`: audio $32/$64 per 1M tokens in/out (cached audio input $0.40), text $4/$24 per 1M tokens in/out (cached text input $0.40). The smaller `gpt-realtime-2.1-mini`: audio $10/$20 per 1M tokens in/out (cached audio input $0.30), text $0.60/$2.40 per 1M tokens in/out (cached text input $0.06). OpenAI's Realtime conversations guide recommends keeping conversation history static to maximise prompt-cache hit rate; with caching in production, audio/text activity of roughly 600 input plus 1,200 output audio tokens per minute works out to an estimated $0.06-$0.11/min on the flagship model, or roughly a third of that on the mini model. Cost rises with conversation length because the conversation is appended to the prompt on each turn, with a 28,224-token headroom before the model's 32,000-token context forces truncation at a 4,096 max output. |
| API | Yes |
| Best for | Engineering teams building a voice agent from scratch who want to go directly to OpenAI's own speech-to-speech model (no orchestration platform, no per-minute markup) and are comfortable being single-vendor on OpenAI. |
| Not for | Non-technical teams who want a working voice agent without writing code, or anyone who wants CRM integrations, call analytics or a dashboard out of the box: a managed platform like Vapi, Retell AI, Bland AI or Synthflow AI fits that need better. |

## Pricing

| Tier | Price |
| --- | --- |
| gpt-realtime-2.1 | $32 / $64 audio / per 1M tokens |
| gpt-realtime-2.1-mini | $10 / $20 audio / per 1M tokens |
| Translation endpoint (gpt-realtime-translate) | Custom, contact sales (per audio minute) |
| Transcription endpoint (gpt-realtime-whisper / gpt-live-transcribe) | Custom, contact sales (per audio minute) |

## Verdict

The OpenAI Realtime API is the rawest option in this category: not an orchestration platform or a managed dashboard, but the actual speech-to-speech model some of this category's own platforms let you plug in as one provider choice among several (LiveKit Agents' plugin ecosystem lists it directly). Going straight to OpenAI trades every convenience those platforms bundle (a dashboard, built-in phone numbers, call analytics, a knowledge base) for direct, usage-based token pricing with no markup and no monthly platform fee, backed by OpenAI's own SOC 2 Type 2 and ISO 27001-family compliance. The tradeoffs are real: sessions cap at 60 minutes, there's no dashboard or built-in CRM, and a developer writes their own tool-calling, session-management and observability code. Pick it over a platform like Vapi or Retell AI when the priority is owning the integration layer entirely and being comfortable single-vendor on OpenAI; pick a platform instead when the priority is a working agent without writing that plumbing.

## How it works

1. Open a session against the Realtime API using a short-lived ephemeral client secret from `POST /v1/realtime/client_secrets` (no long-lived API key in the browser); WebRTC connection helper: `POST /v1/realtime/calls`
2. Choose a model. `gpt-realtime-2.1` is the flagship reasoning-capable option. `gpt-realtime-2.1-mini` is the faster, lower-cost distilled version. Use a separate endpoint for translation (`/v1/realtime/translations`) or transcription (transcription sessions)
3. Connect over WebRTC (browser and mobile), WebSocket (server-side audio pipelines) or SIP (real phone calls). Set `turn_detection: semantic_vad` for automatic turn-taking with interruption handling, or disable it for manual control
4. The model calls developer-defined functions mid-conversation (look up an order, check a calendar) and speaks the result back once the client returns it. Configure a `truncation.retention_ratio` below 1 to control context size and cache behaviour
5. Sessions cap at 60 minutes; billing is purely usage-based. Voice-agent sessions accrue audio and text input plus output tokens. Translation and transcription sessions accrue audio duration instead

## Who it's for

- Engineering teams that want to go straight to OpenAI's own speech-to-speech model with no orchestration platform in between, and are comfortable owning the integration layer themselves
- Teams already building on an orchestration framework (like LiveKit Agents) who want to plug OpenAI's model in as the speech-to-speech provider rather than assembling a separate STT/LLM/TTS pipeline
- Buyers who want transparent, usage-based token pricing with no platform markup, and don't need a dashboard, call analytics or CRM integrations bundled in

## Strengths and weaknesses

- ✓ The only entry in this category priced purely in raw model tokens with no platform fee or per-minute markup. gpt-realtime-2.1 audio $32/$64 per 1M tokens in/out; gpt-realtime-2.1-mini $10/$20.
- ✓ Native SIP telephony, WebRTC and WebSocket support all ship directly in the API. Real phone calls with no separate telephony vendor required for the connection itself.
- ✓ OpenAI's API Platform (which the Realtime API is part of) carries SOC 2 Type 2, ISO/IEC 27001:2022, ISO/IEC 27017, ISO/IEC 27018 and ISO/IEC 27701 certification.
- ✓ Session-level cost controls built into the protocol. Truncation ratio and token-limit settings plus automatic prompt caching let a developer cap input cost without external tooling.
- ✗ Sessions cap at 60 minutes. A hard platform limit other vendors in this category abstract away, so a long-running call needs a session-handoff strategy the developer builds themselves.
- ✗ No dashboard, call analytics, CRM integrations or dedicated free tier. Every session, tool call and downstream integration is code a developer writes and maintains, unlike this category's managed platforms.
- ✗ Single-vendor on OpenAI's own models only. Unlike Vapi, Retell AI or LiveKit Agents there is no bring-your-own-model option if a team wants a different LLM or voice provider.
- ✗ Flagship reasoning model is real-time expensive at scale. gpt-realtime-2.1 audio output is $64 per 1M tokens, and `reasoning.effort: high` measurably increases latency and output token usage per turn.
- ⚠ 60-minute maximum session duration.
- ⚠ No dashboard, call analytics or CRM / helpdesk integrations. A developer builds and maintains all of that.
- ⚠ No dedicated free tier for the Realtime API.
- ⚠ Single-vendor on OpenAI's own models only. No bring-your-own-model option for the speech-to-speech layer (the underlying LLM does run OpenAI models only).
- ⚠ 32,000-token context window on the flagship model: a long-running call needs a truncation strategy to keep cost and latency stable.

## Key features

- **Native speech-to-speech model** — One model call handles listening, reasoning, tool use and speaking. No separate STT, LLM and TTS chain to assemble and keep in sync. Configurable reasoning effort on gpt-realtime-2 and newer.
- **Three connection modes, including native SIP** — WebRTC for browser and mobile clients, WebSocket for server pipelines, or SIP for real phone calls. No separate telephony vendor is required for the connection itself.
- **Server-side session controls** — `truncation.retention_ratio` and `token_limits.post_instructions` cut input cost and shape what is sent to the model each turn. Prompt caching is automatic and works best when conversation history is static.
- **Mid-conversation function calling** — The model invokes developer-defined functions live during a call and speaks the result back once the client returns it. Webhooks and server-side controls can drive a session from outside the client.
- **Configurable turn detection** — `semantic_vad` is on by default: the model decides when the caller has stopped speaking and handles interruptions automatically. Can be disabled for manual, push-to-talk-style control.
- **Image input on Realtime 2 and newer** — `gpt-realtime-2`, `gpt-realtime-2.1` and their mini variants accept image input alongside audio, so an agent can reason over what is on screen or in a photo mid-call.
- **Separate translation and transcription endpoints** — Dedicated `/v1/realtime/translations` and `/v1/realtime/transcription_sessions` endpoints, billed on audio duration rather than tokens, for streaming translation and transcription workflows.

## Use cases

- **Custom voice agent built without a platform** — An engineering team writes its own session, tool-calling and telephony-handoff code directly against the model, paying only for tokens used with no platform markup on top.
- **The model layer beneath an orchestration framework** — A team building on LiveKit Agents or a similar framework plugs OpenAI's Realtime API in as the speech-to-speech provider, keeping the framework's session and turn-detection plumbing while OpenAI's model does the listening, reasoning and speaking.
- **Inbound phone support over native SIP** — A support line connects directly over SIP with no separate telephony vendor, with the model verifying the caller and pulling account context via function calls before escalating to a human when needed.

## Integrations

SIP trunking (native — real inbound/outbound phone calls with no separate telephony vendor required) · Model Context Protocol (MCP) — connects to remote MCP servers for external tool access · No native CRM, helpdesk or dashboard integrations — a developer wires session events, function calls and any downstream system into their own client/server code

## Sources

- https://developers.openai.com/api/docs/guides/realtime
- https://developers.openai.com/api/docs/guides/realtime-conversations
- https://developers.openai.com/api/docs/guides/realtime-costs
- https://developers.openai.com/api/docs/pricing
- https://developers.openai.com/api/docs/models/gpt-realtime-2.1
- https://developers.openai.com/api/docs/changelog
- https://trust.openai.com/