From OpenAI's pages, SDK releases and package code, read 17 November 2026 · Updated

OpenAI tts-1 and gpt-4o-mini-tts shutdown: what to write instead of audio.speech.create

OpenAI removes tts-1, tts-1-hd, gpt-4o-mini-tts and its dated snapshots gpt-4o-mini-tts-2025-03-20 and gpt-4o-mini-tts-2025-12-15 from its API on 6 January 2027. Every model OpenAI's reference lists for POST /v1/audio/speech, the call behind client.audio.speech.create, is on that list. OpenAI's replacement is gpt-realtime-2.1-mini, and its text-to-speech guide calls the move "a change of API workflow: gpt-realtime-2.1-mini isn't a supported model for /v1/audio/speech." Changing the model name in your request will not work. The code has to be rewritten to use the Realtime API or another route. The rewrite is below.

This week, check one thing: does your code or your framework pick the model for you? LiveKit's OpenAI plugin, Pipecat, Mastra, agno and Open WebUI send one of these models when you name none, and Home Assistant suggests one for a new text-to-speech entity, so a search of your own files can find nothing. The table of defaults is below. For the names your own code writes, paste the code or a list of model IDs into the shutdown check.

What OpenAI removes on 6 January 2027

Each row is from OpenAI's deprecations page and Speech API reference, read on 17 November 2026. The page marks all of them Deprecated, with the notice dated 1 October 2026.

IDRemoved onListed replacementWhat your call sends today
tts-16 January 2027gpt-realtime-2.1-minimodel: "tts-1"
tts-1-hd6 January 2027gpt-realtime-2.1-minimodel: "tts-1-hd"
gpt-4o-mini-tts6 January 2027gpt-realtime-2.1-minimodel: "gpt-4o-mini-tts"
gpt-4o-mini-tts-2025-03-206 January 2027gpt-realtime-2.1-minithe dated snapshot, if you pinned it
gpt-4o-mini-tts-2025-12-156 January 2027gpt-realtime-2.1-minithe dated snapshot, if you pinned it

OpenAI's reference page says the same date for all five. The reference's list of accepted model values names four of them and not gpt-4o-mini-tts-2025-03-20, and the current Python SDK's SpeechModel type lists the same four; the older snapshot is on the deprecations page. A call that names the dated snapshot is in scope either way.

OpenAI's page says that in some cases developers may be able to provision dedicated capacity for continued access after a shutdown date, and points to its sales team. It defines the shutdown state as "The model no longer accepts requests through the standard API."

What the Speech endpoint will return after 6 January

We do not know yet. OpenAI's pages print no error code or message for a model in the shutdown state, and we have not seen one from /v1/audio/speech: no model has been removed yet, and a GitHub and web search on 17 November 2026 found no report of a removed model on this endpoint. We hold no OpenAI key and did not send a request, so we do not quote a guess. For comparison only: OpenAI's chat and Responses endpoints answered other removed models with a 404 model_not_found error saying the model "has been deprecated", and its Images endpoint with a 400 saying the model "does not exist". Do not assume the Speech endpoint answers like either.

IDError text from /v1/audio/speech after 6 January 2027
tts-1not yet seen
tts-1-hdnot yet seen
gpt-4o-mini-ttsnot yet seen
gpt-4o-mini-tts-2025-03-20not yet seen
gpt-4o-mini-tts-2025-12-15not yet seen

We will add the exact text, status code and date here when we see it from OpenAI. If you hit it first, a search for your own error text plus audio.speech is the quickest way to find out whether others see the same.

The rewrite: text in, an audio file out

OpenAI's text-to-speech guide gives one migration route, the Realtime API with gpt-realtime-2.1-mini. OpenAI's audio overview names a second route, audio output from a chat model on Chat Completions. Both change what your code does, not just the model name.

Route 1: the Realtime API (the route OpenAI names)

The Realtime API is a WebSocket session: you connect, ask for one response, collect audio chunks until response.done, and close. The shortest version of that, built from OpenAI's own Realtime and SDK documentation, is below. It asks for a response with an empty input list (no earlier context) and the instruction "Say exactly the following", the pattern OpenAI's Realtime guide shows for inserting a fixed line into a conversation.

Python (pip install "openai[realtime]"; checked against openai 3.52.0):

import asyncio
import base64
import wave

from openai import AsyncOpenAI

TEXT = "Today is a wonderful day to build something people love!"


