Nano Banana 2.1 is LIVE — Google's Latest | Try Now →

wavespeed-ai/openai-whisper-turbo

Accurate speech-to-text with OpenAI Whisper Large v3 Turbo: multilingual transcripts with auto language detection and punctuation. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

Speech to Text
Input

Drag & drop or click to upload

Loading…
Enable to generate word-level timestamps for the transcription. Note: This may increase processing time.

Idle

{
  "text": "Welcome to WaveSpeed AI."
}

$0.0007per run·~1428 / $1

ExamplesView all

Related Models

README

OpenAI Whisper Turbo

OpenAI Whisper Turbo is a fast, accurate speech-to-text transcription model powered by OpenAI's Whisper architecture. It converts audio into clean, readable text with support for multiple languages — ideal for transcription, subtitling, and voice-driven workflows.

Why It Stands Out

  • High-speed transcription: Optimized for fast processing without sacrificing accuracy.
  • Multilingual support: Transcribe audio in dozens of languages with automatic language detection.
  • Word-level timestamps: Generate precise timing data for subtitle alignment and editing workflows.
  • Prompt-guided transcription: Steer output formatting, terminology, or punctuation with custom prompts.
  • Prompt Enhancer: Built-in AI-powered prompt optimization for better transcription guidance.
  • Flexible input: Supports direct audio upload or public URL.

Parameters

ParameterRequiredDescription
audioYesUpload or link to an audio file (MP3 / WAV / M4A, etc.).
languageNoLanguage code for transcription; leave empty for auto-detection.
enable_timestampsNoGenerate word-level timestamps (may increase processing time).
promptNoShort guidance text to steer transcription style or terminology.
enable_sync_modeNoWait for result before returning response (API only).

How to Use

  1. Upload your audio — drag and drop a file or paste a public URL.
  2. Select language (optional) — choose a specific language or let the model auto-detect.
  3. Enable timestamps (optional) — turn on for word-level timing data.
  4. Add a prompt (optional) — guide formatting, punctuation, or specific terminology.
  5. Click Run and wait for transcription to complete.
  6. Copy or download the transcribed text.

Best Use Cases

  • Meeting Transcription — Convert recorded meetings, interviews, and calls into searchable text.
  • Subtitle Generation — Create accurate transcripts for video subtitling workflows.
  • Content Repurposing — Turn podcasts, webinars, and lectures into written content.
  • Voice Notes — Quickly transcribe voice memos and audio notes.
  • Accessibility — Generate transcripts to make audio content accessible.

Pricing

ModePrice
Standard (no timestamps)$0.0007 / s
With timestamps enabled$0.0014 / s

Total cost = duration of audio (in seconds) × price per second

Examples

  • 60s audio (standard) → 60 × $0.0007 = $0.042
  • 60s audio (with timestamps) → 60 × $0.0014 = $0.084
  • 10 min (600s) audio (standard) → 600 × $0.0007 = $0.42
  • 10 min (600s) audio (with timestamps) → 600 × $0.0014 = $0.84

Pro Tips for Best Quality

  • Use clear audio with minimal background noise for optimal accuracy.
  • Specify the language if auto-detection is inconsistent.
  • Enable timestamps only when needed for subtitles or alignment — it doubles the cost.
  • Add a prompt to guide transcription — include names, jargon, or formatting preferences.
  • For long recordings, consider splitting into smaller segments for faster processing.

Notes

  • Ensure uploaded audio URLs are publicly accessible.
  • Transcription only: output stays in the source language. For translation to English, use OpenAI Whisper.
  • Timestamps are best for subtitles and editing, but may take longer to process.
  • Processing time varies based on audio duration and current queue load.

Duration limit

The maximum supported audio duration is 10 minutes. Longer audio is automatically trimmed to 10 minutes before processing.

Note:This website uses AI models provided by third parties. Documentation prices are for reference and may be outdated. The Generate button shows an estimate; the final task charge prevails.

Openai Whisper Turbo API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/wavespeed-ai/openai-whisper-turbo with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for Openai Whisper Turbo below.

HTTP example
set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "audio": "https://interactive-examples.mdn.mozilla.net/media/cc0-audio/t-rex-roar.mp3",
    "language": "auto",
    "enable_timestamps": false
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/wavespeed-ai/openai-whisper-turbo" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
  printf 'Submission response did not contain a prediction id
' >&2
  exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done
Node.js example
const submitUrl = "https://api.wavespeed.ai/api/v3/wavespeed-ai/openai-whisper-turbo";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "audio": "https://interactive-examples.mdn.mozilla.net/media/cc0-audio/t-rex-roar.mp3",
        "language": "auto",
        "enable_timestamps": false
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
  await new Promise(resolve => setTimeout(resolve, 2000));
}
Python example
import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "audio": "https://interactive-examples.mdn.mozilla.net/media/cc0-audio/t-rex-roar.mp3",
    "language": "auto",
    "enable_timestamps": False
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/wavespeed-ai/openai-whisper-turbo", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout", "deleted"}:
        raise RuntimeError(result)
    time.sleep(2)

Openai Whisper Turbo API — Frequently asked questions

What is the Openai Whisper Turbo API?

Openai Whisper Turbo is a WaveSpeedAI model for AI inference, exposed as a REST API on WaveSpeedAI. Accurate speech-to-text with OpenAI Whisper Large v3 Turbo: multilingual transcripts with auto language detection and punctuation. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the Openai Whisper Turbo API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates Python, JavaScript, and cURL examples for submitting requests and polling results. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/wavespeed-ai/openai-whisper-turbo.

How much does Openai Whisper Turbo cost per run?

Openai Whisper Turbo starts at $0.0007 per run. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does Openai Whisper Turbo accept?

Key inputs: `prompt`, `audio`, `enable_sync_mode`, `enable_timestamps`, `language`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/wavespeed-ai/openai-whisper-turbo.

How long does Openai Whisper Turbo take to generate?

Reported generation time on WaveSpeedAI is around 2 seconds per request. This is an estimate, not a latency guarantee; queue time and input settings can change the total wait. live status is visible in the prediction record.

Can I use Openai Whisper Turbo outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (WaveSpeedAI). Check the provider's applicable terms and WaveSpeedAI's Terms of Service before commercial use.

llms.txt — wavespeed-ai/openai-whisper-turbo for AI agents and LLMs