whisper-large-v3

Whisper large-v3

The accuracy reference point for open speech recognition. Audio in, text out, with timestamps.

Why It Holds Up

Whisper's advantage was never architectural. It was the data: roughly five million hours of audio, and — crucially — most of it is not clean.

Speech models trained on studio recordings excel on studio recordings. Whisper was trained on the kind of audio people actually have: phone calls, meeting rooms with air conditioning running, speakers with accents the model was not specifically tuned for, two people talking at once, a recording made on a laptop microphone from across a table.

That is why it degrades gracefully where narrower models fail outright. Accuracy on pristine audio is a low bar. Accuracy on a recording someone made in a car is the useful measurement.

What It Does

Transcription — speech to text in the language spoken.

Translation — speech in any supported language to English text, in one pass. Note the direction: English is the only output language for translation. French audio to English text works; English audio to French text does not.

Language detection — automatic, from the audio itself. You can override it if you already know the language, and doing so improves accuracy on short or noisy clips where detection has little to work with.

Timestamps — per-segment by default, marking when each sentence starts and ends.

Ninety-Nine Languages, Unevenly

Whisper supports 99 languages, and accuracy varies enormously between them.

The languages with the most training data — English, Spanish, French, German, Italian, Portuguese, Japanese, Chinese — perform excellently. Lower-resource languages work but with higher word error rates, and heavily accented or code-switched speech is harder still.

For any language outside the top tier, measure before committing. Take twenty recordings from your real source — your actual microphones, your actual speakers, your actual background noise — and check the transcripts by hand. That sample tells you more than any published benchmark, because published benchmarks use clean audio and you probably do not.

Code-switching is a known weak point. A speaker alternating between two languages mid-sentence will produce errors at the switch points, and specifying a single language makes this worse rather than better. If your audio is genuinely mixed, let detection run and expect to post-process.

What Changed in v3

Two things distinguish this version from large-v2.

Finer audio resolution. The model analyses audio using 128 frequency bands instead of 80, giving it more detail to work with per unit of sound.

More training data, including a large volume of pseudo-labelled audio generated by the previous version — a bootstrapping approach that extended coverage well beyond what could be labelled by hand.

The practical effect is lower error rates across most languages, with the largest gains on the harder ones.

Specifications

Capabilities

Using It on DEVUP AI

Endpoint: POST https://api.devupai.com/v1/audio/transcriptions

This is a multipart form upload, not a JSON request. The audio file is uploaded directly.

Transcribe a file — cURL

curl -X POST "https://api.devupai.com/v1/audio/transcriptions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F model="openai/whisper-large-v3" \
  -F file=@meeting.mp3

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

with open("meeting.mp3", "rb") as audio:
    result = client.audio.transcriptions.create(
        model="openai/whisper-large-v3",
        file=audio,
    )

print(result.text)

Working with timestamps — Python

The response carries segments, each with a start time, an end time, and its text. That structure is what makes transcription useful beyond a wall of prose.

with open("interview.mp3", "rb") as audio:
    result = client.audio.transcriptions.create(
        model="openai/whisper-large-v3",
        file=audio,
    )

for segment in result.segments:
    minutes, seconds = divmod(int(segment["start"]), 60)
    print(f"[{minutes:02d}:{seconds:02d}] {segment['text'].strip()}")

Timestamps are what let you build a searchable archive rather than a text dump: click a phrase, jump to that moment in the recording. Store them alongside the text from the start — recovering them later means re-transcribing.

Generating subtitles — Python

def to_srt(segments) -> str:
    """Convert Whisper segments into SubRip subtitle format."""

    def timestamp(seconds: float) -> str:
        hours, remainder = divmod(seconds, 3600)
        minutes, secs = divmod(remainder, 60)
        return f"{int(hours):02d}:{int(minutes):02d}:{int(secs):02d},{int((secs % 1) * 1000):03d}"

    lines = []
    for index, segment in enumerate(segments, start=1):
        lines.append(str(index))
        lines.append(f"{timestamp(segment['start'])} --> {timestamp(segment['end'])}")
        lines.append(segment["text"].strip())
        lines.append("")

    return "\n".join(lines)


with open("video_audio.mp3", "rb") as audio:
    result = client.audio.transcriptions.create(
        model="openai/whisper-large-v3",
        file=audio,
    )

Path("subtitles.srt").write_text(to_srt(result.segments), encoding="utf-8")

Segment boundaries follow natural speech pauses rather than a fixed duration, which usually produces readable subtitle timing without further adjustment.

