> ## Documentation Index
> Fetch the complete documentation index at: https://veniceai-mintlify-de47a659.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Speech-to-Text

> Transcribe audio files to text with Venice speech-to-text models via /audio/transcriptions, choosing response formats and segment timestamps.

Speech-to-text transcribes spoken audio into written text. Send an audio file to `/audio/transcriptions`, choose a transcription model, and select the response format you want back.

Working with a recording of a conversation? [Meeting Notes with Speech to Text](/guides/media/meeting-notes) goes from an audio file to decisions and action items that cite the second they were agreed, including which models return segment timings and how to handle a transcript that never says who is speaking.

## Basic Usage

<CodeGroup>
  ```python Python theme={null}
  import os

  import requests

  with open("meeting.mp3", "rb") as audio:
      response = requests.post(
          "https://api.venice.ai/api/v1/audio/transcriptions",
          headers={"Authorization": f"Bearer {os.environ['VENICE_API_KEY']}"},
          files={"file": audio},
          data={
              "model": "nvidia/parakeet-tdt-0.6b-v3",
              "response_format": "json",
          },
      )

  response.raise_for_status()
  print(response.json()["text"])
  ```

  ```javascript Node.js theme={null}
  import { createReadStream } from "node:fs";
  import FormData from "form-data";

  const form = new FormData();
  form.append("file", createReadStream("meeting.mp3"));
  form.append("model", "nvidia/parakeet-tdt-0.6b-v3");
  form.append("response_format", "json");

  const response = await fetch("https://api.venice.ai/api/v1/audio/transcriptions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.VENICE_API_KEY}`,
      ...form.getHeaders(),
    },
    body: form,
  });

  if (!response.ok) {
    throw new Error(await response.text());
  }

  const transcript = await response.json();
  console.log(transcript.text);
  ```

  ```bash cURL theme={null}
  curl https://api.venice.ai/api/v1/audio/transcriptions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    --form file=@meeting.mp3 \
    --form model=nvidia/parakeet-tdt-0.6b-v3 \
    --form response_format=json
  ```
</CodeGroup>

## Supported Inputs

Supported audio formats are `wav`, `wave`, `flac`, `m4a`, `aac`, `mp4`, `mp3`, `ogg`, `oga`, and `webm`. A file is accepted when either its MIME type or its extension is on that list, and the uploaded bytes must also pass a magic-byte check — renaming a file to a supported extension will not get it through. See the [Speech-to-Text Models](/models/speech-to-text) page for current model support and pricing.

## Response Formats

| Format | Use when                                                                                 |
| ------ | ---------------------------------------------------------------------------------------- |
| `json` | You want a structured response: `text`, plus `duration` and `timestamps` when available. |
| `text` | You want plain text without JSON parsing.                                                |

<Note>
  These are the only two values `response_format` accepts. There is no `srt`, `vtt`, or `verbose_json` option — requesting one returns a `400`. To build subtitles, use `timestamps: true` with `response_format: json` and render the timing data yourself.
</Note>

## Timestamps

Pass `timestamps=true` to get timing data back alongside the transcript. Support is model-specific, and the granularity differs:

| Model                         | Granularity |
| ----------------------------- | ----------- |
| `elevenlabs/scribe-v2`        | `word`      |
| `stt-xai-v1`                  | `word`      |
| `openai/whisper-large-v3`     | `segment`   |
| `fal-ai/wizper`               | `segment`   |
| `nvidia/parakeet-tdt-0.6b-v3` | None        |

<Warning>
  The default model, `nvidia/parakeet-tdt-0.6b-v3`, accepts `timestamps=true` and then ignores it — you get a response containing only `text`, with no error and no warning. Pick a model from the table above if you need timings, and check that the `timestamps` key exists before reading it.
</Warning>

```bash theme={null}
curl https://api.venice.ai/api/v1/audio/transcriptions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  --form file=@meeting.mp3 \
  --form model=elevenlabs/scribe-v2 \
  --form timestamps=true \
  --form response_format=json
```

```json theme={null}
{
  "text": "The quick brown fox jumps over the lazy dog.",
  "duration": 4.099,
  "timestamps": {
    "word": [
      { "word": "The", "start": 0.0, "end": 0.14 },
      { "word": "quick", "start": 0.14, "end": 0.42 }
    ]
  }
}
```

Segment-level models return a `segment` array instead, where each entry is `{ "text": "...", "start": 0.0, "end": 3.2 }`. All times are in seconds.

<Note>
  No Venice transcription model performs speaker diarization, so there is no `speaker` field on any response. A transcript is a single stream of text — speakers can only be attributed when a name is said out loud.
</Note>

## Production Tips

* Keep audio clear and avoid overlapping speakers when possible.
* Split very long recordings into smaller chunks if your workflow needs lower latency or easier retries.
* Store the original audio path, model ID, and response format with each transcript for auditability.

## Related Resources

* [Audio Transcriptions API](/api-reference/endpoint/audio/transcriptions)
* [Speech-to-Text Models](/models/speech-to-text)
* [Text-to-Speech Guide](/guides/media/text-to-speech)