Audio in Chat Completions

For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.

If you already have a text-based LLM application with the Chat Completions endpoint, you may want to add audio capabilities. For example, if your chat application supports text input, you can add audio input and output: include audio in the modalities array and use an audio model, like gpt-audio-1.5.

The Responses API docs currently describe text and image inputs with text outputs. For this audio-chat pattern, use Chat Completions with an audio-capable model.

Audio output from model

Create a human-like audio response to a prompt

import { writeFileSync } from "node:fs";
import OpenAI from "openai";

const openai = new OpenAI();

// Generate an audio response to the given prompt
const response = await openai.chat.completions.create({
  model: "gpt-audio-1.5",
  modalities: ["text", "audio"],
  audio: { voice: "alloy", format: "wav" },
  messages: [
    {
      role: "user",
      content: "Is a golden retriever a good family dog?",
    },
  ],
  store: true,
});

// Inspect returned data
console.log(response.choices[0]);

// Write audio data to a file
writeFileSync(
  "dog.wav",
  Buffer.from(response.choices[0].message.audio.data, "base64"),
  { encoding: "utf-8" }
);

import base64
from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-audio-1.5",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[{"role": "user", "content": "Is a golden retriever a good family dog?"}],
)

print(completion.choices[0])

wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("dog.wav", "wb") as f:
    f.write(wav_bytes)

package main

import (
	"context"
	"encoding/base64"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model:      "gpt-audio-1.5",
		Modalities: []string{"text", "audio"},
		Audio: openai.ChatCompletionAudioParam{
			Voice:  openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},
			Format: openai.ChatCompletionAudioParamFormatWAV,
		},
		Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage("Is a golden retriever a good family dog?")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Choices[0])
	audio, err := base64.StdEncoding.DecodeString(response.Choices[0].Message.Audio.Data)
	if err != nil {
		panic(err)
	}
	if err := os.WriteFile("dog.wav", audio, 0o600); err != nil {
		panic(err)
	}
}

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionAudioParam;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-audio-1.5")
        .addUserMessage("Is a golden retriever a good family dog?")
        .addModality(ChatCompletionCreateParams.Modality.TEXT)
        .addModality(ChatCompletionCreateParams.Modality.AUDIO)
        .audio(
            ChatCompletionAudioParam.builder()
                .voice("alloy")
                .format(ChatCompletionAudioParam.Format.WAV)
                .build())
        .store(true)
        .build();

var message = client.chat().completions().create(params).choices().get(0).message();
var audio =
    message.audio().orElseThrow(() -> new IllegalStateException("No audio output returned"));
Files.write(Path.of("dog.wav"), Base64.getDecoder().decode(audio.data()));
message.content().ifPresent(System.out::println);

using OpenAI.Chat;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ChatClient client = new("gpt-audio-1.5", key);

ChatCompletionOptions options = new()
{
    ResponseModalities = ChatResponseModalities.Text | ChatResponseModalities.Audio,
    AudioOptions = new(ChatOutputAudioVoice.Alloy, ChatOutputAudioFormat.Wav),
    StoredOutputEnabled = true,
};

ChatCompletion completion = await client.CompleteChatAsync(
    [new UserChatMessage("Is a golden retriever a good family dog?")],
    options
);

if (completion.OutputAudio is not ChatOutputAudio audio)
{
    throw new InvalidOperationException("No audio output was returned.");
}

Console.WriteLine(audio.Transcript);
await File.WriteAllBytesAsync("dog.wav", audio.AudioBytes.ToArray());

require "base64"
require "openai"

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-audio-1.5",
  messages: [{role: :user, content: "Is a golden retriever a good family dog?"}],
  modalities: [:text, :audio],
  audio: {voice: :alloy, format: :wav},
  store: true
)

audio = completion.choices.fetch(0).message.audio or raise "No audio returned"
File.binwrite("dog.wav", Base64.strict_decode64(audio.data))

curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
      "model": "gpt-audio-1.5",
      "modalities": ["text", "audio"],
      "audio": { "voice": "alloy", "format": "wav" },
      "messages": [
        {
          "role": "user",
          "content": "Is a golden retriever a good family dog?"
        }
      ]
    }'

Audio input to model

Use audio inputs for prompting a model

import OpenAI from "openai";
const openai = new OpenAI();

// Fetch an audio file and convert it to a base64 string
const url = "https://cdn.openai.com/API/docs/audio/alloy.wav";
const audioResponse = await fetch(url);
const buffer = await audioResponse.arrayBuffer();
const base64str = Buffer.from(buffer).toString("base64");

const response = await openai.chat.completions.create({
  model: "gpt-audio-1.5",
  modalities: ["text", "audio"],
  audio: { voice: "alloy", format: "wav" },
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "What is in this recording?" },
        {
          type: "input_audio",
          input_audio: { data: base64str, format: "wav" },
        },
      ],
    },
  ],
  store: true,
});

console.log(response.choices[0]);

import base64
import requests
from openai import OpenAI

client = OpenAI()

# Fetch the audio file and convert it to a base64 encoded string
url = "https://cdn.openai.com/API/docs/audio/alloy.wav"
response = requests.get(url)
response.raise_for_status()
wav_data = response.content
encoded_string = base64.b64encode(wav_data).decode("utf-8")

completion = client.chat.completions.create(
    model="gpt-audio-1.5",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What is in this recording?"},
                {
                    "type": "input_audio",
                    "input_audio": {"data": encoded_string, "format": "wav"},
                },
            ],
        },
    ],
)

print(completion.choices[0].message)

package main

import (
	"context"
	"encoding/base64"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
)

func main() {
	audio, err := os.ReadFile("fixtures/audio.wav")
	if err != nil {
		panic(err)
	}
	client := openai.NewClient()
	response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model:      "gpt-audio-1.5",
		Modalities: []string{"text", "audio"},
		Audio: openai.ChatCompletionAudioParam{
			Voice:  openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},
			Format: openai.ChatCompletionAudioParamFormatWAV,
		},
		Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
			openai.TextContentPart("What is in this recording?"),
			openai.InputAudioContentPart(openai.ChatCompletionContentPartInputAudioInputAudioParam{
				Data:   base64.StdEncoding.EncodeToString(audio),
				Format: "wav",
			}),
		})},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Choices[0])
}

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionAudioParam;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartInputAudio;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String encodedAudio =
    Base64.getEncoder()
        .encodeToString(
            Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_AUDIO_PATH"))));

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-audio-1.5")
        .addMessage(
            ChatCompletionUserMessageParam.builder()
                .contentOfArrayOfContentParts(
                    List.of(
                        ChatCompletionContentPart.ofText(
                            ChatCompletionContentPartText.builder()
                                .text("What is in this recording?")
                                .build()),
                        ChatCompletionContentPart.ofInputAudio(
                            ChatCompletionContentPartInputAudio.builder()
                                .inputAudio(
                                    ChatCompletionContentPartInputAudio.InputAudio.builder()
                                        .data(encodedAudio)
                                        .format(
                                            ChatCompletionContentPartInputAudio.InputAudio
                                                .Format.WAV)
                                        .build())
                                .build())))
                .build())
        .addModality(ChatCompletionCreateParams.Modality.TEXT)
        .addModality(ChatCompletionCreateParams.Modality.AUDIO)
        .audio(
            ChatCompletionAudioParam.builder()
                .voice("alloy")
                .format(ChatCompletionAudioParam.Format.WAV)
                .build())
        .store(true)
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

using OpenAI.Chat;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ChatClient client = new("gpt-audio-1.5", key);

BinaryData audio = BinaryData.FromBytes(
    await File.ReadAllBytesAsync("audio.wav")
);
UserChatMessage message = new(
    [
        ChatMessageContentPart.CreateTextPart("What is in this recording?"),
        ChatMessageContentPart.CreateInputAudioPart(
            audio,
            ChatInputAudioFormat.Wav
        ),
    ]
);
ChatCompletionOptions options = new()
{
    ResponseModalities = ChatResponseModalities.Text | ChatResponseModalities.Audio,
    AudioOptions = new(ChatOutputAudioVoice.Alloy, ChatOutputAudioFormat.Wav),
    StoredOutputEnabled = true,
};

ChatCompletion completion = await client.CompleteChatAsync([message], options);

if (completion.OutputAudio is not ChatOutputAudio audioOutput)
{
    throw new InvalidOperationException("No audio output was returned.");
}

Console.WriteLine(audioOutput.Transcript);

require "base64"
require "openai"

client = OpenAI::Client.new
audio = Base64.strict_encode64(File.binread("audio.wav"))
completion = client.chat.completions.create(
  model: "gpt-audio-1.5",
  messages: [{
    role: :user,
    content: [
      {type: :text, text: "What is in this recording?"},
      {type: :input_audio, input_audio: {data: audio, format: :wav}}
    ]
  }],
  modalities: [:text, :audio],
  audio: {voice: :alloy, format: :wav},
  store: true
)

puts(completion.choices.fetch(0).message.content)

curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
      "model": "gpt-audio-1.5",
      "modalities": ["text", "audio"],
      "audio": { "voice": "alloy", "format": "wav" },
      "messages": [
        {
          "role": "user",
          "content": [
            { "type": "text", "text": "What is in this recording?" },
            { 
              "type": "input_audio", 
              "input_audio": { 
                "data": "<base64 bytes here>", 
                "format": "wav" 
              }
            }
          ]
        }
      ]
    }'