Node.js

npm install devupai

import DevupAI from "devupai";
import { createReadStream } from "node:fs";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

const result = await client.audio.transcriptions.create({
  model: "openai/whisper-large-v3",
  file: createReadStream("meeting.mp3"),
});

console.log(result.text);

Processing a batch — Python

from pathlib import Path
import json

RECORDINGS = Path("recordings")
OUTPUT = Path("transcripts")
OUTPUT.mkdir(exist_ok=True)

for path in sorted(RECORDINGS.glob("*.mp3")):
    target = OUTPUT / f"{path.stem}.json"
    if target.exists():
        continue  # already done — transcription is not cheap enough to repeat

    try:
        with path.open("rb") as audio:
            result = client.audio.transcriptions.create(
                model="openai/whisper-large-v3",
                file=audio,
            )
    except Exception as exc:
        print(f"{path.name}: {type(exc).__name__} — {exc}")
        continue  # one bad file should not stop the run

    target.write_text(
        json.dumps({"text": result.text, "segments": result.segments}, ensure_ascii=False, indent=2),
        encoding="utf-8",
    )
    print(f"{path.name}: {len(result.text)} characters")

The skip-if-exists check is the important line. A batch that crashes at file 340 of 500 should resume from 341, not start over.

Preparing Audio Well

Transcription quality is decided before the request is sent more often than people expect.

Convert to a supported format first. mp3 and wav are what the endpoint accepts. Anything else — m4a from a phone, ogg from a browser recorder, the audio track inside an mp4 — needs converting before upload.

ffmpeg -i recording.m4a -ar 16000 -ac 1 recording.wav

16 kHz mono is the model's native format. Higher sample rates are downsampled internally and stereo is mixed to mono, so sending a 48 kHz stereo file uploads several times the necessary bytes for identical output. Converting first makes uploads faster and reduces the chance of hitting a size limit.

Trim silence from the start and end. Whisper has a documented tendency to invent text when given nothing to transcribe — leading silence can produce a hallucinated opening line that was never spoken.

Do not clean the audio aggressively. Noise reduction tuned for human listening frequently removes information the model uses. Whisper was trained on noisy audio; heavy denoising can make results worse rather than better. Test both on a sample before applying it to a corpus.

Split very long recordings. The model handles 30-second windows internally and stitches them, but a two-hour upload is one request that either succeeds or fails as a whole. Splitting on silence at natural boundaries gives you resumability and keeps individual requests manageable.

Known Failure Modes

Worth knowing before you find them in production.

Hallucination on silence. Given silence, music, or unintelligible noise, the model sometimes produces confident text that was never spoken — often a phrase common in its training data. Trim silence, and treat suspiciously fluent output over a quiet passage as suspect.

Repetition loops. Occasionally a segment repeats a phrase many times. This is detectable programmatically: flag any segment where one phrase recurs beyond a threshold.

Unstable punctuation and casing. Sentence boundaries and capitalisation vary run to run. If downstream logic depends on exact formatting, normalise it yourself rather than relying on the model.

Speaker identity is not tracked. Whisper transcribes what was said, not who said it. Distinguishing speakers requires a separate diarisation step.

Output is not deterministic. The same file transcribed twice can differ in small ways. For reproducibility, store the transcript rather than re-generating it.

Choosing Between Whisper Variants

Two versions of this model exist on the platform, and the choice is straightforward.

This model is the accuracy option. Use it for anything archived, published, legally significant, in a lower-resource language, or recorded in difficult conditions.

The turbo variant is substantially faster with a modest accuracy cost, concentrated in the harder languages. Use it for high volume, near-real-time work, and clean English audio.

A pattern worth considering when both matter: transcribe with the fast variant, then re-run only the segments where confidence is low or the output looks wrong through this one.

Limitations

• Transcription and English translation only. It cannot translate into languages other than English, and it does not generate speech.
• No streaming. The full file is uploaded, processed, and returned. Live transcription requires a model built for it.
• mp3 and wav only on this endpoint. Convert other formats before uploading.
• No speaker labels. Diarisation is a separate problem.
• Accuracy varies sharply across languages. Measure on your own audio rather than trusting an aggregate benchmark.
• Hallucinates on silence and noise. Trim, and review output that looks too clean for the input.
• Not deterministic. Store transcripts rather than regenerating them.
• Timestamps are per segment, not per word, on this response shape.
• Audio leaves your system when uploaded. Recordings frequently contain personal or confidential speech; handle them under the same policy you apply to any other outbound data.