Text to speech

For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.

The Audio API provides a speech endpoint based on our GPT-4o mini TTS (text-to-speech) model. It comes with 11 built-in voices and can be used to:

Narrate a written blog post
Produce spoken audio in multiple languages
Give realtime audio output using streaming

Here's an example of the alloy voice:

Our usage policies require you to provide a clear disclosure to end users that the TTS voice they are hearing is AI-generated and not a human voice.

Quickstart

The speech endpoint takes three key inputs:

The model you're using
The text to be turned into audio
The voice that will speak the output

Here's a simple request example:

Generate spoken audio from input text

import fs from "fs";
import path from "path";
import OpenAI from "openai";

const openai = new OpenAI();
const speechFile = path.resolve("./speech.mp3");

const mp3 = await openai.audio.speech.create({
  model: "gpt-4o-mini-tts",
  voice: "coral",
  input: "Today is a wonderful day to build something people love!",
  instructions: "Speak in a cheerful and positive tone.",
});

const buffer = Buffer.from(await mp3.arrayBuffer());
await fs.promises.writeFile(speechFile, buffer);

from pathlib import Path
from openai import OpenAI

client = OpenAI()
speech_file_path = Path(__file__).parent / "speech.mp3"

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input="Today is a wonderful day to build something people love!",
    instructions="Speak in a cheerful and positive tone.",
) as response:
    response.stream_to_file(speech_file_path)

package main

import (
	"context"
	"io"
	"os"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	response, err := client.Audio.Speech.New(context.Background(), openai.AudioSpeechNewParams{
		Model:        openai.SpeechModelGPT4oMiniTTS,
		Voice:        openai.AudioSpeechNewParamsVoiceUnion{OfAudioSpeechNewsVoiceString2: openai.String("coral")},
		Input:        "Today is a wonderful day to build something people love!",
		Instructions: openai.String("Speak in a cheerful and positive tone."),
	})
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	file, err := os.Create("speech.mp3")
	if err != nil {
		panic(err)
	}
	if _, err := io.Copy(file, response.Body); err != nil {
		panic(err)
	}
	if err := file.Close(); err != nil {
		panic(err)
	}
}

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpResponse;
import com.openai.models.audio.speech.SpeechCreateParams;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

try (HttpResponse audio =
    client
        .audio()
        .speech()
        .create(
            SpeechCreateParams.builder()
                .model("gpt-4o-mini-tts")
                .voice("coral")
                .input("Today is a wonderful day to build something people love!")
                .instructions("Speak in a cheerful and positive tone.")
                .build())) {
  Files.copy(audio.body(), Path.of("speech.mp3"), StandardCopyOption.REPLACE_EXISTING);
}

using OpenAI.Audio;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-4o-mini-tts";
AudioClient client = new(model, key);

BinaryData audio = await client.GenerateSpeechAsync(
    "Today is a wonderful day to build something people love!",
    GeneratedSpeechVoice.Coral,
    new SpeechGenerationOptions
    {
        Instructions = "Speak in a cheerful and positive tone.",
    }
);

await File.WriteAllBytesAsync("speech.mp3", audio.ToArray());

require "openai"

client = OpenAI::Client.new
audio = client.audio.speech.create(
  model: "gpt-4o-mini-tts",
  voice: "coral",
  input: "Today is a wonderful day to build something people love!",
  instructions: "Speak in a cheerful and positive tone."
)
File.binwrite("speech.mp3", audio.read)

curl https://api.openai.com/v1/audio/speech \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini-tts",
    "input": "Today is a wonderful day to build something people love!",
    "voice": "coral",
    "instructions": "Speak in a cheerful and positive tone."
  }' \
  --output speech.mp3

openai audio:speech create \
  --model gpt-4o-mini-tts \
  --voice coral \
  --instructions "Speak in a cheerful and positive tone." \
  --input "Today is a wonderful day to build something people love!" \
  --output speech.mp3

By default, the endpoint outputs an MP3 of the spoken audio, but you can configure it to output any supported format.

Text-to-speech models

For intelligent realtime applications, use the gpt-4o-mini-tts model, our newest and most reliable text-to-speech model. You can prompt the model to control aspects of speech, including:

Accent
Emotional range
Intonation
Impressions
Speed of speech
Tone
Whispering

Our other text-to-speech models are tts-1 and tts-1-hd. The tts-1 model provides lower latency, but at a lower quality than the tts-1-hd model.

Voice options

The TTS endpoint provides 13 built‑in voices to control how speech is rendered from text. Hear and play with these voices in OpenAI.fm, our interactive demo for trying the latest text-to-speech model in the OpenAI API. Voices are currently optimized for English.

alloy
ash
ballad
coral
echo
fable
nova
onyx
sage
shimmer
verse
marin
cedar

For best quality, we recommend using marin or cedar.

Voice availability depends on the model. The tts-1 and tts-1-hd models support a smaller set: alloy, ash, coral, echo, fable, onyx, nova, sage, and shimmer.

If you're using the Realtime API, note that the set of available voices is slightly different—see the realtime conversations guide for current realtime voices.

Streaming realtime audio

The Speech API provides support for realtime audio streaming using chunk transfer encoding. This means the audio can be played before the full file is generated and made accessible.

Stream spoken audio from input text directly to your speakers

import OpenAI from "openai";
import { playAudio } from "openai/helpers/audio";

const openai = new OpenAI();

const response = await openai.audio.speech.create({
  model: "gpt-4o-mini-tts",
  voice: "coral",
  input: "Today is a wonderful day to build something people love!",
  instructions: "Speak in a cheerful and positive tone.",
  response_format: "wav",
});

await playAudio(response);

import asyncio

from openai import AsyncOpenAI
from openai.helpers import LocalAudioPlayer

openai = AsyncOpenAI()


async def main() -> None:
    async with openai.audio.speech.with_streaming_response.create(
        model="gpt-4o-mini-tts",
        voice="coral",
        input="Today is a wonderful day to build something people love!",
        instructions="Speak in a cheerful and positive tone.",
        response_format="pcm",
    ) as response:
        await LocalAudioPlayer().play(response)


if __name__ == "__main__":
    asyncio.run(main())

package main

import (
	"context"
	"io"
	"os"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	response, err := client.Audio.Speech.New(context.Background(), openai.AudioSpeechNewParams{
		Model:          openai.SpeechModelGPT4oMiniTTS,
		Voice:          openai.AudioSpeechNewParamsVoiceUnion{OfAudioSpeechNewsVoiceString2: openai.String("coral")},
		Input:          "Today is a wonderful day to build something people love!",
		Instructions:   openai.String("Speak in a cheerful and positive tone."),
		ResponseFormat: openai.AudioSpeechNewParamsResponseFormatWAV,
	})
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()
	if _, err := io.Copy(os.Stdout, response.Body); err != nil {
		panic(err)
	}
}

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpResponse;
import com.openai.models.audio.speech.SpeechCreateParams;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;

try (HttpResponse audio =
    client
        .audio()
        .speech()
        .create(
            SpeechCreateParams.builder()
                .model("gpt-4o-mini-tts")
                .voice("coral")
                .input("Today is a wonderful day to build something people love!")
                .instructions("Speak in a cheerful and positive tone.")
                .responseFormat(SpeechCreateParams.ResponseFormat.PCM)
                .streamFormat(SpeechCreateParams.StreamFormat.AUDIO)
                .build())) {
  AudioFormat format = new AudioFormat(24_000, 16, 1, true, false);
  String outputPath = System.getenv("OPENAI_EXAMPLE_AUDIO_OUTPUT_PATH");
  if (outputPath == null || outputPath.isBlank()) {
    try (SourceDataLine speakers = AudioSystem.getSourceDataLine(format)) {
      speakers.open(format);
      speakers.start();
      byte[] chunk = new byte[1024];
      int bytesRead;
      while ((bytesRead = audio.body().read(chunk)) != -1) {
        speakers.write(chunk, 0, bytesRead);
      }
      speakers.drain();
    }
  } else {
    try (OutputStream output = Files.newOutputStream(Path.of(outputPath))) {
      long bytes = audio.body().transferTo(output);
      System.out.println(bytes + " audio bytes");
    }
  }
}

