OpenAI has released two new Realtime models in its API. They are named gpt-realtime-2.1 and gpt-realtime-2.1-mini. Both target low-latency voice and multimodal experiences. The mini model is the notable part of this release. It is a mini reasoning model for realtime voice. It ships at the same cost as the earlier gpt-realtime-mini. OpenAI also reduced p95 latency by at least 25% across Realtime voice models. That reduction comes from improved caching.

What is GPT-Realtime-2.1-mini

gpt-realtime-2.1-mini is a mini reasoning model for realtime voice interactions. It responds to audio and text inputs over a live connection. OpenAI positions it as the faster, more cost-efficient option in the lineup.

The Realtime API processes and generates audio through a single model. This avoids chaining separate speech-to-text and text-to-speech systems. That single-model design reduces latency and preserves nuance in speech.

Reasoning is the main capability here. It means the model can think internally before it speaks. The mini tier also supports tool use, or function calling, through the Realtime API. Together these let the mini model plan a step, call your function, then answer.

The larger sibling is gpt-realtime-2.1. It updates GPT-Realtime-2 with improved alphanumeric recognition. It also improves silence and noise handling, and interruption behavior. It supports speech-to-speech with configurable reasoning effort, instruction following, and tool use.

A quick way to choose between them: use gpt-realtime-2.1 when you want the strongest realtime reasoning, tool use, instruction following, and voice-agent behavior. Use gpt-realtime-2.1-mini when you want a faster, more cost-efficient option.

Voice agents often stall during tool calls. The model fires a function call, then goes silent. Users assume the call dropped and interrupt. That creates partial results and confused conversation state.

Reasoning and a spoken preamble fixes this pattern. The model can say ‘I’ll check that order now’ before acting. It keeps talking while it works through a request. That behavior keeps multi-step voice tasks coherent.

Reasoning effort is configurable across levels. Developers can select minimal, low, medium, high, or xhigh. Low is the default and keeps latency down for simple turns. Higher effort increases latency and output token usage. OpenAI advises starting low for most production voice agents.

The Latency and Caching Improvement

p95 latency is the 95th-percentile response time. It captures the slow tail that users actually feel. A cut of at least 25% on that tail helps live voice. Improved caching drives this reduction across the Realtime voice models.

Caching also lowers cost, not just latency. Cached input tokens are billed at a steep discount. For gpt-realtime-2.1-mini, cached audio input drops to $0.30 per 1M. Fresh audio input costs $10.00 per 1M by comparison. Long sessions benefit most, because the system prompt caches after the first turn.

Pricing and Comparison

Pricing is per 1M tokens, split by text, audio, and image. The mini keeps the previous mini rate while adding reasoning. The table below lists the published figures.

The mini audio output rate is $20.00 per 1M. The full gpt-realtime-2.1 charges $64.00 for the same. That is roughly a 3x gap on audio output. Teams can trade some capability for lower cost while keeping reasoning.

Use Cases with Examples

• Customer support triage: A caller reports a billing error over the phone. The mini model reasons about the issue at low effort. It calls a lookup_account tool, then a check_invoice tool. It narrates each step so the caller stays informed.
• Appointment scheduling: A user asks to move a booking to next Tuesday. The model captures the exact date character by character. It confirms details, then calls a reschedule function. Confirmed values prevent tool calls on guessed inputs.
• In-app voice assistant: A mobile app streams microphone audio over WebRTC. The mini model answers product questions in one or two short sentences. Lower cost lets the feature run at higher volume.
• Field data capture: A technician asks the agent to log a part number. Improved alphanumeric recognition helps capture codes like ‘8-3-5-7-1’. The model reads the value back for confirmation before acting.

Minimal Implementation

Browser clients connect over WebRTC. Your server mints a short-lived client secret first. The browser then connects directly to the Realtime API. Server media pipelines use WebSockets, and telephony uses SIP.

First, the server creates an ephemeral client secret. Keep your standard API key on the server. The session config sets the model, low reasoning effort, and one tool.

// Server: mint a short-lived client secret (API key stays server-side)
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

Next, the browser opens a WebRTC peer connection. It adds the microphone track and a data channel for events. It then posts its SDP offer to the calls endpoint.

// Browser: connect to the Realtime API over WebRTC
// EPHEMERAL_KEY comes from your server endpoint above.
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() });

Start reasoning effort at low, then raise it only for harder tasks. Add short instructions that separate hard rules from defaults. Run evals before and after any model migration.

Strengths and Weaknesses

Strengths:

• Reasoning now reaches the low-cost mini tier.
• Pricing matches the prior gpt-realtime-mini rate.
• p95 latency is down at least 25% across Realtime voice models.
• Configurable reasoning effort trades latency for depth per task.
• Single-model audio pipeline keeps conversations natural.

Weaknesses:

• Audio token pricing is hard to convert into per-call cost.
• Higher reasoning effort raises both latency and output tokens.
• Long sessions resubmit context and grow input cost without pruning.
• The mini tier trades some capability against the full gpt-realtime-2.1.

Interactive Explainer

Check out the Technical details here. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us