# Speech to text

> Transcribe audio files with POST /v1/audio/transcriptions: request and answer formats, speakers and timestamps, languages, limits, billing per second and data handling.

Source: https://docs.serenityedge.ai/docs/audio-transcriptions/

Serenity Edge transcribes audio files on `POST /v1/audio/transcriptions`, in the format of OpenAI's speech-to-text API, so the OpenAI SDKs work unchanged. One request carries one file and returns the transcript. On request it also returns who spoke when: speaker labels and timestamps for each segment.

|  |  |
| --- | --- |
| Endpoint | `POST /v1/audio/transcriptions`, a `multipart/form-data` form |
| Model | `vibevoice-asr` (alias `microsoft/vibevoice-asr`) |
| Licence | MIT, as published by Microsoft ([licence text](https://github.com/microsoft/VibeVoice/blob/9634518ca42c9c417ec51e4f293e8416faf3843e/LICENSE)) |
| Result | The transcript, as JSON or plain text; with `verbose_json`, segments with start, end and speaker |
| Languages | More than 50, detected automatically, including changes of language within a file |
| Billed | Per second of audio, rounded up per request: see [Billing](https://docs.serenityedge.ai/docs/audio-transcriptions/#billing) |
| Limits | 5 minutes of audio and 16 MiB per request |
| Access | Serenity Edge API keys |

## Request

```bash
curl https://api.serenityedge.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $SERENITY_EDGE_API_KEY" \
  -F model=vibevoice-asr \
  -F file=@meeting.mp3 \
  -F response_format=verbose_json
```

```python
from openai import OpenAI

client = OpenAI(base_url="https://api.serenityedge.ai/v1", api_key="YOUR_SERENITY_EDGE_API_KEY")

with open("meeting.mp3", "rb") as audio:
    transcript = client.audio.transcriptions.create(model="vibevoice-asr", file=audio)

print(transcript.text)
```

| Field | Required | Description |
| --- | --- | --- |
| `file` | Yes | The audio file, once per request. See [Audio files](https://docs.serenityedge.ai/docs/audio-transcriptions/#audio-files). |
| `model` | Yes | `vibevoice-asr` or `microsoft/vibevoice-asr`. |
| `response_format` | No | `json` (the default), `text` or `verbose_json`. `srt` and `vtt` are not supported. |
| `prompt` | No | Up to 2000 characters of context: names, technical terms or the topic. The model uses them to spell what it hears. |
| `language` | No | An ISO 639-1 code such as `es` or `en`. The model detects the language itself; the code is returned in `verbose_json`. |
| `temperature` | No | Accepted for compatibility (0 to 1) and not used. |
| `timestamp_granularities[]` | No | `segment` only. Word timestamps are not available. |
| `stream` | No | Accepted and ignored: the answer comes in one piece. |
| `remove_nonspeech_tags` | No | `true` removes the tags the model writes for audio without speech, such as `[Silence]`. `false`, the default, keeps them. See [Non-speech tags](https://docs.serenityedge.ai/docs/audio-transcriptions/#non-speech-tags). |

Other fields are ignored.

## Answer

With `json`, the transcript and the seconds billed:

```json
{
  "text": "Good morning, everyone. Shall we start? Yes, let's go.",
  "usage": {"type": "duration", "seconds": 4}
}
```

With `verbose_json`, also the duration and the segments, each with its speaker. Speaker labels are the model's and hold within one file only.

```json
{
  "task": "transcribe",
  "language": "en",
  "duration": 3.62,
  "text": "Good morning, everyone. Shall we start? Yes, let's go.",
  "segments": [
    {"id": 0, "start": 0.0, "end": 2.1, "text": "Good morning, everyone. Shall we start?", "speaker": 0},
    {"id": 1, "start": 2.4, "end": 3.5, "text": "Yes, let's go.", "speaker": 1}
  ],
  "usage": {"type": "duration", "seconds": 4}
}
```

With `text`, the transcript alone, as `text/plain`.

### Non-speech tags

The model marks audio without speech with a tag in square brackets, in the text and in the segments:

| Tag | Marks |
| --- | --- |
| `[Silence]` | A pause |
| `[Noise]` | Noise |
| `[Music]` | Music |
| `[Human Sounds]` | Sounds people make that are not words |
| `[Environmental Sounds]` | Sounds of the surroundings |
| `[Unintelligible Speech]` | Speech the model cannot make out |

Recordings with pauses between sentences get a few tags per request, most of them `[Silence]`. In `verbose_json`, a tag between sentences is usually a segment of its own, without a `speaker`:

```json
{"id": 1, "start": 9.38, "end": 10.02, "text": "[Silence]"}
```

The tags are kept by default. To remove them, send `remove_nonspeech_tags=true`:

```bash
curl https://api.serenityedge.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $SERENITY_EDGE_API_KEY" \
  -F model=vibevoice-asr \
  -F file=@meeting.mp3 \
  -F remove_nonspeech_tags=true
```

```python
transcript = client.audio.transcriptions.create(
    model="vibevoice-asr",
    file=audio,
    extra_body={"remove_nonspeech_tags": True},
)
```

With `remove_nonspeech_tags=true`:

-   **Text.** The six tags above leave the text of every format, in any letter case, together with the spaces around them: `on time. [Silence] The next` becomes `on time. The next`. Other text in square brackets is kept.
-   **Segments.** In `verbose_json`, a segment that held only tags is left out, and the segments are numbered again from 0. The others keep their start, end and speaker.
-   **Billing.** It does not change: it follows the duration of the audio. A file without speech comes back with an empty transcript and is billed.

Any value other than `true` or `false` is refused with `400`.

### Long files

A file that takes more than about 20 seconds to transcribe still gets its answer on the same connection. The answer starts with `200 OK` and blank lines while the transcription runs, and the transcript follows. JSON parsers, the OpenAI SDKs among them, skip the blank lines. With `text`, trim them.

If the transcription fails after the answer has started, a JSON answer carries the [error object](https://docs.serenityedge.ai/docs/errors-and-rate-limits/) instead of a transcript. On `text`, the connection is closed before the end, so an error is never taken for a transcript.

## Audio files

-   **Formats**: FLAC, M4A and MP4, MP3, Ogg (Vorbis and Opus), WAV and WebM. The format is read from the file itself, not from its name.
-   **Size**: up to 16 MiB per request. That is about 8 minutes of 16 kHz WAV, or about an hour of 32 kb/s Opus. Compress long recordings, or split them.
-   **Length**: up to 5 minutes of audio per request. Longer files are refused with `400` before anything is billed, when their duration can be read from the file. Split longer recordings into several requests.

## Quality and speed

These are the results of our tests in November 2026. We used read speech from the FLEURS test set, joined into files of 10 seconds to 5 minutes, and sent one request at a time from a client in Spain.

-   **Word error rate.** Spanish and English both came out at about 7 to 9 %.
    
    -   With the tags kept, it was about 9 % in Spanish and 8 % in English. With `remove_nonspeech_tags=true`, it was about 7 % in both.
    -   Much of the rest is numbers: the model often spells out what a reference writes in digits (`two thousand five` for `2005`), and the score counts that as an error. Rare proper nouns account for most of what remains.
    -   The same file can come back with small differences between requests, such as a number in digits or in words.
-   **Time to the answer**, upload included:
    
    | Audio | Answer in |
    | --- | --- |
    | 10 seconds | about 1.5 seconds |
    | 30 seconds to 1 minute | 3 to 7 seconds |
    | 2 minutes | 11 to 15 seconds |
    | 5 minutes | 21 to 24 seconds |
    
    Time follows the amount of speech more than the length of the file. A 5-minute file usually takes long enough to start with the blank lines described in [Long files](https://docs.serenityedge.ai/docs/audio-transcriptions/#long-files).
    
-   **Limits.** 5 minutes of audio and a 16 MiB body per request (see [Audio files](https://docs.serenityedge.ai/docs/audio-transcriptions/#audio-files)).
    

## Billing

Each request is billed by the duration of its audio, in seconds, rounded up, at least one second. The `usage.seconds` of the answer is what was billed. Output is not billed separately.

-   The duration comes from the file's own headers. For a file whose headers do not state it (some WebM recordings), it is the duration the model measures, else the end of the last segment.
-   A request that ends in an error is not billed. Neither is one for which the model returns no transcript at all. A transcript that is empty only because `remove_nonspeech_tags` removed its tags is billed.

The price is read from `GET /v1/models?format=openai` when this page is published and again when you open it. It is in US dollars per second of audio, listed with the model under `audio_pricing.per_second`.

| Model id | Per second of audio |
| --- | --- |
| `vibevoice-asr`, also `microsoft/vibevoice-asr` | $0.000047 |

Read from the API (`GET /v1/models?format=openai`) when this page was published, on 20 November 2026, 14:40 UTC.

## Data handling

Audio, transcripts and prompts are processed in memory to answer the request and are not stored or logged. Requests are served in the European Union. See [Data residency and privacy](https://docs.serenityedge.ai/docs/data-residency/).

## Errors

The errors are those of every route ([Errors and rate limits](https://docs.serenityedge.ai/docs/errors-and-rate-limits/)), with these of their own:

| Status | When |
| --- | --- |
| `400` | No `file` or `model`, an audio format that is not supported, a file longer than the limit, `srt` or `vtt`, word timestamps, a `remove_nonspeech_tags` other than `true` or `false`, or a field out of range. `param` names the field. |
| `404` | An unknown model. |
| `413` | A file or body over 16 MiB. |
| `429` | The model is at capacity. Retry after the `Retry-After` seconds. |
| `500` with code `timeout` | The file took too long to transcribe. Split it into shorter requests. |