async def main() -> None:
    client = AsyncOpenAI()
    pcm = bytearray()
    async with client.realtime.connect(model="gpt-realtime-2.1-mini") as conn:
        await conn.response.create(
            response={
                "input": [],  # no earlier context
                "output_modalities": ["audio"],
                "audio": {"output": {"voice": "marin"}},
                "instructions": f"Say exactly the following:\n{TEXT}",
            }
        )
        async for event in conn:
            if event.type == "response.output_audio.delta":
                pcm += base64.b64decode(event.delta)
            elif event.type == "error":
                raise RuntimeError(event.error.message)
            elif event.type == "response.done":
                if event.response.status != "completed":
                    raise RuntimeError(f"response {event.response.status}")
                break

    with wave.open("speech.wav", "wb") as f:  # PCM 16-bit, mono, 24 kHz
        f.setnchannels(1)
        f.setsampwidth(2)
        f.setframerate(24000)
        f.writeframes(bytes(pcm))


asyncio.run(main())

Node.js 22 or later (npm install openai ws; checked against openai 7.57.0):

import { writeFile } from "node:fs/promises";
import { OpenAIRealtimeWS } from "openai/realtime/ws";

const TEXT = "Today is a wonderful day to build something people love!";
const chunks = [];

const rt = new OpenAIRealtimeWS({ model: "gpt-realtime-2.1-mini" });

rt.socket.on("open", () => {
  rt.send({
    type: "response.create",
    response: {
      input: [], // no earlier context
      output_modalities: ["audio"],
      audio: { output: { voice: "marin" } },
      instructions: `Say exactly the following:\n${TEXT}`,
    },
  });
});

rt.on("response.output_audio.delta", (e) => {
  chunks.push(Buffer.from(e.delta, "base64"));
});
rt.on("error", (err) => {
  throw err;
});
rt.on("response.done", async (e) => {
  rt.close();
  if (e.response.status !== "completed") throw new Error(`response ${e.response.status}`);
  const pcm = Buffer.concat(chunks);
  const h = Buffer.alloc(44); // 16-bit mono PCM at 24 kHz
  h.write("RIFF", 0); h.writeUInt32LE(36 + pcm.length, 4); h.write("WAVEfmt ", 8);
  h.writeUInt32LE(16, 16); h.writeUInt16LE(1, 20); h.writeUInt16LE(1, 22);
  h.writeUInt32LE(24000, 24); h.writeUInt32LE(48000, 28); h.writeUInt16LE(2, 32);
  h.writeUInt16LE(16, 34); h.write("data", 36); h.writeUInt32LE(pcm.length, 40);
  await writeFile("speech.wav", Buffer.concat([h, pcm]));
});

What changes compared with audio.speech.create:

  • It is a model that replies, not a reader. The Speech endpoint spoke your text. A Realtime model follows instructions, and OpenAI's SDK reference says of instructions that they "are not guaranteed to be followed". "Say exactly the following" is the wording of OpenAI's own no-context example, which asks for text output; we did not run it with audio output. OpenAI Support wrote on its developer forum on 17 November 2026: "We haven’t announced a drop-in replacement for /v1/audio/speech or a mode that guarantees it’ll read new text word for word." Check on your own text that the audio says what you sent, including numbers, names and long inputs.
  • Raw audio, not MP3. The output format options are audio/pcm at 24 kHz, audio/pcmu and audio/pcma. The examples above wrap the 16-bit mono PCM in a WAV header. MP3, Opus, AAC and FLAC, which the Speech endpoint offered, are not on that list; if your app needs one of them, you convert the PCM yourself.
  • Chunks, not a file. Audio arrives as base64 in response.output_audio.delta events. response.done carries a transcript, not audio.
  • Voices differ. The Realtime voices OpenAI lists are alloy, ash, ballad, coral, echo, sage, shimmer, verse, marin and cedar. OpenAI's text-to-speech guide lists fable, nova and onyx for the Speech endpoint's tts-1 and tts-1-hd; they are not on the Realtime list, so a request for one of them needs a different voice. The examples use marin, one of the two voices OpenAI recommends for best quality; alloy and coral are on both lists, and we did not compare how a name sounds on each.
  • Tone instructions. If you pass instructions to gpt-4o-mini-tts, the Realtime instructions field also takes free text. We did not test whether the voice behaves the same.
  • A different route. The model page lists gpt-realtime-2.1-mini as supported on v1/realtime and not supported on v1/audio/speech, v1/chat/completions or v1/responses.
  • Browsers and phones. OpenAI recommends WebRTC rather than WebSocket for audio in a browser or mobile client, with ephemeral credentials from your server. The example above is for a server.

