OpenAI Releases GPT-Realtime-2.1 and GPT-Realtime-2.1-mini Real-Time Voice Models: the mini Model Now Reasons, Latency Down 25%

Where Voice Assistants Used to Get Stuck

Voice assistants used to stall out whenever they called a tool. The model would go silent right after triggering a function call, the user would assume the call had dropped, then either talk over it or just hang up — breaking the conversation state and leaving the user with a half-finished result they'd have to redo from scratch.

Reasoning Moves Into the Mini Tier — How It Fixes the Silence Problem

This section is the heart of the release: pushing reasoning down into the low-cost mini tier, paired with a "spoken heads-up," is exactly what fixes the dead-air problem from the last section.

What "Reasoning" Means Here

Reasoning means the model thinks through how to handle a request — and whether to call a tool — before it opens its mouth, instead of blurting out whatever comes to mind the instant it hears something. The mini tier now also supports function calling, so it can plan a step ahead, call your function, and then deliver an answer.

Breaking down a single tool-using exchange, the sequence looks like this:

Five Reasoning Levels — Trading Off Latency Against Quality

Reasoning effort is configurable across five levels, from low to high: minimal, low, medium, high, xhigh. Low is the default and keeps latency down for simple exchanges; higher levels mean more latency and more output tokens. OpenAI recommends most production voice assistants start at low and only dial it up for harder tasks.

Choosing Between the Two Models

In short: for the strongest real-time reasoning, tool calling, instruction-following, and voice-assistant behavior, use the full gpt-realtime-2.1; for faster and cheaper with "good enough" capability, use gpt-realtime-2.1-mini.

25% Lower Latency — How Caching Saves Money

This round's latency improvement comes from caching optimizations. And caching doesn't just save time — it saves a lot of money too.

First, What Is "p95 Latency"

p95 latency is what you get when you line up every request's response time from fastest to slowest and take the value sitting at the 95th percentile. It represents how long the slowest 5% of users actually waited — not the average. For real-time voice, the stutter users actually notice is hiding in that slow tail. Cutting that tail by at least 25% makes a noticeable difference in how responsive a call feels.

Why Cache Hits Cut the Price So Much

A cached input hit means this turn of the conversation is continuing from a system prompt or history that's already been processed — the service recognizes "this part's already computed," reuses it instead of recomputing, and the price drops sharply as a result. The system prompt gets cached after the first turn, so the longer the conversation and the more it's reused, the more you save. Here's the gap between cached and fresh pricing for the mini's audio input:

Full Pricing Across All Three Models

All prices are per million tokens, split into text, audio, and image categories. Click a tab to switch views; the mini column is highlighted.

What It's Good For

Four typical scenarios, and how each one puts reasoning, tool calling, and the recognition improvements to work:

What Integration Looks Like

The minimal setup looks like this: the server first mints a short-lived client credential (the standard API key stays server-side and never gets exposed), and the browser uses that short-lived credential to connect directly via WebRTC, establishing a microphone track and a data channel to send and receive events.

The connection method depends on the scenario: browsers and mobile apps capturing and playing audio directly use WebRTC; servers that already have a raw audio stream (call centers, media pipelines) use WebSocket; phone voice agents use SIP.

// Server: mint a short-lived client secret
const r = await fetch("https://api.openai.com/v1/realtime/client_secrets", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    session: {
      type: "realtime",
      model: "gpt-realtime-2.1-mini",
      instructions: "You are a support agent. Reply in one or two short sentences.",
      reasoning: { effort: "low" },
      tools: [
        {
          type: "function",
          name: "lookup_account",
          description: "Look up a customer account by email.",
          parameters: {
            type: "object",
            properties: { email: { type: "string" } },
            required: ["email"]
          }
        }
      ],
      tool_choice: "auto"
    }
  })
});
const { value: EPHEMERAL_KEY } = await r.json(); // pass this to the browser

// Browser: connect to the Realtime API over WebRTC
const pc = new RTCPeerConnection();

const audioEl = document.createElement("audio");
audioEl.autoplay = true;
pc.ontrack = (e) => { audioEl.srcObject = e.streams[0]; };

const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
pc.addTrack(mic.getTracks()[0]);

const events = pc.createDataChannel("oai-events");
events.addEventListener("message", (e) => console.log(JSON.parse(e.data)));

const offer = await pc.createOffer();
await pc.setLocalDescription(offer);

const sdp = await fetch("https://api.openai.com/v1/realtime/calls", {
  method: "POST",
  body: offer.sdp,
  headers: {
    Authorization: `Bearer ${EPHEMERAL_KEY}`,
    "Content-Type": "application/sdp"
  }
});
await pc.setRemoteDescription({ type: "answer", sdp: await sdp.text() });

This is a full GA endpoint, not a beta. If your app distinguishes between end users, OpenAI recommends adding an OpenAI-Safety-Identifier header to the credential-minting request (e.g., a hash of an internal user ID), so that when the platform monitors for abuse it can pinpoint a specific user instead of mistakenly flagging the whole account.

Strengths and Limitations

Per OpenAI's own claims, here's both sides of this release: