Skip to content
Zabio is in beta: models, prices and features can change. Tell us what breaks at hello@zabio.ai.

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.

Send an audio file and get its text back. The key needs the chat scope (keys have it by default).

Terminal window
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}}
}
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 Google 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.

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

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.

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.delta carries the next piece of audio, base64 encoded, in the response_format you 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 with response_format: pcm. With wav, Zabio waits for the model’s whole answer before the first piece, which keeps the model’s content credentials in the file.
  • speech.audio.done comes once, after the last piece. usage is 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 in zabio.units instead ({"kind":"character","characters":312}).
  • zabio carries what the headers carry on the audio form: call_id, vendor, model_served, cost_micros (what the call cost you, fee included), units, byok and retires_at where they apply, and finish_reason: "length" when the model stopped before the end of the input. The response headers carry x-zabio-call-id, x-zabio-vendor and x-zabio-model-served but 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":"..."}} and data: [DONE], with no speech.audio.done, and the call is not billed. A failure before the first piece is answered with an error status, as on the audio form, 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.

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.

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.

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.

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"])

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.

Terminal window
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.mp3

The 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/mpeg
x-zabio-call-id: call_...
x-zabio-vendor: together
x-zabio-model-served: kokoro-82m
x-zabio-cost-micros: 189
x-zabio-units: character=45
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 Google 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).

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.

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)

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.

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.

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.

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.

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.