Synthèse vocale | OpenAI API

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

Lire un article de blog à voix haute
Produire de la parole dans plusieurs langues
Fournir une sortie audio en temps réel grâce au streaming

Voici un exemple de la voix alloy :

Nos politiques d’utilisation vous obligent à informer clairement les utilisateurs finaux que la voix de synthèse qu’ils entendent est générée par l’IA et n’est pas une voix humaine.

Démarrage rapide

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

Le modèle que vous utilisez
Le texte à convertir en audio
La voix utilisée pour lire le texte

Voici un exemple de requête simple :

Générez de la parole à partir du texte fourni

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 produit un fichier MP3 de la parole générée, mais vous pouvez le configurer pour utiliser n’importe quel format pris en charge.

Modèles de synthèse vocale

Pour les applications intelligentes en temps réel, utilisez le modèle gpt-4o-mini-tts, notre modèle de synthèse vocale le plus récent et le plus fiable. Vous pouvez lui donner des instructions par prompt pour contrôler différents aspects de la parole, notamment :

L’accent
La palette d’émotions
L’intonation
Les imitations
Le débit de parole
Le ton
Le 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 une qualité inférieure à celle du modèle tts-1-hd.

Choix de la voix

Le point de terminaison TTS propose 13 voix intégrées pour contrôler le rendu vocal du texte. Écoutez et essayez ces voix sur OpenAI.fm, notre démonstration interactive permettant de tester le 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 obtenir la meilleure qualité, nous vous recommandons d’utiliser marin ou cedar.

Les voix disponibles dépendent du modèle. Les modèles tts-1 et tts-1-hd prennent en charge un ensemble plus restreint : alloy, ash, coral, echo, fable, onyx, nova, sage et shimmer.

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

Streaming audio en temps réel

L’API Speech prend en charge le streaming audio en temps réel grâce à l’encodage de transfert par blocs. L’audio peut ainsi être lu avant que le fichier complet soit généré et rendu accessible.

Diffusez en streaming la parole générée à partir du texte fourni 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 cas d’utilisation courants.
Opus : pour le streaming et les communications sur Internet, avec une faible latence.
AAC : pour la compression audio numérique, privilégié par YouTube, Android et iOS.
FLAC : pour la compression audio sans perte, apprécié des audiophiles pour l’archivage.
WAV : audio WAV non compressé, adapté aux applications à faible latence pour éviter le traitement supplémentaire lié au décodage.
PCM : similaire au WAV, mais contient les échantillons bruts à 24 kHz (16 bits signés, petit-boutiste), sans en-tête.

Langues prises en charge

Les langues prises en charge par le modèle TTS sont globalement les mêmes que celles du modèle Whisper. Whisper prend en charge les langues suivantes et offre 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.

Vous pouvez générer de la parole dans ces langues en fournissant un texte dans la langue de votre choix.

Voix personnalisées

Créez une voix personnalisée approuvée à partir d’un enregistrement du consentement d’un locuteur et d’un échantillon audio correspondant. Consultez Voix personnalisées pour connaître les critères d’éligibilité, les exigences d’enregistrement, les phrases de consentement et les requêtes API.

Création d’une voix

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

Utilisation d’une voix lors de la génération de parole

Transmettez l’identifiant de la voix créée lors de la génération de parole. Consultez les exemples de génération de parole.

Vue d’ensemble de Realtime et de l’audio

Choisissez l’approche adaptée aux agents vocaux, à la traduction, à la transcription et à la génération de parole.

Concepts de l’audio et de la parole

Découvrez les modalités audio, les tâches liées à la parole, le streaming et les API basées sur des requêtes.

Suggestions

Bien démarrer

Concepts fondamentaux

SDK et CLI

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Conception de prompts

Raisonnement

Images et vidéo

Realtime et audio

Modèles spécialisés

API Agents

SDK Agents

ChatKit

Recherche et récupération

Connectez des outils et des données

Créez des flux de travail avec des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Développez avec la voix

Connexions

Traitement audio

Passez en production

Performances et qualité

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts fondamentaux

Plan

Build

Test and publish

Conversion specs

Guides

Ressources

Bien démarrer

Guides

File Upload

API

Measurement

Advertiser API

Référence de l’API

Bien démarrer

Fondamentaux

Explorer

Disponible sur

Versions

Flux de travail

Capacités

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendez les capacités de ChatGPT et de Codex

Linux

Windows

Flux de travail de développement

Étendre et automatiser

Environnements

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Bien démarrer

ChatGPT Work

Identité et authentification

Accès à l’espace de travail, stratégies et modèles

Contrôles des plugins et des connecteurs

Utilisation, gouvernance et conformité

Déploiement et fournisseurs de modèles

Communauté

Blog

Communauté

Blog