require "openai"

client = OpenAI::Client.new
audio = client.audio.speech.create(
  model: "gpt-4o-mini-tts",
  voice: "alloy",
  input: "Welcome to the OpenAI API.",
  response_format: :pcm,
  stream_format: :audio
)
while (chunk = audio.read(1_024))
  puts(chunk.bytesize)
end

curl https://api.openai.com/v1/audio/speech \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini-tts",
    "input": "Today is a wonderful day to build something people love!",
    "voice": "coral",
    "instructions": "Speak in a cheerful and positive tone.",
    "response_format": "wav"
  }' | ffplay -i -

For the fastest response times, we recommend using wav or pcm as the response format.

Supported output formats

The default response format is mp3, but other formats like opus and wav are available.

MP3: The default response format for general use cases.
Opus: For internet streaming and communication, low latency.
AAC: For digital audio compression, preferred by YouTube, Android, iOS.
FLAC: For lossless audio compression, favored by audio enthusiasts for archiving.
WAV: Uncompressed WAV audio, suitable for low-latency applications to avoid decoding overhead.
PCM: Similar to WAV but contains the raw samples in 24kHz (16-bit signed, low-endian), without the header.

Supported languages

The TTS model generally follows the Whisper model in terms of language support. Whisper supports the following languages and performs well, despite voices being optimized for English:

Afrikaans, Arabic, Armenian, Azerbaijani, Belarusian, Bosnian, Bulgarian, Catalan, Chinese, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, Galician, German, Greek, Hebrew, Hindi, Hungarian, Icelandic, Indonesian, Italian, Japanese, Kannada, Kazakh, Korean, Latvian, Lithuanian, Macedonian, Malay, Marathi, Maori, Nepali, Norwegian, Persian, Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swahili, Swedish, Tagalog, Tamil, Thai, Turkish, Ukrainian, Urdu, Vietnamese, and Welsh.

You can generate spoken audio in these languages by providing input text in the language of your choice.

Custom voices

Create an approved custom voice from a speaker's consent recording and matching audio sample. See Custom voices for eligibility, recording requirements, consent phrases, and API requests.

Creating a voice

Follow Create a custom voice.

Using a voice during speech generation

Pass the created voice ID when generating speech. See the speech generation examples.

