OpenAI Prompt-to-Voice API: Make a Voice, Use It in GPT-Live

The OpenAI prompt-to-voice API lets you create a custom voice from a plain text description and then use that voice in GPT-Live voice sessions. OpenAI released it to all API customers on October 16, 2026, according to the OpenAI API changelog. You create the voice either through the API, using the v1/audio/voices endpoint, or in the voice Playground, and then reference it from a GPT-Live session created through v1/live/sessions.

The cost model is the part most people are really asking about. Creating a prompt-generated voice is free. You pay only when the voice speaks, and that is billed as ordinary GPT-Live session time, which the OpenAI pricing page lists at $0.05 per minute, billed per second, as of October 16, 2026. Backend model and tool usage during the session is charged separately.

How prompt-to-voice fits into GPT-Live#

GPT-Live 1 (gpt-live-1) became generally available in the API on September 10, 2026. It runs full-duplex voice conversations that can keep going while a backend model or agent handles reasoning and tools. You can hand that reasoning to an OpenAI model with Responses delegation, or connect your own backend with client delegation. On October 15, 2026 OpenAI added native Decisions integration, so a Live session can call the Decisions API directly or trigger decisions as transcript deltas arrive.

Prompt-to-voice adds a new kind of asset to that picture: a voice you define in words rather than pick from a list. Before October 16 you chose one of the built-in GPT-Live voices. Now you can describe the speaker you want, create it once, and reuse it across as many sessions as you like.

Two details from the changelog entry are worth keeping in mind. First, the feature is tagged against gpt-live-1 and the two endpoints v1/audio/voices and v1/live/sessions. The entry does not mention gpt-realtime-2, gpt-realtime-2.1 or gpt-4o-mini-tts, so don't assume a prompt-generated voice carries over to those models. Second, the release is for all API customers, with no waitlist or tier restriction stated.

Creating a custom voice from a text description#

There are two ways to create a voice, and I'd use both in sequence.

Start in the voice Playground. Writing a good voice description is an iterative job. You'll want to hear a draft, adjust a word or two, and hear it again. The Playground is the fastest loop for that.

Then move to the API. Once you're happy with the wording, create the same voice through the v1/audio/voices endpoint so the voice lives in your project and your deployment pipeline, not in someone's browser tab. The changelog names the endpoint but doesn't spell out the request body, so check the entry for audio voices in the OpenAI API reference for the exact fields before you write the call. If you're new to calling OpenAI endpoints from code, the setup walkthrough in how to use the OpenAI API in Python covers keys, the SDK and error handling.

Whatever you put in the description, keep it concrete and non-contradictory. A description is a prompt, and the same rules apply as for any prompt: state who is speaking, how they sound, how fast they talk, and what to avoid. Here's a small helper that assembles a description from structured attributes so the wording can be versioned and reviewed alongside the rest of your config:

// Build a voice description from structured attributes, so the same
// wording can be reused across environments and reviewed in code.
const spec = {
  persona: "a calm, experienced support engineer",
  age: "mid-30s",
  accent: "neutral US English",
  pace: "slightly slower than average, with short pauses between steps",
  tone: "warm but matter-of-fact, never salesy",
  avoid: ["upspeak", "vocal fry", "exaggerated enthusiasm"],
};

function describeVoice(s) {
  return [
    `Voice of ${s.persona}, ${s.age}, speaking ${s.accent}.`,
    `Pace: ${s.pace}.`,
    `Tone: ${s.tone}.`,
    `Avoid: ${s.avoid.join(", ")}.`,
  ].join(" ");
}

const description = describeVoice(spec);
console.log(description);
console.log(`\n${description.split(/\s+/).length} words, ${description.length} characters`);

The attributes I'd always include are persona, approximate age, accent or language, pace, and tone. The "avoid" list is optional but useful, because it's often easier to say what you don't want than to describe the positive quality precisely.

Reusing the voice in GPT-Live sessions#

The whole point of creating a voice as an asset is that you create it once and reference it many times. A session is created through v1/live/sessions, and that's where you pick which voice speaks. The flow looks like this:

1. Create the voice (Playground or v1/audio/voices). This step is free.
2. Store the resulting voice identifier in your configuration, the same way you'd store a model ID.
3. When your app opens a GPT-Live session through v1/live/sessions, select that voice.
4. Choose how reasoning happens: Responses delegation to an OpenAI model, or client delegation to your own backend.
5. Session time starts billing when the session runs, at the GPT-Live per-minute rate, per second.

Treat the voice identifier like any other environment-specific setting. Create one voice per environment if you need to, but don't create a fresh voice on every session start. It isn't a cost problem, since creation is free, but it defeats consistency, which is the reason to have a custom voice in the first place.

If you also run voice or multimodal features on other providers, the request patterns are close enough that the structure in Gemini API Python: install, chat and stream will feel familiar, even though the endpoints differ.

What the prompt-to-voice API costs#

As of October 16, 2026, the pricing is simple to reason about:

The per-second billing matters more than it looks. A 45-second session costs 45/60 of the per-minute rate, not a full minute. Here's a quick calculator you can adapt to your own traffic estimates:

