Synthèse vocale | OpenAI API

Les modèles tts-1, tts-1-hd et gpt-4o-mini-tts sont obsolètes et seront retirés le 6 janvier 2027. Migrez vers gpt-realtime-2.1-mini en utilisant la Realtime API. Cette migration change la façon d’appeler l’API, car le modèle gpt-realtime-2.1-mini ne peut pas être utilisé avec /v1/audio/speech. Les intégrations existantes peuvent continuer à utiliser l’API Speech comme indiqué ci-dessous jusqu’au retrait des modèles. Consultez l’avis de dépréciation.

L’API Audio propose un point de terminaison speech basé sur notre modèle de synthèse vocale GPT-4o mini TTS. Il offre 11 voix intégrées et permet de :

Lire un article de blog à voix haute
Générer de la parole dans plusieurs langues
Diffuser le son en continu et en temps réel

Voici un extrait de la voix alloy :

Nos politiques d’utilisation vous imposent d’indiquer clairement aux utilisateurs finaux que la voix de synthèse qu’ils entendent est générée par une IA et qu’il ne s’agit pas d’une voix humaine.

Démarrage rapide

Le point de terminaison speech accepte trois paramètres principaux :

Le modèle à utiliser
Le texte à convertir en parole
La voix qui lira le texte

Voici un exemple de requête :

Générez de la parole à partir d’un texte

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

Par défaut, le point de terminaison renvoie un fichier MP3 contenant le texte lu à voix haute. Vous pouvez le configurer pour obtenir la réponse dans n’importe quel format pris en charge.

Modèles de synthèse vocale

Si vous utilisez déjà l’API Speech, le modèle gpt-4o-mini-tts vous permet de contrôler les caractéristiques suivantes de la voix à l’aide de prompts :

Accent
Palette d’émotions
Intonation
Imitations vocales
Débit de parole
Ton
Chuchotement

Nos autres modèles de synthèse vocale sont tts-1 et tts-1-hd. Le modèle tts-1 offre une latence plus faible, mais la qualité audio est inférieure à celle du modèle tts-1-hd.

Choix de la voix

Le point de terminaison de synthèse vocale propose 13 voix intégrées pour choisir comment le texte sera lu. Écoutez et essayez ces voix sur OpenAI.fm, notre démo interactive du dernier modèle de synthèse vocale de l’API OpenAI. Les voix sont actuellement optimisées pour l’anglais.

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

Pour une qualité optimale, nous vous recommandons d’utiliser marin ou cedar.

Les voix disponibles varient selon le modèle. Les modèles tts-1 et tts-1-hd prennent en charge un choix plus restreint de voix : alloy, ash, coral, echo, fable, onyx, nova, sage et shimmer.

Si vous utilisez la Realtime API, le choix de voix est légèrement différent. Consultez le guide des conversations en temps réel pour connaître les voix actuellement disponibles en temps réel.

Diffusion audio en temps réel

L’API Speech permet de diffuser l’audio en temps réel grâce au codage de transfert par blocs. La lecture peut ainsi commencer avant que le fichier complet soit généré et disponible.

Diffusez la lecture d’un texte en continu directement sur vos haut-parleurs

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 -

Pour obtenir les temps de réponse les plus courts, nous vous recommandons d’utiliser wav ou pcm comme format de réponse.

Formats de sortie pris en charge

Le format de réponse par défaut est mp3, mais d’autres formats comme opus et wav sont disponibles.

MP3 : format de réponse par défaut pour les usages courants.
Opus : format à faible latence adapté à la diffusion en continu et aux communications sur Internet.
AAC : format de compression audio numérique privilégié par YouTube, Android et iOS.
FLAC : format de compression audio sans perte que les amateurs de haute fidélité privilégient pour l’archivage.
WAV : format audio WAV non compressé, adapté aux applications à faible latence puisqu’il évite le coût du décodage.
PCM : format similaire au WAV, mais sans en-tête. Il contient les échantillons bruts à 24 kHz, codés sur 16 bits signés avec l’octet de poids faible en premier.

Langues prises en charge

Le modèle de synthèse vocale prend généralement en charge les mêmes langues que le modèle Whisper. Whisper prend en charge les langues suivantes et donne de bons résultats, même si les voix sont optimisées pour l’anglais :

Afrikaans, arabe, arménien, azerbaïdjanais, biélorusse, bosnien, bulgare, catalan, chinois, croate, tchèque, danois, néerlandais, anglais, estonien, finnois, français, galicien, allemand, grec, hébreu, hindi, hongrois, islandais, indonésien, italien, japonais, kannada, kazakh, coréen, letton, lituanien, macédonien, malais, marathi, maori, népalais, norvégien, persan, polonais, portugais, roumain, russe, serbe, slovaque, slovène, espagnol, swahili, suédois, tagalog, tamoul, thaï, turc, ukrainien, ourdou, vietnamien et gallois.

Pour générer de la parole dans l’une de ces langues, fournissez un texte dans la langue de votre choix.

Voix personnalisées

Pour créer une voix personnalisée approuvée, fournissez un enregistrement dans lequel la personne donne son consentement ainsi qu’un échantillon audio de sa voix. Consultez le guide Voix personnalisées pour connaître les critères d’éligibilité, les exigences d’enregistrement, les phrases de consentement et les requêtes API à utiliser.

Création d’une voix

Suivez les étapes de la section Créer une voix personnalisée.

Utilisation d’une voix pour la synthèse vocale

Transmettez l’identifiant de la voix créée dans votre requête de synthèse vocale. Consultez les exemples de synthèse vocale.

Guides associés

Présentation du temps réel et de l’audio

Choisissez l’approche adaptée aux agents vocaux, à la traduction, à la transcription et à la synthèse vocale.

Notions sur l’audio et la parole

Découvrez les modalités audio, les tâches de traitement de la parole, la diffusion en continu et les API qui fonctionnent par requêtes.

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

API Agents

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès