Conversión de texto a voz

Los modelos tts-1, tts-1-hd y gpt-4o-mini-tts están en desuso y dejarán de funcionar el 6 de enero de 2027. Migra a gpt-realtime-2.1-mini mediante la Realtime API. Esto cambia la forma de usar la API, ya que gpt-realtime-2.1-mini no es compatible con /v1/audio/speech. Las integraciones existentes pueden seguir usando los flujos de trabajo de la API de voz que se muestran a continuación hasta que los modelos dejen de funcionar. Consulta el aviso de retiro.

La API de audio ofrece el punto de acceso speech, basado en nuestro modelo GPT-4o mini TTS de conversión de texto a voz. Incluye 11 voces integradas y te permite:

Narrar una entrada de blog
Generar voz en varios idiomas
Transmitir el audio generado en tiempo real

Escucha un ejemplo de la voz alloy:

Nuestras políticas de uso exigen que informes claramente a los usuarios finales que la voz que escuchan es una voz sintética generada por IA y no una voz humana.

Inicio rápido

El punto de acceso speech recibe tres parámetros principales:

El modelo que usas
El texto que quieres convertir en audio
La voz que leerá el texto

Ejemplo de solicitud:

Genera voz a partir del texto de entrada

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import 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);

1
2
3
4
5
6
7
8
9
10
11
12
13from 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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34package 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)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import 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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17using 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());

1
2
3
4
5
6
7
8
9
10require "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)

1
2
3
4
5
6
7
8
9
10curl 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

1
2
3
4
5
6openai 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

De forma predeterminada, el punto de acceso devuelve un archivo MP3 con la voz generada, pero puedes configurarlo para que devuelva el audio en cualquiera de los formatos compatibles.

Modelos de conversión de texto a voz

Si ya tienes una integración con la API de voz, gpt-4o-mini-tts te permite usar prompts para controlar los siguientes aspectos de la voz:

Acento
Gama de emociones
Entonación
Imitaciones de voces
Velocidad del habla
Tono
Susurros

Nuestros otros modelos de conversión de texto a voz son tts-1 y tts-1-hd. El modelo tts-1 ofrece menor latencia, pero la calidad del audio es inferior a la del modelo tts-1-hd.

Opciones de voz

El punto de acceso de conversión de texto a voz ofrece 13 voces integradas para que elijas cómo sonará el texto. Escucha estas voces y experimenta con ellas en OpenAI.fm, nuestra demo interactiva para probar el modelo de conversión de texto a voz más reciente de la API de OpenAI. Por ahora, las voces están optimizadas para el inglés.

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

Para obtener la mejor calidad, te recomendamos usar marin o cedar.

Las voces disponibles dependen del modelo. Los modelos tts-1 y tts-1-hd admiten menos voces: alloy, ash, coral, echo, fable, onyx, nova, sage y shimmer.

Si usas la Realtime API, ten en cuenta que las opciones de voz son ligeramente distintas. Consulta la guía de conversaciones en tiempo real para conocer las voces disponibles actualmente en esa API.

Transmisión de audio en tiempo real

La API de voz permite transmitir audio en tiempo real mediante la codificación de transferencia por fragmentos. Así puedes empezar a reproducir el audio antes de que se genere y esté disponible el archivo completo.

Transmite la voz generada a partir del texto de entrada directamente a tus altavoces

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14import 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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import 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())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27package 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)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46import 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");
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13require "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

1
2
3
4
5
6
7
8
9
10curl 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 -

Para obtener los tiempos de respuesta más cortos, te recomendamos usar wav o pcm como formato de respuesta.

Formatos de salida compatibles

El formato de respuesta predeterminado es mp3, pero también hay otros formatos disponibles, como opus y wav.

MP3: formato de respuesta predeterminado para uso general.
Opus: ofrece baja latencia para la transmisión y la comunicación por internet.
AAC: formato de compresión de audio digital que prefieren YouTube, Android e iOS.
FLAC: formato de compresión sin pérdida que prefieren los aficionados al audio para archivar grabaciones.
WAV: audio WAV sin comprimir, adecuado para aplicaciones de baja latencia que necesitan evitar el costo de la decodificación.
PCM: similar a WAV, pero contiene las muestras sin procesar a 24 kHz (16 bits con signo, con el byte menos significativo primero) y no incluye encabezado.

Idiomas compatibles

En general, el modelo de conversión de texto a voz admite los mismos idiomas que Whisper. Whisper admite los siguientes idiomas y ofrece buenos resultados, aunque las voces están optimizadas para el inglés:

afrikáans, árabe, armenio, azerí, bielorruso, bosnio, búlgaro, catalán, chino, croata, checo, danés, neerlandés, inglés, estonio, finés, francés, gallego, alemán, griego, hebreo, hindi, húngaro, islandés, indonesio, italiano, japonés, canarés, kazajo, coreano, letón, lituano, macedonio, malayo, maratí, maorí, nepalí, noruego, persa, polaco, portugués, rumano, ruso, serbio, eslovaco, esloveno, español, suajili, sueco, tagalo, tamil, tailandés, turco, ucraniano, urdu, vietnamita y galés.

Para generar voz en cualquiera de estos idiomas, proporciona el texto de entrada en el idioma que elijas.

Voces personalizadas

Crea una voz personalizada aprobada a partir de una grabación en la que la persona da su consentimiento y una muestra de audio de esa misma voz. Consulta Voces personalizadas para saber quién puede usar esta función, qué requisitos deben cumplir las grabaciones, qué frases se usan para dar el consentimiento y cómo realizar las solicitudes a la API.

Crear una voz

Sigue los pasos de Crear una voz personalizada.

Usar una voz al generar audio

Al generar voz, pasa el ID de la voz que creaste. Consulta los ejemplos de generación de voz.

Guías relacionadas

Introducción a la interacción en tiempo real y al audio

Elige la opción adecuada para crear agentes de voz, traducir, transcribir o generar voz.

Conceptos de audio y voz

Repasa las modalidades de audio, las tareas de voz, la transmisión de audio y las API basadas en solicitudes.

Sugerencias

Primeros pasos

Conceptos fundamentales

SDK y CLI

Proveedores de servicios en la nube

Recursos

API heredadas

Elige un modelo

Texto y código

Redacción de prompts

Razonamiento

Imágenes

Tiempo real y audio

Modelos especializados

API de agentes

Agents SDK

ChatKit

Búsqueda y recuperación de información

Conecta herramientas y datos

Crea flujos de trabajo con herramientas

Computadora y código

Multimedia

GPT-Live

Realtime API

Desarrollar aplicaciones de voz

Conexiones

Procesamiento de audio

Pasa a producción

Rendimiento y calidad

Evaluación

Costo y rendimiento

Seguridad y gobernanza

Infraestructura y acceso

Operaciones

Conceptos básicos

Planificación

Desarrollo

Pruebas y publicación

Especificaciones de conversión

Guías

Recursos

Identidad

Uso del plan de ChatGPT

Guías

Carga de archivos

API

Medición

API para anunciantes

Referencia de la API

Primeros pasos

Primeros pasos

Fundamentos

Explorar

Disponible en

Versiones

Flujos de trabajo

Capacidades

Sites

dots

ChatGPT Espacio

Referencia

Personalización

Archivo de configuración

Configuración de agentes

Ampliar las funciones de ChatGPT y Codex

Linux

Windows

Flujos de trabajo de desarrollo

Ampliar funciones y automatizar

Entornos

Codex Cloud

Desarrollar con Codex

Integraciones de terceros

Referencia

Permisos

Codex Security

Ciberseguridad

Primeros pasos

Configuración de funciones

Identidad y acceso