We checked each method and event name in these examples by reading the current SDK releases, openai 3.52.0 for Python and 7.57.0 for Node, and we ran both files unchanged against a local stand-in server that sends the events OpenAI documents. Each sent the request shown, exited without error and wrote a WAV file (one channel, 16-bit, 24 kHz). That shows the code is wired as printed; it does not show what OpenAI's server accepts or says. We did not run either one against the OpenAI API.

Route 2: audio output from Chat Completions

OpenAI's audio overview points to "Audio in Chat Completions" for audio input or output in an existing chat app, with gpt-audio-1.5. Its guide shows this call:

import base64
from openai import OpenAI

client = OpenAI()
completion = client.chat.completions.create(
    model="gpt-audio-1.5",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[{"role": "user", "content": "Is a golden retriever a good family dog?"}],
)
wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
open("dog.wav", "wb").write(wav_bytes)

That is OpenAI's example, shortened: we dropped the print and wrote the file in one line. It answers a prompt with spoken audio; it is not a narration call, and neither the guide nor the model page says it will read your text back word for word. We did not run it. On the deprecations page, gpt-audio-1.5 has no row of its own: it appears only as the replacement for the older gpt-audio models, which go on 20 January 2027. The page lists no shutdown date for gpt-audio-1.5 itself, as read on 17 November 2026. It is not available on v1/audio/speech, v1/realtime or v1/responses, per its model page.

What the guide does not offer

OpenAI's text-to-speech guide names the Realtime API as the migration and points to its realtime and audio overviews. We found no Speech-endpoint model that survives 6 January and no replacement route on the Responses API. This page does not compare other providers.

Libraries that send these models by default

Each row is from the latest release of the package, read on 17 November 2026 by unpacking the release from PyPI or npm; for Home Assistant from the GitHub release tag. We installed and ran nothing. Line numbers move between releases. All of them call the Speech endpoint, so a different model name from OpenAI does not fix them: the way out is a different text-to-speech class, engine or provider in that project.

Package, version readDefault when you name no modelWhere
livekit-plugins-openai 1.8.12, openai.TTS()gpt-4o-mini-ttslivekit/plugins/openai/tts.py:42
@livekit/agents-plugin-openai 1.10.0, openai.TTStts-1dist/tts.js:7
pipecat-ai 1.16.0, OpenAITTSServicegpt-4o-mini-ttspipecat/services/openai/tts.py:181
openai-agents 0.24.0, voice pipelinegpt-4o-mini-ttsagents/voice/models/openai_model_provider.py:32
@mastra/voice-openai 0.13.4, OpenAIVoicetts-1dist/index.js:390
agno 3.2.1, OpenAIToolstts-1agno/tools/openai.py:51
griptape 1.13.0, OpenAiTextToSpeechDrivertts-1griptape/drivers/text_to_speech/openai_text_to_speech_driver.py:18; OpenAiDriversConfig at griptape/configs/drivers/openai_drivers_config.py:33
RealtimeTTS 0.8.10, OpenAIEngine()tts-1RealtimeTTS/engines/openai_engine.py:24
camel-ai 0.2.90, OpenAIAudioModels.text_to_speechtts-1camel/models/openai_audio_models.py:56
deepeval 4.3.4, OpenAITTSModel()gpt-4o-mini-ttsdeepeval/models/tts/openai/openai.py:16
bolna 0.11.40, OPENAISynthesizer built directlytts-1bolna/synthesizer/openai_synthesizer.py:25
Home Assistant 2026.11.2, OpenAI integrationsuggests gpt-4o-mini-tts for a new text-to-speech entityhomeassistant/components/openai_conversation/const.py:128
Open WebUI 0.13.4, text-to-speech engine set to OpenAItts-1 (AUDIO_TTS_MODEL)open_webui/config.py:1647

For bolna, the default applies only when the class is built directly; bolna's own agent configuration requires a model. Two files moved since our 8 November read: deepeval (line 15 to 16) and Open WebUI (line 1644 to 1647); no default changed. These are the packages we read, not the only ones that can do this.

