# Audio in

Send a recording with your question; get an answer about it.

1. [Pick a model that listens](#1-pick-a-model-that-listens).
2. [Add the recording as a part of your message](#2-add-the-recording-as-a-part-of-your-message).
3. [Read the answer](#3-read-the-answer).

To turn a recording into text and nothing else, [Transcription](/docs/transcription) is the guide.

## 1. Pick a model that listens

Only some text models take sound. [Models that take audio in](/models?modality=text&input_modality=audio) lists them; the sample below uses `google/gemini-2.5-flash`.

<div class="watch-out">
<p>A recording sent to a model that cannot listen is refused before it goes anywhere, with a 400. Nothing is charged.</p>
</div>

## 2. Add the recording as a part of your message

A message's `content` is a text, or a list of parts. To send a recording, make it a list: one `text` part for your question, one `input_audio` part for the recording.

| Part | Holds |
|---|---|
| `{"type": "text", "text": "..."}` | your question |
| `{"type": "input_audio", "input_audio": {"data": "...", "format": "wav"}}` | the recording: its bytes as base64 in `data`, and its format (`wav` or `mp3`) in `format` |

The recording goes in the request itself: there is no link to give. Read the file, encode it as base64, and put the result in `data`.

```python
import base64
import json
import os
import urllib.request

API_KEY = os.environ["OPENDUNES_API_KEY"]
ADDRESS = "https://opendunes.com/v1/chat/completions"
MODEL = "google/gemini-2.5-flash"
PROMPT = "List the decisions taken in this meeting."
RECORDING_FILE = "meeting.wav"

with open(RECORDING_FILE, "rb") as file:
    recording = base64.b64encode(file.read()).decode()

body = {
    "model": MODEL,
    "messages": [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": PROMPT},
                {
                    "type": "input_audio",
                    "input_audio": {"data": recording, "format": "wav"},
                },
            ],
        }
    ],
}

request = urllib.request.Request(
    ADDRESS,
    data=json.dumps(body).encode(),
    headers={
        "Authorization": "Bearer " + API_KEY,
        "Content-Type": "application/json",
    },
)
with urllib.request.urlopen(request) as response:
    reply = json.load(response)

print(reply["choices"][0]["message"]["content"])
print(reply["usage"]["cost"])
```

```javascript
import { readFileSync } from "node:fs";

const API_KEY = process.env.OPENDUNES_API_KEY;
const ADDRESS = "https://opendunes.com/v1/chat/completions";
const MODEL = "google/gemini-2.5-flash";
const PROMPT = "List the decisions taken in this meeting.";
const RECORDING_FILE = "meeting.wav";

const recording = readFileSync(RECORDING_FILE).toString("base64");

const response = await fetch(ADDRESS, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: MODEL,
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: PROMPT },
          {
            type: "input_audio",
            input_audio: { data: recording, format: "wav" },
          },
        ],
      },
    ],
  }),
});
const reply = await response.json();

console.log(reply.choices[0].message.content);
console.log(reply.usage.cost);
```

```go
package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

const (
	address       = "https://opendunes.com/v1/chat/completions"
	model         = "google/gemini-2.5-flash"
	prompt        = "List the decisions taken in this meeting."
	recordingFile = "meeting.wav"
)

func main() {
	apiKey := os.Getenv("OPENDUNES_API_KEY")

	bytesRead, err := os.ReadFile(recordingFile)
	if err != nil {
		panic(err)
	}
	recording := base64.StdEncoding.EncodeToString(bytesRead)

	body, err := json.Marshal(map[string]any{
		"model": model,
		"messages": []any{
			map[string]any{
				"role": "user",
				"content": []any{
					map[string]any{"type": "text", "text": prompt},
					map[string]any{
						"type": "input_audio",
						"input_audio": map[string]any{
							"data":   recording,
							"format": "wav",
						},
					},
				},
			},
		},
	})
	if err != nil {
		panic(err)
	}

	request, err := http.NewRequest("POST", address, bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	request.Header.Set("Authorization", "Bearer "+apiKey)
	request.Header.Set("Content-Type", "application/json")

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	var reply struct {
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
		} `json:"choices"`
		Usage struct {
			Cost float64 `json:"cost"`
		} `json:"usage"`
	}
	if err := json.NewDecoder(response.Body).Decode(&reply); err != nil {
		panic(err)
	}
	fmt.Println(reply.Choices[0].Message.Content)
	fmt.Println(reply.Usage.Cost)
}
```

```bash cURL
ADDRESS="https://opendunes.com/v1/chat/completions"
MODEL="google/gemini-2.5-flash"
PROMPT="List the decisions taken in this meeting."
RECORDING_FILE="meeting.wav"

RECORDING=$(base64 < "$RECORDING_FILE" | tr -d '\n')

curl "$ADDRESS" \
  -H "Authorization: Bearer $OPENDUNES_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
  "model": "$MODEL",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "$PROMPT"
        },
        {
          "type": "input_audio",
          "input_audio": {
            "data": "$RECORDING",
            "format": "wav"
          }
        }
      ]
    }
  ]
}
EOF
```

<div class="do">
<p>Send <code>wav</code> or <code>mp3</code>, and keep the recording short enough that the whole request stays under 32 MB.</p>
</div>

<div class="dont">
<p>Don't put a link in <code>data</code>. It holds the recording's bytes, as base64, never an address.</p>
</div>

## 3. Read the answer

The answer is the text in `choices[0].message.content`, as on any text request. The recording is charged as audio input, counted in `usage.prompt_tokens_details.audio_tokens`, and `usage.cost` is the whole charge.

To send the answer back as a stream, see [Streaming](/docs/streaming). Every field of the request: [Chat](/docs/reference/chat-completions).

<div class="good-to-know">
<p>A batch does not take audio. Send the request on its own: see <a href="/docs/batches">Batches</a>.</p>
</div>

## Errors

The body says why. What to do on every status: [Errors and retries](/docs/errors-and-retries).

| Status | Means |
|---|---|
| 400 | the model takes no audio, or the recording is in a format it does not read |
| 402 | the balance cannot cover the request |
| 404 | no such model |
| 413 | the request is larger than the door takes |