# GPT-Live session cost: $0.05 per minute, billed per second (no rounding up).
RATE_PER_MINUTE = 0.05

def session_cost(seconds: int) -> float:
    return seconds / 60 * RATE_PER_MINUTE

sessions = {
    "45-second IVR hop": 45,
    "3-minute support call": 180,
    "12-minute onboarding": 720,
}

total = 0.0
for name, secs in sessions.items():
    cost = session_cost(secs)
    total += cost
    print(f"{name:24s} {secs:5d}s  ${cost:.4f}")

print(f"{'voice creation':24s} {'':6s} $0.0000  (free to create)")
print(f"{'session total':24s} {'':6s} ${total:.4f}")
print("Backend model and tool usage during the session is billed separately.")

Two things the calculator does not include. If you use Responses delegation, the backend model's input and output tokens are billed at that model's rates. The pricing page lists gpt-6-luna at $0.10 input and $0.50 output per 1M tokens, gpt-6.1-sol at $2.00 input and $10.00 output, and gpt-6-astra at $10.00 input and $50.00 output, all for short context at the standard tier. Any built-in tools the backend calls are billed at their own rates too.

Also note the usage tier change from October 6, 2026. OpenAI simplified API usage tiers to three: Build, Launch and Grow. Your organization moves up automatically as total credit purchases reach each tier's minimum, and rate limits per model are listed in your dashboard. Prompt-to-voice itself isn't gated by tier in the changelog, but your session volume is still subject to your tier's limits.

Prompt-to-voice or a built-in GPT-Live voice#

The same October 16, 2026 release added nine natural voices to GPT-Live, so you have a real choice between describing a voice and picking one:

My rule of thumb: start with a built-in voice if one of them is already close to what you need, especially for one of those languages. Built-in voices are tuned, predictable and need zero prompt engineering. Reach for prompt-to-voice when the brand or product voice has to be specific, when you need the same character across languages or markets, or when none of the built-in options matches the persona you've written for the agent. Both routes cost the same once the voice is speaking, since session billing doesn't change based on which voice you use.

The OpenAI models page lists GPT-Live 1 under realtime models, alongside the GPT-Realtime family and the GPT-4o Mini TTS speech model. That page is the place to check which models currently exist if you're deciding where a custom voice fits.

Common mistakes and gotchas#

Mixing up the Realtime API and GPT-Live. The Realtime API Beta was deprecated and removed on May 12, 2026, and the released Realtime API is a separate product with its own models and token-based pricing. Prompt-to-voice is tied to gpt-live-1 and v1/live/sessions. If your code still targets a v1/realtime endpoint, you're in the wrong place for this feature.

Assuming the voice works with the TTS endpoint. The changelog ties prompt-generated voices to GPT-Live sessions. It doesn't say they can be used with gpt-4o-mini-tts or the GPT-Realtime models. Until the official docs say otherwise, plan on GPT-Live only.

Budgeting for creation instead of usage. Creation is free, so it's tempting to think the feature is free. The real cost is session minutes plus whatever backend model and tools run behind the session. Model your costs on expected session length and backend token volume, not on how many voices you make.

Forgetting the delegation charges. With Responses delegation, every turn the backend model processes bills its own tokens. A long session with a large system prompt on gpt-6-astra can cost more in tokens than in session time. If cost matters, test the same conversation with gpt-6-luna as the backend before settling.

Writing contradictory descriptions. "Energetic but calm" or "young voice with decades of experience" gives the model nothing to lock onto. Pick one dominant quality per dimension and add detail around it.

Recreating the voice on every deploy or session. Create it once, store the identifier, and reuse it. Consistency is the feature.

Regional endpoints cost more. The pricing page states that regional processing (data residency) endpoints are charged a 10% uplift for models released on or after March 5, 2026 that are eligible for data residency. If you route sessions through a regional endpoint, check whether that uplift applies to your setup.

Rate limit errors look different now. Since September 2, 2026, traffic that ramps too fast returns a 429 with the slow_down code, and temporary overload returns a 503 with server_is_overloaded. Both can include a Retry-After header. Honor the header when present and fall back to exponential backoff when it isn't. This matters for voice apps because a burst of session starts after a product launch is exactly the pattern that triggers slow_down.

Quick reference#

• Feature: prompt-to-voice, released October 16, 2026, for all API customers.
• Create a voice: voice Playground, or the v1/audio/voices endpoint.
• Use a voice: GPT-Live sessions through v1/live/sessions with gpt-live-1.
• Creation cost: free.
• Speech cost: $0.05 per minute of GPT-Live session, billed per second, as of October 16, 2026.
• Separate charges: backend model tokens under Responses delegation, and any tools the session calls.
• Built-in alternatives: nine new voices for German, French, Hindi, Japanese and Korean, added the same day.
• Not covered by the docs yet: use with GPT-Realtime or GPT-4o Mini TTS, and any limit on how many voices you can create. The changelog and pricing page don't list either, so check them before you depend on it.
• Before shipping: store the voice identifier in config, test session length against your budget, pick the cheapest backend model that passes your evals, and handle slow_down and server_is_overloaded with backoff.

Quick answers