Speech model sizes explained: tiny to turbo, and which one your browser can run
Whisper model sizes from tiny to large and turbo: what parameters mean, the VRAM and speed figures from OpenAI's own table, and what each costs in a browser.
OpenAI’s open-source Whisper models come in six sizes: tiny, base, small, medium, large and turbo. The Whisper model sizes run from 39 million parameters to 1,550 million, and the README lists required video memory from about 1 GB to about 10 GB. Bigger is more accurate and slower. In a browser the question is different: how much do you have to download, and how much memory does your graphics card have. This post explains what a parameter is, walks through OpenAI’s own table, and shows why a browser tool settles on the base model by default.
A model’s size is its number of parameters
A speech recognition model is a neural network, and a neural network is mostly a very large collection of numbers called parameters, or weights. Training sets those numbers. Running the model, which is what happens when you transcribe a file, means pushing your audio through them, multiplying and adding many millions of times per second of speech.
So “model size” has one plain meaning. It’s how many of those numbers there are. When the README says base has 74 M parameters, it means 74 million numbers that have to be stored on disk, loaded into memory and multiplied through for every chunk of audio.
That single count drives what you care about: download size, memory while running, and time taken. More parameters also usually means better accuracy, because a larger network can learn finer distinctions between similar sounds and rarer words.
The Whisper model sizes, straight from the README
OpenAI publishes one table in the project README on GitHub. Its framing is: “There are six model sizes, four with English-only versions, offering speed and accuracy tradeoffs.” The first five columns below are copied from it, leaving out its multilingual-model column. The last column is our own measurement of the ONNX conversions we use, measured by us on 14 September 2026, and is explained further down.
| Size | Parameters | English-only model | Required VRAM | Relative speed | Download in our browser build |
|---|---|---|---|---|---|
| tiny | 39 M | tiny.en | ~1 GB | ~10x | Not in our build |
| base | 74 M | base.en | ~1 GB | ~7x | About 209 MB (encoder_model fp32, 82.5 MB, plus decoder_model_merged q4, 123.6 MB) |
| small | 244 M | small.en | ~2 GB | ~4x | Not in our build |
| medium | 769 M | medium.en | ~5 GB | ~2x | Not in our build |
| large | 1550 M | N/A | ~10 GB | 1x | Not in our build |
| turbo | 809 M | N/A | ~6 GB | ~8x | About 565 MB (encoder_model q4f16, 370 MB, plus decoder_model_merged, 194 MB); about 1.6 GB at fp16 |
Two notes on reading the README’s columns. VRAM is the memory on a graphics card, and these are the figures for running the model with OpenAI’s own Python code, not in a browser. Relative speed is as the README states it: “The relative speeds below are measured by transcribing English speech on a A100, and the real-world speed may vary significantly depending on many factors including the language, the speaking speed, and the available hardware.” An A100 is a data-centre card, so treat that column as a ranking, not a prediction for your laptop.
Turbo sits outside the neat progression. The README describes it as “an optimized version of large-v3 that offers faster transcription speed with a minimal degradation in accuracy.” It has roughly half the parameters of large, and the README rates it faster than medium and close to base.
English-only versions exist for the four smaller sizes
Every size up to medium has a .en variant trained for English only. The README’s guidance: “The .en models for English-only applications tend to perform better, especially for the tiny.en and base.en models. We observed that the difference becomes less significant for the small.en and medium.en models.”
That matters if you are choosing a small model for English speech. At the same parameter count the English-only version tends to do better, and the effect is largest for exactly the sizes a browser can run comfortably. Large and turbo have no English-only variant.
Accuracy goes up with size, on the README’s own terms
The README states the trade-off and does not put numbers on it. Its only accuracy figures are a chart of word and character error rates for large-v3 and large-v2 by language, evaluated on the Common Voice 15 and Fleurs datasets; for the other sizes it points to the paper’s appendices. There’s no table of error rates for tiny, base, small or medium in the README itself, so we won’t invent one.
What you can take from the document is the direction: larger models are more accurate, the English-only variants help most at the small end, and turbo gives up a little accuracy against large-v3 for a large gain in speed. In our own test of the base English model, a clean text-to-speech recording came back word-perfect, and the weak spots were names, technical terms, heavy accents and noisy rooms. Read any transcript through before relying on it.
Download size is what the parameter count turns into in a browser
The VRAM column is for a Python install on a desktop or server. In a browser the first cost you meet is the download, and that depends on the parameter count and on how many bytes each parameter is stored in.
A full-precision number, fp32, takes 4 bytes. Seventy-four million of them is close to 300 MB before any compression. Model files for the browser are therefore often stored at lower precision: fp16 uses 2 bytes per number, and q4 stores most weights in about half a byte. Lower precision means a smaller download and less memory, at some risk to accuracy and, on some hardware, to whether the file loads at all. That’s how base comes down to about 209 MB in the table above, and why turbo is 565 MB compressed but about 1.6 GB at fp16, a size nobody ships to a browser by default.
Why FreeTranscribe runs the base English model, and what turbo would cost
FreeTranscribe loads onnx-community/whisper-base.en, the English-only base model, with a full-precision fp32 encoder and a q4 compressed decoder. The download is about 209 MB, fetched once and then cached by your browser.
The mix of precisions is deliberate. The encoder is the part that reads the audio, and keeping it at fp32 avoids loading problems we hit with fp16 and q4 encoders on integrated graphics through WebGPU. The decoder, the part that writes out words, is the larger file, so compressing it to q4 is where the download saving comes from. The result is a model that starts on a thin laptop as well as on a desktop with a discrete card.
Speed follows from size. In our test, a desktop with a graphics card transcribed 71 seconds of audio in 41 to 50 seconds including model load, about 1.5 times real time. A thin laptop with integrated graphics takes roughly as long as the recording. The post on WebGPU explains why the graphics card matters at all.
Turbo would be the natural upgrade for accuracy. Our code defines a turbo option at about 565 MB, but base is what runs today and every number on this site refers to base. The costs of turbo are plain from the table. The download is 565 MB compressed against 209 MB, and it has to fit in the browser’s cache. On memory, the README lists ~6 GB of VRAM for turbo against ~1 GB for base under OpenAI’s Python code. We have not measured the browser build’s memory use, and integrated graphics share the system’s RAM rather than having VRAM of their own, so treat the 6 GB as a warning rather than a rule. A model with eleven times the parameters of base will not start on every machine that runs base, and will run slower on all of them.
That’s the whole trade. Base is the model most desktop Chrome or Edge users can download in a minute and run at usable speed, and its known limits are names, jargon, accents and noise. The tool is English only and desktop only for now. If that fits your recording, drop a file on the transcriber and see how long it takes on your hardware.
Frequently asked questions
Which model size is best? The README gives one answer: large is the most accurate and the slowest, tiny the fastest and least accurate, and every size between is a trade between the two. For English on a small model, the README says the .en versions tend to perform better. In a browser the practical limit is download size and graphics memory, which is why base is the usual default.
Is turbo the same as large? No. The README describes turbo as “an optimized version of large-v3” with 809 M parameters against large’s 1550 M, “faster transcription speed with a minimal degradation in accuracy”, and a required VRAM figure of ~6 GB against ~10 GB.
Does the browser version give the same results as the Python one? It uses the same trained weights converted to ONNX, with the decoder stored at lower precision to shrink the download. Lower precision can cost a little accuracy. We have not measured the difference: same model, slightly compressed, so read the transcript through.
Is the model free to use? Yes. The README states that “Whisper’s code and model weights are released under the MIT License.”
Sources, checked 15 September 2026
- https://github.com/openai/whisper : OpenAI’s Whisper README, “Available models and languages” table (parameters, English-only models, required VRAM, relative speed), the A100 speed note, the
.enguidance, the turbo description, the WER chart for large-v3 and large-v2 on Common Voice 15 and Fleurs, and the MIT licence statement - https://raw.githubusercontent.com/openai/whisper/main/README.md : raw copy of the same README, used to confirm the exact wording quoted above
- File sizes for the ONNX conversions (
onnx-community/whisper-base.enandonnx-community/whisper-large-v3-turbo) were measured by us on 14 September 2026; speed and accuracy figures are from our own test of the tool, described in the text