Audio
Zabio transcribes audio through POST /v1/audio/transcriptions and turns text into speech through POST /v1/audio/speech, in the shape OpenAI’s SDKs already send. Change base_url and your key, keep the rest.
For the exact shape of every request and response, with curl, Python and Node examples, see the API reference. Audio inside a chat request (an input_audio part the model listens to and answers in text) is on the Chat completions page.
Transcription
Section titled “Transcription”Send an audio file and get its text back. The key needs the chat scope (keys have it by default).
curl https://api.zabio.ai/v1/audio/transcriptions \ -H "Authorization: Bearer insert your zabio.ai key here" \ -F file=@meeting.mp3 \ -F model=auto{ "text": "Good morning, let us start with the numbers.", "usage": {"type": "duration", "seconds": 20.4}, "zabio": {"call_id": "call_...", "vendor": "deepinfra", "model_served": "voxtral-mini-3b-2507", "cost_micros": 357, "units": {"kind": "audio_second", "seconds": 20.4, "estimated": false}}}Models
Section titled “Models”| Model | Maker | Price per minute | Formats | Notes |
|---|---|---|---|---|
gpt-transcribe |
OpenAI | 0.0045 | json, text; streams | OpenAI’s recommended model; takes several expected languages |
whisper-1 |
OpenAI | 0.006 | json, text, verbose_json, srt, vtt; word timestamps | retires on 2027-02-26 (OpenAI’s date) |
gpt-4o-transcribe, gpt-4o-mini-transcribe |
OpenAI | billed in audio tokens (2.50 and 1.25 per million; about 0.006 and 0.003 per minute, OpenAI’s estimate) | json, text | retire on 2027-02-26 (OpenAI’s date) |
whisper-large-v3 |
OpenAI, served by Together AI | 0.0015 | json, text, verbose_json, srt, vtt; word timestamps | up to 4 hours of audio |
voxtral-mini-3b-2507, voxtral-small-24b-2507 |
Mistral AI, served by DeepInfra | 0.001 and 0.003 | json, text, verbose_json | English, Spanish, French, Portuguese, Hindi, German, Dutch and Italian; up to 30 minutes |
gemini-3.5-transcribe |
billed in audio tokens (2.00 per million; about 0.003 per minute, Google’s estimate at 25 tokens per second) plus 12.00 per million output tokens | json, text, verbose_json, srt, vtt; word timestamps | 85 or more locales; up to 30 minutes; a prompt becomes custom vocabulary when no timestamps are asked |
|
scribe-v2 |
ElevenLabs | 0.0037 (0.22 per hour) | json, text, verbose_json, srt, vtt; word timestamps | 90 or more languages; up to 10 hours |
scribe-v2-medical |
ElevenLabs | 0.0037 (0.22 per hour) | json, text, verbose_json, srt, vtt; word timestamps | ElevenLabs’ model for clinical audio, with the same request and languages as scribe-v2; up to 10 hours. Zabio is not a HIPAA business associate and signs no business associate agreement. Do not send protected health information through Zabio |
nova-3, nova-3-multilingual |
Deepgram | 0.0043 and 0.0052 | json, text, verbose_json, srt, vtt; word timestamps | about 60 languages, or code-switching across about 50 with the multilingual model; billed per second; prompt and temperature are not sent |
whisper-large |
Deepgram | 0.0048 | json, text, verbose_json, srt, vtt; word timestamps | OpenAI’s Whisper large model run by Deepgram; Whisper’s languages, detected when you name none; Deepgram stops a call after 10 minutes of processing; billed per second |
Prices are the provider’s list prices in USD; the plan fee applies on top (see Billing). GET /v1/models lists every transcription model with zabio.kind: "transcription", its unit and its formats, and the models page shows where each one is processed.
model: auto picks the cheapest transcription model able to do what your request asks: the language you name, the timestamps and the format. There is no quality bar yet, so auto, auto/cheap, auto/balanced and auto/best all pick the same model on this endpoint. If the chosen model fails, Zabio tries the next one at the same vendor, and at other vendors when the key’s fallback setting allows it. An auto call pays the price of automatic model choice (at most 0.00025 USD) like any other auto call.
Request
Section titled “Request”Multipart form data, as OpenAI.
| Field | Notes |
|---|---|
file |
required; mp3, mp4, mpeg, mpga, m4a, wav, webm, flac or ogg; 25 MB at most |
model |
a transcription model or auto (the default when absent) |
language |
ISO 639-1 code of the audio; detected when absent |
languages |
several expected languages, for the models that take them (gpt-transcribe); the first is sent to the others |
prompt |
context for the model: names, spelling, style |
response_format |
json (default), text, verbose_json, srt or vtt. Zabio renders srt and vtt from the model’s segment timestamps, so a model that returns no segments cannot serve them (400 unsupported_value) |
timestamp_granularities |
segment, word; with verbose_json |
stream |
true streams transcript.text.delta and transcript.text.done events as OpenAI does, with json format. A model that does not stream answers with the whole text in one done event at the end |
temperature |
0 to 1 |
Response
Section titled “Response”json returns text, the detected language where the model reports it, as an ISO 639-1 code on every model, usage and the zabio object. verbose_json adds task, duration, segments and, when asked, words. text, srt and vtt return the file as text/plain.
The zabio object carries call_id, vendor, model_served, cost_micros (what the call cost you, fee included) and units: the seconds of audio billed, and estimated: true when the vendor reported no duration and Zabio read it from the file’s header.
Streaming as events (stream_format: sse)
Section titled “Streaming as events (stream_format: sse)”With stream_format set to sse, the answer is text/event-stream in OpenAI’s shape instead of the bytes. Each event is one data: line followed by a blank line:
data: {"type":"speech.audio.delta","audio":"<base64 audio>"}data: {"type":"speech.audio.done","usage":{"input_tokens":20,"output_tokens":162,"total_tokens":182},"zabio":{"call_id":"call_...","vendor":"openai","model_served":"gpt-4o-mini-tts","cost_micros":2054,"units":{"kind":"token","text_input_tokens":20,"audio_output_tokens":162}}}data: [DONE]speech.audio.deltacarries the next piece of audio, base64 encoded, in theresponse_formatyou asked for. Decode each piece and join them in order to get the file. The first piece goes out as soon as the model sends audio, on every model. On the Gemini models, the first piece comes about a second after the request withresponse_format: pcm. Withwav, Zabio waits for the model’s whole answer before the first piece, which keeps the model’s content credentials in the file.speech.audio.donecomes once, after the last piece.usageis always there: the text input and audio output tokens on the models billed in tokens, and zeros on the models billed per character, whose count is inzabio.unitsinstead ({"kind":"character","characters":312}).zabiocarries what the headers carry on theaudioform:call_id,vendor,model_served,cost_micros(what the call cost you, fee included),units,byokandretires_atwhere they apply, andfinish_reason: "length"when the model stopped before the end of the input. The response headers carryx-zabio-call-id,x-zabio-vendorandx-zabio-model-servedbut not the cost, which is only known at the end.- If the model fails after the first piece, the stream ends with
data: {"type":"error","error":{"message":"...","type":"...","code":"..."}}anddata: [DONE], with nospeech.audio.done, and the call is not billed. A failure before the first piece is answered with an error status, as on theaudioform, after Zabio has tried the next model where it can.
tts-1 and tts-1-hd take sse too: OpenAI streams them as bytes and Zabio turns the bytes into events.
What is billed
Section titled “What is billed”A minute of audio at the model’s price, plus the plan fee. The vendor’s own count of seconds or tokens is what Zabio bills; when a vendor reports none, Zabio reads the length from the file’s header, rounded up to the second, and marks it estimated. Models billed in audio tokens are billed on the tokens the vendor reports. A call that fails at the vendor is not billed. Your own OpenAI, Google, Together AI or DeepInfra key serves your named calls at no charge from Zabio (ElevenLabs and Deepgram own keys are not accepted yet); auto always runs on Zabio’s keys and needs credit. Before a call that needs credit reaches the model, its estimated cost (the file’s length at the dearest model that may serve it, fee included) is set aside on your balance until the call ends. A call whose estimate does not fit the balance left after the calls still in flight is refused with 402 insufficient_credits; the message names the estimate, the balance and the least amount to add. When the file’s header does not give its length, the estimate is taken from the file’s size as speech at 16 kbit/s, the longest such a file plausibly is, so it can be well above the bill; the bill is always the real length. While your organization runs on trial credit alone, the estimate uses the longer of two lengths: the one the file’s header states, and the file’s size as speech at 16 kbit/s. A file encoded above 16 kbit/s is then estimated above its bill (about eight times for a 128 kbit/s MP3, sixteen times for a 16 kHz mono WAV); the bill is still the real length, and what was set aside beyond it returns to your balance when the call ends. An organization that has added credit is estimated on the header’s length.
What is stored
Section titled “What is stored”The audio file is sent to the vendor and dropped when the call ends: never written to a database, never logged. Zabio keeps the call’s metadata (model, vendor, seconds, cost) as for any call. If the key has body logging on, the transcript text and a reference to the media (type, size, seconds) are stored encrypted under your organization’s retention, never the audio. See Privacy.
Limits and errors
Section titled “Limits and errors”The key’s requests per minute limit applies (the token limit does not count audio). Spend limits, member quotas and the balance apply as on every call. A file above the cap returns 413 media_too_large; a file that is not audio returns 400 unsupported_format; a model named on this endpoint that is not a transcription model returns 400 unsupported_for_model. See Errors.
Python
Section titled “Python”from openai import OpenAI
client = OpenAI(base_url="https://api.zabio.ai/v1", api_key="insert your zabio.ai key here")with open("meeting.mp3", "rb") as f: res = client.audio.transcriptions.create(model="auto", file=f, response_format="json")print(res.text, res.model_extra["zabio"]["cost_micros"])Speech
Section titled “Speech”Send text and get audio back. The key needs the chat scope. The voices are AI-generated: tell your own users so where you play them, as the vendors’ terms require.
curl https://api.zabio.ai/v1/audio/speech \ -H "Authorization: Bearer insert your zabio.ai key here" \ -H "Content-Type: application/json" \ -d '{"model": "auto", "input": "Good morning, let us start with the numbers.", "response_format": "mp3"}' \ --output morning.mp3The answer is the audio itself, sent in chunks as the model produces it, with the right Content-Type. Because the body is audio, the zabio fields come as response headers:
Content-Type: audio/mpegx-zabio-call-id: call_...x-zabio-vendor: togetherx-zabio-model-served: kokoro-82mx-zabio-cost-micros: 189x-zabio-units: character=45Models
Section titled “Models”| Model | Maker | Price | Formats | Voices | Notes |
|---|---|---|---|---|---|
kokoro-82m |
Hexgrad, served by Together AI | 4.00 per million characters | mp3, wav, pcm | 54, such as af_heart, am_adam, bf_emma; the prefix names the language and gender |
the cheapest mp3; eight languages |
aura-2 |
Deepgram | 30.00 per million characters | mp3, opus, flac, wav, pcm | the Aura-2 voices, aura-2-thalia-en, aura-2-sirio-es and the rest, in English, Spanish, Dutch, French, German, Italian and Japanese |
2,000 characters at most per request |
aura-1 |
Deepgram | 15.00 per million characters | mp3, opus, flac, wav, pcm | the 12 Aura-1 voices, aura-asteria-en, aura-luna-en and the rest |
English only, so auto never picks it; 2,000 characters at most per request |
flux-tts |
Deepgram | 45.00 per million characters | mp3, opus, flac, wav, pcm | 266 Flux voices, flux-hannah-en, flux-carmen-es and the rest; the suffix names the language: English and 41 more, of which Deepgram marks all but Dutch, French, German, Hindi, Italian, Japanese, Portuguese, Russian and Spanish as early access |
speed from 0.5 to 1.5, and not in every language: Deepgram refuses the rest with a 400 |
eleven-v4, eleven-v4-turbo |
ElevenLabs | 80.00 and 40.00 per million characters | mp3, opus, wav, pcm | ElevenLabs’ default library, 19 voices by voice id, JBFqnCBsd6RMkjVDRZzb (George) and the rest; see ElevenLabs voices |
90 or more languages; eleven-v4 takes 10,000 characters at most, which the endpoint’s own cap of 4,096 already keeps |
eleven-v3, eleven-v3-conversational |
ElevenLabs | 80.00 and 40.00 per million characters | mp3, opus, wav, pcm | the same 19 voices | 70 or more languages; eleven-v3 takes 5,000 characters at most |
eleven-multilingual-v2 |
ElevenLabs | 80.00 per million characters | mp3, opus, wav, pcm | the same 19 voices | 29 languages |
eleven-flash-v2.5, eleven-flash-v2 |
ElevenLabs | 40.00 per million characters | mp3, opus, wav, pcm | the same 19 voices | eleven-flash-v2.5 speaks 32 languages; eleven-flash-v2 speaks English only, so auto never picks it |
gemini-3.8-flash-tts, gemini-3.8-flash-lite-tts |
billed in tokens: text in at 0.50 per million, audio out at 9.00 and 6.00 per million (about 0.00225 and 0.0015 per 10 seconds of audio, Google’s estimate at 25 tokens per second); these prices double on 2027-01-01, as Google’s page states | wav, pcm | 30 prebuilt voices, Kore, Puck, Zephyr and the rest |
over 130 languages, detected; instructions becomes the style |
|
gpt-4o-mini-tts |
OpenAI | billed in tokens: text in at 0.60, audio out at 12.00 per million | mp3, opus, aac, flac, wav, pcm | marin, cedar, alloy, ash, ballad, coral, echo, fable, nova, onyx, sage, shimmer, verse |
takes instructions; by name only, shuts down on 2027-01-06 (OpenAI’s date) |
tts-1, tts-1-hd |
OpenAI | 15.00 and 30.00 per million characters | mp3, opus, aac, flac, wav, pcm | alloy, ash, coral, echo, fable, onyx, nova, sage, shimmer |
by name only, shut down on 2027-01-06 (OpenAI’s date) |
Prices are the provider’s list prices in USD; the plan fee applies on top (see Billing). GET /v1/models lists every speech model with zabio.kind: "speech", its unit, its formats and its voices under zabio.media, and the models page shows where each one is processed.
Nothing is transcoded: each model returns the formats its vendor produces, so a request for aac or flac is served by Deepgram or OpenAI, and one for wav or pcm by any of them. pcm is raw 16-bit little-endian samples at 24 kHz with no header, on every model. opus comes in an Ogg container; the Content-Type is the vendor’s (audio/opus from OpenAI and ElevenLabs, audio/ogg from Deepgram).
ElevenLabs voices
Section titled “ElevenLabs voices”Every ElevenLabs model takes these 19 voices from ElevenLabs’ default library. Send the voice id as voice; the name, gender and accent are ElevenLabs’ own (ElevenLabs’ voice list, read 2026-11-04), and the description is a short summary of theirs. George is the default.
| Voice id | Name | Gender | Accent | Description |
|---|---|---|---|---|
JBFqnCBsd6RMkjVDRZzb |
George | male | British | warm storyteller |
21m00Tcm4TlvDq8ikWAM |
Janet | not labelled | American English | professional voice |
EXAVITQu4vr4xnSDxMaL |
Sarah | female | American | mature and reassuring |
FGY2WhTYpPnrIDTdsKH5 |
Laura | female | American | enthusiastic and quirky |
IKne3meq5aSn9XLyUdCD |
Charlie | male | Australian | deep and energetic |
N2lVS1w4EtoT3dr4eOWO |
Callum | male | American | husky and playful |
SAz9YHcvj6GT2YYXdXww |
River | neutral | American | relaxed and informative |
TX3LPaxmHKxFdv7VOQHJ |
Liam | male | American | energetic, for social media |
XB0fDUnXU5powFXDhCwa |
Helen | not labelled | British English | professional voice |
Xb7hH8MSUJpSbSDYk0k2 |
Alice | female | British | clear educator |
XrExE9yKIg1WjnnlVkGX |
Matilda | female | American | knowledgeable and professional |
bIHbv24MWmeRgasZH58o |
Will | male | American | relaxed and optimistic |
cgSgspJ2msm6clMCkdW9 |
Jessica | female | American | playful and bright |
cjVigY5qzO86Huf0OWal |
Eric | male | American | smooth and trustworthy |
iP95p4xoKVk53GoZ742B |
Chris | male | American | charming and down to earth |
nPczCjzI2devNBz1zQrb |
Brian | male | American | deep and comforting |
onwK4e9ZLuTAKqWW03F9 |
Daniel | male | British | steady broadcaster |
pFZP5JQG7iQjIQuC4Bku |
Lily | female | British | velvety actress |
pqHfZKP75CvOlQylNhV4 |
Bill | male | American | wise and balanced |
model: auto picks the cheapest speech model that offers the format you ask for and, if you name one, the voice; without a voice, each model speaks with its default (the first in its list). There is no quality bar yet, so auto, auto/cheap, auto/balanced and auto/best all pick the same model on this endpoint. If the chosen model fails before the first byte, Zabio tries the next one at the same vendor, and at other vendors when the key’s fallback setting allows it, during the first 40 seconds of the request. An auto call pays the price of automatic model choice (at most 0.00025 USD) like any other auto call. The three OpenAI models are never picked by auto, since they shut down in January. Nor are the models that speak English only (aura-1, eleven-flash-v2): a speech request does not say its language, so auto keeps to the models that speak any language their vendor lists, and a fallback from a model you name never moves to one that speaks fewer languages. Name an English-only model to use it.
Request
Section titled “Request”JSON, as OpenAI.
| Field | Notes |
|---|---|
input |
required; the text to speak, 4,096 characters at most |
model |
a speech model or auto (the default when absent) |
voice |
a voice the model lists; the model’s default when absent. A voice the model does not have returns 400 unsupported_value |
response_format |
mp3 (default), opus, aac, flac, wav or pcm. A format the model does not produce returns 400 unsupported_value |
speed |
0.25 to 4; the model’s default when absent. Models without a speed setting ignore it; a model with a narrower range refuses a value outside it with 400 (flux-tts: 0.5 to 1.5) |
instructions |
style guidance for the models that take it (gpt-4o-mini-tts, the Gemini models); the others ignore it; 4,096 characters at most |
stream_format |
audio (the default): the audio bytes. sse: server-sent events with the audio in base64, on every speech model (see below) |
Response
Section titled “Response”The audio, chunked, with Content-Type set to what the model returned. The headers carry what the zabio object carries elsewhere: x-zabio-call-id, x-zabio-vendor, x-zabio-model-served, x-zabio-cost-micros (what the call cost you, fee included) and x-zabio-units (character=312 on a model billed per character; text_input_token=80, audio_output_token=1250 on one billed in tokens), and x-zabio-finish-reason: length when the model stopped before the end of the input.
What is billed
Section titled “What is billed”The characters of your input at the model’s price per million characters, plus the plan fee; or, on the Gemini and gpt-4o-mini-tts models, the text input and audio output tokens the vendor reports. A character is a Unicode code point. Where a vendor reports its own count of characters (Deepgram), that count is billed. A call that fails at the vendor before the first byte is not billed; a stream that breaks after the first byte is not billed either. A call you hang up on before the end is billed, since the vendor speaks the whole text either way. A Gemini speech model can stop before the end of a long input. The audio it made is billed, and the answer says so: finish_reason length in the zabio object with stream_format: sse, the header x-zabio-finish-reason: length on the audio form. Your own OpenAI, Google or Together AI key serves your named calls at no charge from Zabio (ElevenLabs and Deepgram own keys are not accepted yet); auto always runs on Zabio’s keys and needs credit. Before a call that needs credit reaches the model, its estimated cost (the characters at the dearest model that may serve the request, fee included) is set aside on your balance until the call ends. A call whose estimate does not fit the balance left after the calls still in flight is refused with 402 insufficient_credits; the message names the estimate, the balance and the least amount to add.
What is stored
Section titled “What is stored”The audio is streamed to you and kept nowhere: never written to a database, never logged. Zabio keeps the call’s metadata (model, vendor, characters or tokens, cost) as for any call. If the key has body logging on, the input text and a reference to the media (type, bytes, characters) are stored encrypted under your organization’s retention, never the audio. See Privacy.
Limits and errors
Section titled “Limits and errors”The key’s requests per minute limit applies (the token limit does not count characters). Spend limits, member quotas and the balance apply as on every call. An input above 4,096 characters returns 400 invalid_value; a model named on this endpoint that is not a speech model returns 400 unsupported_for_model. See Errors.
Python
Section titled “Python”from openai import OpenAI
client = OpenAI(base_url="https://api.zabio.ai/v1", api_key="insert your zabio.ai key here")with client.audio.speech.with_streaming_response.create(model="auto", input="Good morning.", response_format="mp3") as res: res.stream_to_file("morning.mp3") print(res.headers["x-zabio-model-served"], res.headers["x-zabio-cost-micros"])With events:
import base64, json, requests
res = requests.post("https://api.zabio.ai/v1/audio/speech", stream=True, headers={"Authorization": "Bearer insert your zabio.ai key here"}, json={"model": "auto", "input": "Good morning.", "stream_format": "sse"})with open("morning.mp3", "wb") as out: for line in res.iter_lines(): if not line.startswith(b"data: ") or line == b"data: [DONE]": continue event = json.loads(line[6:]) if event["type"] == "speech.audio.delta": out.write(base64.b64decode(event["audio"])) elif event["type"] == "speech.audio.done": print(event["zabio"]["model_served"], event["zabio"]["cost_micros"]) elif event["type"] == "error": raise RuntimeError(event["error"]["message"])zabio speak -o morning.mp3 "Good morning." writes the file and prints the model, the vendor and the cost; --model, --voice, --format and --speed as above.