[Realtime and audio overview

  Choose the right path for voice agents, translation, transcription, and
speech generation.](https://developers.openai.com/api/docs/guides/realtime)

[Audio and speech concepts

  Review audio modalities, speech tasks, streaming, and request-based APIs.](https://developers.openai.com/api/docs/guides/audio)

guides/text-to-speech.md +6 −136

398 398

399## Custom voices399## Custom voices

400 400

401Custom voices enable you to create a unique voice for your agent or application. These voices can be used for audio output with the [Text to Speech API](https://developers.openai.com/api/reference/resources/audio/subresources/speech/methods/create), the [Realtime API](https://developers.openai.com/api/reference/resources/realtime), or the [Chat Completions API with audio output](https://developers.openai.com/api/docs/guides/audio).401Create an approved custom voice from a speaker's consent recording and matching

~~402~~ 402audio sample. See [Custom voices](https://developers.openai.com/api/docs/guides/custom-voices) for eligibility,

403To create a custom voice, you’ll provide a short sample audio reference that the model will seek to replicate.403recording requirements, consent phrases, and API requests.

~~404~~

405Custom voices are limited to eligible customers. Contact our [sales

406 team](https://openai.com/contact-sales/) to learn more. Once enabled for your

407 organization, you’ll have access to the

408 [Voices](https://platform.openai.com/audio/voices) tab under Audio.

409 404

410#### Creating a voice405#### Creating a voice

411 406

412Currently, voices must be created through an API request. See the API reference for the full set of API operations.407Follow [Create a custom voice](https://developers.openai.com/api/docs/guides/custom-voices#creating-a-voice).

~~413~~

414Creating a voice requires two separate audio recordings:

~~415~~

4161. **Consent recording** — this recording captures the voice actor providing consent to create a likeness of their voice. The actor must read one of the consent phrases provided below.

4172. **Sample recording** — the actual audio sample that the model will try to adhere to. The voice must match the consent recording.

~~418~~

419**Tips for creating a high-quality voice**

~~420~~

421The quality of your custom voice is highly dependent on the quality of the sample you provide. Optimizing the recording quality can make a big difference.

~~422~~

423- Record in a quiet space with minimal echo.

424- Use a professional XLR microphone.

425- Stay about 7–8 inches from the mic with a pop filter in between, and keep that distance consistent.

426- The model copies exactly what you give it—tone, cadence, energy, pauses, habits—so record the exact voice you want. Be consistent in energy, style, and accent throughout.

427- Small variations in the audio sample can result in quality differences with the generated voice, it's worth trying multiple examples to find the best fit.

~~428~~

429**Requirements and limitations**

~~430~~

431- At most 20 voices can be created per organization.

432- The audio samples must be 30 seconds or less.

433- The audio samples must be one of the following types: `mpeg`, `wav`, `ogg`, `aac`, `flac`, `webm`, or `mp4`.

~~434~~

435Refer to the Text-to-Speech Supplemental Agreement for additional terms of use.

~~436~~

437**Creating a voice consent**

~~438~~

439The consent audio recording must only include one of the following phrases. Any divergence from the script will lead to a failure.

~~440~~

441| Language | Phrase |

442| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |

443| `de` | Ich bin der Eigentümer dieser Stimme und bin damit einverstanden, dass OpenAI diese Stimme zur Erstellung eines synthetischen Stimmmodells verwendet. |

444| `en` | I am the owner of this voice and I consent to OpenAI using this voice to create a synthetic voice model. |

445| `es` | Soy el propietario de esta voz y doy mi consentimiento para que OpenAI la utilice para crear un modelo de voz sintética. |

446| `fr` | Je suis le propriétaire de cette voix et j'autorise OpenAI à utiliser cette voix pour créer un modèle de voix synthétique. |

447| `hi` | मैं इस आवाज का मालिक हूं और मैं सिंथेटिक आवाज मॉडल बनाने के लिए OpenAI को इस आवाज का उपयोग करने की सहमति देता हूं |

448| `id` | Saya adalah pemilik suara ini dan saya memberikan persetujuan kepada OpenAI untuk menggunakan suara ini guna membuat model suara sintetis. |

449| `it` | Sono il proprietario di questa voce e acconsento che OpenAI la utilizzi per creare un modello di voce sintetica. |

450| `ja` | 私はこの音声の所有者であり、OpenAIがこの音声を使用して音声合成モデルを作成することを承認します。 |

451| `ko` | 나는 이 음성의 소유자이며 OpenAI가 이 음성을 사용하여 음성 합성 모델을 생성할 것을 허용합니다. |

452| `nl` | Ik ben de eigenaar van deze stem en ik geef OpenAI toestemming om deze stem te gebruiken om een synthetisch stemmodel te maken. |

453| `pl` | Jestem właścicielem tego głosu i wyrażam zgodę na wykorzystanie go przez OpenAI w celu utworzenia syntetycznego modelu głosu. |

454| `pt` | Eu sou o proprietário desta voz e autorizo o OpenAI a usá-la para criar um modelo de voz sintética. |

455| `ru` | Я являюсь владельцем этого голоса и даю согласие OpenAI на использование этого голоса для создания модели синтетического голоса. |

456| `uk` | Я є власником цього голосу і даю згоду OpenAI використовувати цей голос для створення синтетичної голосової моделі. |

457| `vi` | Tôi là chủ sở hữu giọng nói này và tôi đồng ý cho OpenAI sử dụng giọng nói này để tạo mô hình giọng nói tổng hợp. |

458| `zh` | 我是此声音的拥有者并授权OpenAI使用此声音创建语音合成模型 |

~~459~~

460Then upload the recording via the API. A successful upload will return the consent recording ID that you’ll reference later. Note the consent can be used for multiple different voice creations if the same voice actor is making multiple attempts.

~~461~~

462```bash

463curl https://api.openai.com/v1/audio/voice_consents \

464 -X POST \

465 -H "Authorization: Bearer $OPENAI_API_KEY" \

466 -F "name=test_consent" \

467 -F "language=en" \

468 -F "recording=@$HOME/tmp/voice_consent/consent_recording.wav;type=audio/x-wav"

469```

~~470~~

~~471~~

472**Creating a voice**

~~473~~

474Next, you’ll create the actual voice by referencing the consent recording ID, and providing the voice sample.

~~475~~

476```bash

477curl https://api.openai.com/v1/audio/voices \

478 -X POST \

479 -H "Authorization: Bearer $OPENAI_API_KEY" \

480 -F "name=test_voice" \

481 -F "audio_sample=@$HOME/tmp/voice_consent/audio_sample_recording.wav;type=audio/x-wav" \

482 -F "consent=cons_123abc"

483```

~~484~~

~~485~~

486If successful, the created voice will be listed under the [Audio tab](https://platform.openai.com/audio/voices).

487 408

488#### Using a voice during speech generation409#### Using a voice during speech generation

489 410

490Speech generation will work as usual. Simply specify the ID of the voice in the `voice` parameter when [creating speech](https://developers.openai.com/api/reference/resources/audio/subresources/speech/methods/create), or when initiating a [realtime session](https://developers.openai.com/api/reference/resources/realtime/subresources/calls/methods/create#realtime_create_call-session-audio-output-voice).411Pass the created voice ID when generating speech. See the

~~491~~ 412[speech generation examples](https://developers.openai.com/api/docs/guides/custom-voices#using-a-voice-during-speech-generation).

492**Text to speech example**

~~493~~

494```bash

495curl https://api.openai.com/v1/audio/speech \

496 -X POST \

497 -H "Authorization: Bearer $OPENAI_API_KEY" \

498 -H "Content-Type: application/json" \

499 -d '{

500 "model": "gpt-4o-mini-tts",

501 "voice": {

502 "id": "voice_123abc"

503 },

504 "input": "Maple est le meilleur golden retriever du monde entier.",

505 "language": "fr",

506 "format": "wav"

507 }' \

508 --output sample.wav

509```

~~510~~

~~511~~

512**Realtime API example**

~~513~~

514For Ruby, set `OPENAI_VOICE_ID` to your custom voice ID before running the example.

~~515~~

516```javascript

517const sessionConfig = JSON.stringify({

518 session: {

519 type: "realtime",

520 model: "gpt-realtime-2",

521 audio: {

522 output: {

523 voice: { id: "voice_123abc" },

524 },

525 },

526 },

527});

528```

~~529~~

530```ruby

531require "json"

~~532~~

533session_config = JSON.generate(

534 session: {

535 type: "realtime",

536 model: "gpt-realtime-2",

537 audio: {output: {voice: {id: ENV.fetch("OPENAI_VOICE_ID")}}}

538 }

539)

540puts(session_config)

541```

~~542~~

543 413

544## Related guides414## Related guides

545 415

guides/text-to-speech.md 2026-09-09 23:59 UTC to 2026-09-10 18:01 UTC

Text to speech

Quickstart

Text-to-speech models

Voice options

Streaming realtime audio

Supported output formats

Supported languages

Custom voices

Creating a voice

Using a voice during speech generation

Related guides