guides/audio-chat-completions.md +454 −0 created

1# Audio in Chat Completions

3> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.

5If you already have a text-based LLM application with the [Chat Completions endpoint](https://developers.openai.com/api/reference/resources/chat), you may want to add audio capabilities. For example, if your chat application supports text input, you can add audio input and output: include `audio` in the `modalities` array and use an audio model, like [`gpt-audio-1.5`](https://developers.openai.com/api/docs/models/gpt-audio-1.5).

7The [Responses API](https://developers.openai.com/api/reference/resources/responses) docs currently describe

8 text and image inputs with text outputs. For this audio-chat pattern, use Chat

9 Completions with an audio-capable model.

13Audio output from model

15 Create a human-like audio response to a prompt

17```javascript

18import { writeFileSync } from "node:fs";

19import OpenAI from "openai";

21const openai = new OpenAI();

23// Generate an audio response to the given prompt

24const response = await openai.chat.completions.create({

25 model: "gpt-audio-1.5",

26 modalities: ["text", "audio"],

27 audio: { voice: "alloy", format: "wav" },

28 messages: [

29 {

30 role: "user",

31 content: "Is a golden retriever a good family dog?",

32 },

33 ],

34 store: true,

35});

37// Inspect returned data

38console.log(response.choices[0]);

40// Write audio data to a file

41writeFileSync(

42 "dog.wav",

43 Buffer.from(response.choices[0].message.audio.data, "base64"),

44 { encoding: "utf-8" }

45);

46```

48```python

49import base64

50from openai import OpenAI

52client = OpenAI()

54completion = client.chat.completions.create(

55 model="gpt-audio-1.5",

56 modalities=["text", "audio"],

57 audio={"voice": "alloy", "format": "wav"},

58 messages=[{"role": "user", "content": "Is a golden retriever a good family dog?"}],

59)

61print(completion.choices[0])

63wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)

64with open("dog.wav", "wb") as f:

65 f.write(wav_bytes)

66```

68```go

69package main

71import (

72 "context"

73 "encoding/base64"

74 "fmt"

75 "os"

77 "github.com/openai/openai-go/v3"

78)

80func main() {

81 client := openai.NewClient()

82 response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{

83 Model: "gpt-audio-1.5",

84 Modalities: []string{"text", "audio"},

85 Audio: openai.ChatCompletionAudioParam{

86 Voice: openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},

87 Format: openai.ChatCompletionAudioParamFormatWAV,

88 },

89 Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage("Is a golden retriever a good family dog?")},

90 })

91 if err != nil {

92 panic(err)

93 }

94 fmt.Println(response.Choices[0])

95 audio, err := base64.StdEncoding.DecodeString(response.Choices[0].Message.Audio.Data)

96 if err != nil {

97 panic(err)

98 }

99 if err := os.WriteFile("dog.wav", audio, 0o600); err != nil {

100 panic(err)

101 }

102}

103```

104

105```java

106import com.openai.client.OpenAIClient;

107import com.openai.client.okhttp.OpenAIOkHttpClient;

108import com.openai.models.chat.completions.ChatCompletionAudioParam;

109import com.openai.models.chat.completions.ChatCompletionCreateParams;

110import java.io.IOException;

111import java.nio.file.Files;

112import java.nio.file.Path;

113import java.util.Base64;

114

115ChatCompletionCreateParams params =

116 ChatCompletionCreateParams.builder()

117 .model("gpt-audio-1.5")

118 .addUserMessage("Is a golden retriever a good family dog?")

119 .addModality(ChatCompletionCreateParams.Modality.TEXT)

120 .addModality(ChatCompletionCreateParams.Modality.AUDIO)

121 .audio(

122 ChatCompletionAudioParam.builder()

123 .voice("alloy")

124 .format(ChatCompletionAudioParam.Format.WAV)

125 .build())

126 .store(true)

127 .build();

128

129var message = client.chat().completions().create(params).choices().get(0).message();

130var audio =

131 message.audio().orElseThrow(() -> new IllegalStateException("No audio output returned"));

132Files.write(Path.of("dog.wav"), Base64.getDecoder().decode(audio.data()));

133message.content().ifPresent(System.out::println);

134```

135

136```csharp

137using OpenAI.Chat;

138#pragma warning disable OPENAI001

139

140string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

141ChatClient client = new("gpt-audio-1.5", key);

142

143ChatCompletionOptions options = new()

144{

145 ResponseModalities = ChatResponseModalities.Text | ChatResponseModalities.Audio,

146 AudioOptions = new(ChatOutputAudioVoice.Alloy, ChatOutputAudioFormat.Wav),

147 StoredOutputEnabled = true,

148};

149

150ChatCompletion completion = await client.CompleteChatAsync(

151 [new UserChatMessage("Is a golden retriever a good family dog?")],

152 options

153);

154

155if (completion.OutputAudio is not ChatOutputAudio audio)

156{

157 throw new InvalidOperationException("No audio output was returned.");

158}

159

160Console.WriteLine(audio.Transcript);

161await File.WriteAllBytesAsync("dog.wav", audio.AudioBytes.ToArray());

162```

163

164```ruby

165require "base64"

166require "openai"

167

168client = OpenAI::Client.new

169completion = client.chat.completions.create(

170 model: "gpt-audio-1.5",

171 messages: [{role: :user, content: "Is a golden retriever a good family dog?"}],

172 modalities: [:text, :audio],

173 audio: {voice: :alloy, format: :wav},

174 store: true

175)

176

177audio = completion.choices.fetch(0).message.audio or raise "No audio returned"

178File.binwrite("dog.wav", Base64.strict_decode64(audio.data))

179```

180

181```bash

182curl "https://api.openai.com/v1/chat/completions" \

183 -H "Content-Type: application/json" \

184 -H "Authorization: Bearer $OPENAI_API_KEY" \

185 -d '{

186 "model": "gpt-audio-1.5",

187 "modalities": ["text", "audio"],

188 "audio": { "voice": "alloy", "format": "wav" },

189 "messages": [

190 {

191 "role": "user",

192 "content": "Is a golden retriever a good family dog?"

193 }

194 ]

195 }'

196```

197

198

199

200

201

202

203Audio input to model

204

205 Use audio inputs for prompting a model

206

207```javascript

208import OpenAI from "openai";

209const openai = new OpenAI();

210

211// Fetch an audio file and convert it to a base64 string

212const url = "https://cdn.openai.com/API/docs/audio/alloy.wav";

213const audioResponse = await fetch(url);

214const buffer = await audioResponse.arrayBuffer();

215const base64str = Buffer.from(buffer).toString("base64");

216

217const response = await openai.chat.completions.create({

218 model: "gpt-audio-1.5",

219 modalities: ["text", "audio"],

220 audio: { voice: "alloy", format: "wav" },

221 messages: [

222 {

223 role: "user",

224 content: [

225 { type: "text", text: "What is in this recording?" },

226 {

227 type: "input_audio",

228 input_audio: { data: base64str, format: "wav" },

229 },

230 ],

231 },

232 ],

233 store: true,

234});

235

236console.log(response.choices[0]);

237```

238

239```python

240import base64

241import requests

242from openai import OpenAI

243

244client = OpenAI()

245

246# Fetch the audio file and convert it to a base64 encoded string

247url = "https://cdn.openai.com/API/docs/audio/alloy.wav"

248response = requests.get(url)

249response.raise_for_status()

250wav_data = response.content

251encoded_string = base64.b64encode(wav_data).decode("utf-8")

252

253completion = client.chat.completions.create(

254 model="gpt-audio-1.5",

255 modalities=["text", "audio"],

256 audio={"voice": "alloy", "format": "wav"},

257 messages=[

258 {

259 "role": "user",

260 "content": [

261 {"type": "text", "text": "What is in this recording?"},

262 {

263 "type": "input_audio",

264 "input_audio": {"data": encoded_string, "format": "wav"},

265 },

266 ],

267 },

268 ],

269)

270

271print(completion.choices[0].message)

272```

273

274```go

275package main

276

277import (

278 "context"

279 "encoding/base64"

280 "fmt"

281 "os"

282

283 "github.com/openai/openai-go/v3"

284)

285

286func main() {

287 audio, err := os.ReadFile("fixtures/audio.wav")

288 if err != nil {

289 panic(err)

290 }

291 client := openai.NewClient()

292 response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{

293 Model: "gpt-audio-1.5",

294 Modalities: []string{"text", "audio"},

295 Audio: openai.ChatCompletionAudioParam{

296 Voice: openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},

297 Format: openai.ChatCompletionAudioParamFormatWAV,

298 },

299 Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{

300 openai.TextContentPart("What is in this recording?"),

301 openai.InputAudioContentPart(openai.ChatCompletionContentPartInputAudioInputAudioParam{

302 Data: base64.StdEncoding.EncodeToString(audio),

303 Format: "wav",

304 }),

305 })},

306 })

307 if err != nil {

308 panic(err)

309 }

310 fmt.Println(response.Choices[0])

311}

312```

313

314```java

315import com.openai.client.OpenAIClient;

316import com.openai.client.okhttp.OpenAIOkHttpClient;

317import com.openai.models.chat.completions.ChatCompletionAudioParam;

318import com.openai.models.chat.completions.ChatCompletionContentPart;

319import com.openai.models.chat.completions.ChatCompletionContentPartInputAudio;

320import com.openai.models.chat.completions.ChatCompletionContentPartText;

321import com.openai.models.chat.completions.ChatCompletionCreateParams;

322import com.openai.models.chat.completions.ChatCompletionUserMessageParam;

323import java.io.IOException;

324import java.nio.file.Files;

325import java.nio.file.Path;

326import java.util.Base64;

327import java.util.List;

328

329String encodedAudio =

330 Base64.getEncoder()

331 .encodeToString(

332 Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_AUDIO_PATH"))));

333

334ChatCompletionCreateParams params =

335 ChatCompletionCreateParams.builder()

336 .model("gpt-audio-1.5")

337 .addMessage(

338 ChatCompletionUserMessageParam.builder()

339 .contentOfArrayOfContentParts(

340 List.of(

341 ChatCompletionContentPart.ofText(

342 ChatCompletionContentPartText.builder()

343 .text("What is in this recording?")

344 .build()),

345 ChatCompletionContentPart.ofInputAudio(

346 ChatCompletionContentPartInputAudio.builder()

347 .inputAudio(

348 ChatCompletionContentPartInputAudio.InputAudio.builder()

349 .data(encodedAudio)

350 .format(

351 ChatCompletionContentPartInputAudio.InputAudio

352 .Format.WAV)

353 .build())

354 .build())))

355 .build())

356 .addModality(ChatCompletionCreateParams.Modality.TEXT)

357 .addModality(ChatCompletionCreateParams.Modality.AUDIO)

358 .audio(

359 ChatCompletionAudioParam.builder()

360 .voice("alloy")

361 .format(ChatCompletionAudioParam.Format.WAV)

362 .build())

363 .store(true)

364 .build();

365

366client.chat().completions().create(params).choices().stream()

367 .flatMap(choice -> choice.message().content().stream())

368 .forEach(System.out::println);

369```

370

371```csharp

372using OpenAI.Chat;

373#pragma warning disable OPENAI001

374

375string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

376ChatClient client = new("gpt-audio-1.5", key);

377

378BinaryData audio = BinaryData.FromBytes(

379 await File.ReadAllBytesAsync("audio.wav")

380);

381UserChatMessage message = new(

382 [

383 ChatMessageContentPart.CreateTextPart("What is in this recording?"),

384 ChatMessageContentPart.CreateInputAudioPart(

385 audio,

386 ChatInputAudioFormat.Wav

387 ),

388 ]

389);

390ChatCompletionOptions options = new()

391{

392 ResponseModalities = ChatResponseModalities.Text | ChatResponseModalities.Audio,

393 AudioOptions = new(ChatOutputAudioVoice.Alloy, ChatOutputAudioFormat.Wav),

394 StoredOutputEnabled = true,

395};

396

397ChatCompletion completion = await client.CompleteChatAsync([message], options);

398

399if (completion.OutputAudio is not ChatOutputAudio audioOutput)

400{

401 throw new InvalidOperationException("No audio output was returned.");

402}

403

404Console.WriteLine(audioOutput.Transcript);

405```

406

407```ruby

408require "base64"

409require "openai"

410

411client = OpenAI::Client.new

412audio = Base64.strict_encode64(File.binread("audio.wav"))

413completion = client.chat.completions.create(

414 model: "gpt-audio-1.5",

415 messages: [{

416 role: :user,

417 content: [

418 {type: :text, text: "What is in this recording?"},

419 {type: :input_audio, input_audio: {data: audio, format: :wav}}

420 ]

421 }],

422 modalities: [:text, :audio],

423 audio: {voice: :alloy, format: :wav},

424 store: true

425)

426

427puts(completion.choices.fetch(0).message.content)

428```

429

430```bash

431curl "https://api.openai.com/v1/chat/completions" \

432 -H "Content-Type: application/json" \

433 -H "Authorization: Bearer $OPENAI_API_KEY" \

434 -d '{

435 "model": "gpt-audio-1.5",

436 "modalities": ["text", "audio"],

437 "audio": { "voice": "alloy", "format": "wav" },

438 "messages": [

439 {

440 "role": "user",

441 "content": [

442 { "type": "text", "text": "What is in this recording?" },

443 {

444 "type": "input_audio",

445 "input_audio": {

446 "data": "<base64 bytes here>",

447 "format": "wav"

448 }

449 }

450 ]

451 }

452 ]

453 }'

454```

guides/audio-chat-completions.md 2026-09-09 23:59 UTC to 2026-09-10 18:01 UTC

Audio in Chat Completions