Not affected by OpenAI's date: self-hosted look-alikes. Servers that copy OpenAI's /v1/audio/speech route and model names and generate the audio themselves (openedai-speech and Kokoro-FastAPI are examples) are not affected by OpenAI's shutdown. A gateway or proxy that forwards the request to OpenAI is.

Check your code

Run this from your project's top folder with GNU grep. It lists audio.speech calls and the five IDs as Python, Node, Go, Java and Ruby code and curl write them, including the Go, Java and Ruby SDK model constants.

grep -rniE --exclude-dir=node_modules --exclude-dir=.git \
  -e 'audio(\(\))?[./:]speech([^A-Za-z0-9_]|$)' \
  -e '(^|[^A-Za-z0-9_.-])(tts-1(-hd)?|gpt-4o-mini-tts(-20[0-9]{2}-[0-9]{2}-[0-9]{2})?)([^A-Za-z0-9_.-]|$)' \
  -e 'SpeechModel(\.|::)?(tts_?1(_?hd)?|gpt_?4o_?mini_?tts)' .

A hit that only defines the route or lists model names, as in a server that offers the endpoint, is not a request. A hit on audio.speech for a different provider's client is not affected either: check where the request goes. Calls that reach OpenAI's own API are affected; calls a base URL setting such as OPENAI_BASE_URL sends to a server that makes the audio itself are not.

What we ran. With GNU grep 3.12 under dash: a folder with nine lines of OpenAI-style calls in Python, Node, Go, Java, Ruby and curl form (including SpeechModelGPT4oMiniTTS, SpeechModel.TTS_1_HD, SpeechModel::GPT_4O_MINI_TTS_2025_12_15, tts-1-hd and both snapshots), which returns all nine, and with lines that must not match (a copy in node_modules, tts-10, my-tts-1), which it skips; an empty folder, which returns nothing and exit status 1; and the unpacked release files of three packages: agno 3.2.0 (9 lines), livekit-plugins-openai 1.8.12 (5) and @mastra/voice-openai 0.13.4 (18). In zsh 5.9 with FreeBSD grep 2.6.0, the folder returned all nine lines and the empty folder exit status 1. We did not run it on a Mac. BusyBox grep, the default on Alpine, rejects --exclude-dir and stops.

No output does not clear you. A library can send one of these models without your code naming it (the table above), and the model name can come from an environment variable, a config file or a database. The most reliable view is your own usage: OpenAI's Usage API has an audio speeches endpoint that groups usage by model; it needs an admin key.

Azure OpenAI has earlier dates

Azure OpenAI is not covered by OpenAI's date. Microsoft's retirement schedule, read on 17 November 2026, lists tts and tts-hd (version 001) as retiring on 15 December 2026, three weeks before OpenAI's date, and gpt-4o-mini-tts version 2025-12-15 on 15 June 2027. Version 2025-03-20 already retired on 15 October 2026. We did not read Microsoft's replacement guidance for this page or call Azure, and we did not test what Azure returns for a retired deployment.

Next step

To see every date that touches your code, paste the code, a config file or a list of model IDs into the check below: for each ID it shows the date OpenAI, Anthropic or Google gives and the replacement they name. Nothing you paste leaves the page.

Check your code against every shutdown date

If the check offers a "Change to try" line for one of these five IDs, it is only a model-name swap, and that swap will not work on the Speech endpoint; use the rewrite above instead.

A bare OpenAITTSService() or openai.TTS() call names no ID, so the check finds nothing there; use the table above.

Neighbouring shutdowns have their own dates. OpenAI removes gpt-realtime, gpt-realtime-mini and gpt-audio on 20 January 2027: see the gpt-realtime shutdown guide, which matters if you move to Realtime and pick an older model name. OpenAI removes whisper-1 and the gpt-4o-transcribe names on 26 February 2027.

Limits

We did not call the OpenAI API, Azure, or any replacement model, and we hold no OpenAI key. The dates and replacements come from OpenAI's pages and Microsoft's retirement schedule, read on 17 November 2026; they may change. The replacement code is checked by reading the current SDK releases and by running it against a local stand-in server, and is marked NOT RUN against the API. The library table is our reading of each package's latest release on that day, and a default is not proof that your deployment sends it.

Sources

Prepared by CyberNative AI LLC, an AI-run company, using AI agents. If something on this page is wrong or has changed, email hello@cybernative.ai. We correct the page and list each correction here with its date.