Custom voices

Custom 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, the Realtime API, or the Chat Completions API with audio output.

To create a custom voice, you’ll provide a short sample audio reference that the model will seek to replicate.

Creating a voice

Currently, voices must be created through an API request. See the API reference for the full set of API operations.

Creating a voice requires two separate audio recordings:

1. 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.
2. Sample recording: The actual audio sample that the model will try to adhere to. The voice must match the consent recording.

Tips for creating a high-quality voice

The 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.

• Record in a quiet space with minimal echo.
• Use a professional XLR microphone.
• Stay about 7–8 inches from the mic with a pop filter in between, and keep that distance consistent.
• 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.
• Small variations in the audio sample can result in quality differences with the generated voice. Try multiple examples to find the best fit.

Requirements and limitations

• At most 20 voices can be created per organization.
• The audio samples must be 30 seconds or less.
• The audio samples must be one of the following types: mpeg, wav, ogg, aac, flac, webm, or mp4.

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

Creating a voice consent

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

Then 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.

1
2
3
4
5
6curl https://api.openai.com/v1/audio/voice_consents \
  -X POST \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F "name=test_consent" \
  -F "language=en" \
  -F "recording=@$HOME/tmp/voice_consent/consent_recording.wav;type=audio/x-wav"

Creating a voice

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

1
2
3
4
5
6curl https://api.openai.com/v1/audio/voices \
  -X POST \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F "name=test_voice" \
  -F "audio_sample=@$HOME/tmp/voice_consent/audio_sample_recording.wav;type=audio/x-wav" \
  -F "consent=cons_123abc"

If successful, the created voice will be listed under the Audio tab.

Using a voice during speech generation

Speech generation will work as usual. Specify the ID of the voice in the voice parameter when creating speech, or when initiating a realtime session.

Text to speech example

1
2
3
4
5
6
7
8
9
10
11
12
13
14curl https://api.openai.com/v1/audio/speech \
  -X POST \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini-tts",
    "voice": {
      "id": "voice_123abc"
    },
    "input": "Maple est le meilleur golden retriever du monde entier.",
    "language": "fr",
    "format": "wav"
  }' \
  --output sample.wav

Realtime API example

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

1
2
3
4
5
6
7
8
9
10
11const sessionConfig = JSON.stringify({
  session: {
    type: "realtime",
    model: "gpt-realtime-2",
    audio: {
      output: {
        voice: { id: "voice_123abc" },
      },
    },
  },
});

1
2
3
4
5
6
7
8
9
10require "json"

session_config = JSON.generate(
  session: {
    type: "realtime",
    model: "gpt-realtime-2",
    audio: {output: {voice: {id: ENV.fetch("OPENAI_VOICE_ID")}}}
  }
)
puts(session_config)

Use a custom voice with GPT-Live

Use a project-scoped API key approved for both GPT-Live and custom voice creation. Reading consent phrases and using a custom voice require api.voices.read; creating consents and voices requires api.voices.write and custom-voice API access. Use the same project for every request and keep the API key on a trusted server.

Prepare the recordings

List the current supported consent phrases before recording:

curl https://api.openai.com/v1/audio/consent_phrases \
  -H "Authorization: Bearer $OPENAI_API_KEY"

The consent recording and reference sample must come from the same person. The sample needs at least five seconds of actual speech and at least 15 transcribed text tokens; silence does not count. Use a 10–30-second recording with several complete sentences. Each upload is limited to 10 MiB. The service extracts the reference transcript; do not upload transcript tokens, configure a decoder, or add custom request headers.

Browser recorders may label audio audio/webm;codecs=opus, which the upload endpoint rejects. When constructing an upload, use the supported base MIME type audio/webm while preserving the original audio bytes. Use the consent and voice creation requests above, then save the returned voice ID.

Select the voice at session creation

Pass a custom voice as the object { "id": "voice_123" }, not the string "voice_123". Named voices such as "marin" use strings.

gpt-live-1 supports custom voices with English accents. To use an accent, also specify it in session.instructions, such as “Speak British English” or “Speak Irish English.” The example below uses British English; change the instruction to match the accent you want for your custom voice.

Include the following configuration in the initial session:

12345{
  "model": "gpt-live-1",
  "instructions": "You are a helpful voice assistant. Speak British English.",
  "audio": { "output": { "voice": { "id": "voice_123" } } }
}

For WebRTC, the trusted session broker places this configuration in the JSON session field alongside transport. The Live endpoint requires JSON, not multipart or raw SDP. Read the created session ID from session.id and the SDP answer from transport.sdp. Authenticate hosted broker requests with application credentials; never expose the OpenAI API key to the browser.

For WebSockets, put the configuration in the first session.start event. Connect without query parameters and wait for session.started before streaming audio. Send audio with session.input_audio.append. After sending session.close, keep receiving until session.closed supplies final usage.

Handle access and lifecycle failures

• The output voice cannot be changed after the Live session starts. Start a new session to use a different voice.
• A deleted or revoked voice, a consent from another project, or missing custom-voice access can appear as a 404.
• Malformed audio, a mismatched speaker, or a non-project-scoped key is rejected.

Confirm your project’s permissions, recording minimums, and upload limits before creating a voice. See GPT-Live getting started for session setup requirements.