Audio & embeddings

Text-to-speech (TTS), speech recognition (ASR) and text embeddings.

Text-to-speech (TTS)

POST https://api.onefast.ai/v1/audio/speech

Returns the audio as a binary stream.

cURL

curl https://api.onefast.ai/v1/audio/speech \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "speech-2.8-turbo",
    "input": "Hello, and welcome to our service.",
    "voice": "male-qn-qingse",
    "response_format": "mp3"
  }' --output speech.mp3

Python

from openai import OpenAI

client = OpenAI(api_key="sk-xxx", base_url="https://api.onefast.ai/v1")
with client.audio.speech.with_streaming_response.create(
    model="speech-2.8-turbo",
    input="Hello, and welcome to our service.",
    voice="male-qn-qingse",
    response_format="mp3",
) as resp:
    resp.stream_to_file("speech.mp3")

• Billed by character count; each Chinese, Japanese or Korean character counts as 2 characters. The model catalog lists prices per 10K characters.
• If you pass an OpenAI voice name (such as alloy), the default English voice is used.
• OpenAI model names work as-is: tts-1 and gpt-4o-mini-tts map to speech-2.8-turbo, and tts-1-hd maps to speech-2.8-hd. Existing OpenAI SDK code only needs a new base_url and key.
• Unsupported formats such as opus / aac are returned as mp3.

Gemini text-to-speech

gemini-3.8-flash-tts and gemini-3.8-flash-lite-tts can be called through either of two endpoints.

Option 1: OpenAI-compatible endpoint (existing OpenAI SDK code only needs the model name changed)

cURL

curl https://api.onefast.ai/v1/audio/speech \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": "Have a wonderful day!",
    "voice": "Kore",
    "instructions": "Say cheerfully",
    "response_format": "wav"
  }' --output speech.wav

Option 2: Gemini native endpoint (request and response match the official Google API; the audio is base64-encoded in candidates[0].content.parts[0].inlineData)

cURL

curl "https://api.onefast.ai/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "Joe: How is it going today, Jane?\nJane: Not too bad, how about you?"}]}],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {"speaker": "Joe", "voiceConfig": {"prebuiltVoiceConfig": {"voiceName": "Kore"}}},
            {"speaker": "Jane", "voiceConfig": {"prebuiltVoiceConfig": {"voiceName": "Puck"}}}
          ]
        }
      }
    }
  }'

• On the native endpoint, inlineData.mimeType may be audio/wav (WAV header included) or audio/L16;codec=pcm;rate=24000 (raw PCM; add a WAV header yourself or convert with ffmpeg -f s16le -ar 24000 -ac 1 -i out.pcm out.wav). The OpenAI-compatible endpoint handles both and always returns playable wav.
• Billed by tokens: input text at the input price, generated audio at the output price (about 25 tokens per second of audio), based on the usage reported upstream. The per-minute price in the model catalog is an estimate based on 25 tokens of audio output per second, excludes input text, and is for reference only.
• Requests blocked by the content safety policy return 400 and are not billed.

Doubao speech synthesis (Seed TTS 2.0)^Beta

Beta: ready for production calls; parameters and default voices may still be fine-tuned.

Model doubao-seed-tts-2-0, called through the same /v1/audio/speech endpoint; existing OpenAI SDK code only needs the model name changed.

cURL

curl https://api.onefast.ai/v1/audio/speech \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seed-tts-2-0",
    "input": "Добрый день! Рады видеть вас снова.",
    "response_format": "mp3"
  }' --output speech.mp3

• Billed by character count: spaces and punctuation count, and every Chinese, English or Russian character counts as 1 (unlike the speech-* models above, where each CJK character counts as 2). The model catalog lists prices per 10K characters.
• An input that is empty or contains only punctuation and symbols returns 400 and is not billed.

Speech recognition (ASR)

POST https://api.onefast.ai/v1/audio/transcriptions

Compatible with the OpenAI transcription API. Upload an audio file (multipart/form-data) and get the recognized text back.

cURL

curl https://api.onefast.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $API_KEY" \
  -F model="asr-1.0" \
  -F file="@meeting.mp3" \
  -F response_format="json"

Python

from openai import OpenAI

client = OpenAI(api_key="sk-xxx", base_url="https://api.onefast.ai/v1")
result = client.audio.transcriptions.create(
    model="asr-1.0",
    file=open("meeting.mp3", "rb"),
)
print(result.text)

What each response_format returns:

Streaming events use the same format as OpenAI:

data: {"type":"transcript.text.delta","delta":"Hello"}

data: {"type":"transcript.text.done","text":"Hello everyone","usage":{"type":"duration","seconds":7,"input_tokens":117}}

• Billed by audio duration (seconds, rounded up), based on the duration in the result. The model catalog lists prices per minute.
• Split audio longer than 500 seconds before uploading. Speech recognition does not need high sample rates: 16 kHz mono or a compressed format gives the same accuracy.
• /v1/audio/translations (speech translation) is not supported.

Doubao speech recognition (Seed ASR 2.0)^Beta

Beta: ready for production calls; parameters may still be fine-tuned.

Model doubao-seed-asr-2-0, also via /v1/audio/transcriptions:

cURL

curl https://api.onefast.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $API_KEY" \
  -F model="doubao-seed-asr-2-0" \
  -F file="@meeting.mp3" \
  -F language="ru" \
  -F response_format="verbose_json"

• Billed by audio duration (seconds, rounded up). The model catalog lists prices per minute.
• Streaming (stream) and /v1/audio/translations are not supported.

MiniMax-compatible endpoints

Code already written against the official MiniMax documentation works by changing only the domain and key. Request and response formats are unchanged.

Text-to-speech (sync)

POST https://api.onefast.ai/v1/t2a_v2

cURL

curl https://api.onefast.ai/v1/t2a_v2 \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "speech-2.8-hd",
    "text": "Hello, welcome to our service.",
    "stream": false,
    "voice_setting": {"voice_id": "English_expressive_narrator", "speed": 1, "emotion": "happy"},
    "audio_setting": {"format": "mp3", "sample_rate": 32000}
  }'

• Returns JSON. The audio is in data.audio, hex-encoded; usage is in extra_info.usage_characters.
• stream: true is supported (SSE chunks of hex audio; the last frame has data.status = 2 and the full usage).
• Fields such as voice_setting, audio_setting, pronunciation_dict, language_boost and voice_modify work as documented.
• output_format is always hex (no audio download URLs) and subtitle_enable is not available. wav / flac / pcm accept at most 2,000 characters per request.

Speech recognition

POST https://api.onefast.ai/v1/speech_to_text

cURL

curl https://api.onefast.ai/v1/speech_to_text \
  -H "Authorization: Bearer $API_KEY" \
  -H "language: en" \
  -F model="asr-1.0" \
  -F file="@meeting.mp3" \
  -F response_format="verbose_json" \
  -F timestamp_level="word"

• The language hint goes in the language request header (optional; detected automatically if omitted).
• response_format supports json / verbose_json / srt / vtt; timestamp_level supports sentence (default) / word. With stream: true, results come back as SSE events {"index","delta","finish","duration"}.
• File limits and billing are the same as in Speech recognition (ASR) above.

Text embeddings

POST https://api.onefast.ai/v1/embeddings

cURL

curl https://api.onefast.ai/v1/embeddings \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "text-embedding-3-small", "input": "The food was delicious."}'

Python

emb = client.embeddings.create(model="text-embedding-3-small", input=["First passage", "Second passage"])
print(len(emb.data), len(emb.data[0].embedding))

Billed by input tokens.