asr-bench independent · non-sponsored · self-funded

Home / Benchmarks / Speech-to-text leaderboard

Who made this, and why

Roberto Mastrangelo

Who I am

Why I built this

Speech-to-Text Model & Provider Leaderboard

An independent, self-funded benchmark of speech-to-text engines. No vendor sponsored it, reviewed it, or saw it before publication.

Word error rate, robustness and cost across speech-to-text engines - running locally on one GPU, cloud APIs - measured on identical audio with one published scorer. The ranking changes every time the audio does.

Key takeaways

    Highlights

        lower-left is better · cost axis is logarithmic

        Show these numbers as a table

        WER across evaluation conditions

        The same four engines on five kinds of audio. A leaderboard built on the first column alone would recommend a different engine than any of the other four.

          ↑ lower WER is better · axis inverted
          Engines

          Show these numbers as a table

          Where every engine ranks, condition by condition

          The four engines above are the legible case. This is all of them - position is rank, not score, so a line that climbs is an engine other engines overtook.

          Show these ranks as a table

          Every language, with its confidence interval

          pooled WER · 95% CI from a paired bootstrap · marks an engine the bootstrap could not separate from that language's winner

          A single headline number hides which language it was won in. Switching to Parliament also switches domain - FLEURS is read speech, VoxPopuli is spontaneous parliamentary speech - and that is the harder test.

          Show these numbers as a table

          The same field, scored by characters

            rank 1 at the top · a tilted line means the two metrics disagree

            Show these numbers as a table

            Listen for yourself

            What engines say when there is nothing to hear

            Two probes with an empty reference: pure digital silence, and noise with no speech in it. Anything an engine returns here is invented - unless it is describing the sound rather than transcribing it, which is a different thing entirely.

              Show these numbers as a table

              What they actually returned

              Ask twice, get two different answers

              The same audio, the same engine, two independent passes. A benchmark that reports a single run is reporting one sample from a distribution it never measured.

              Local - one GPU, two passes

                Cloud - two API calls

                  Long recordings, and what chunking costs

                  The same speech scored twice: once as ~6.6 segments of ~11.5 s, once as one continuous ~76 s recording, with identical reference words on both sides.

                    Show these numbers as a table

                    Speed, on two axes that must not be merged

                    A local model's cost is compute; a cloud API's is a network round trip. They are different quantities measured on different machines, so they get two charts and never one axis - putting them together would invent a comparison.

                    Local - realtime factor on one GPU

                      Cloud - wall-clock turnaround per clip

                        The accuracy score cannot see whether numbers are usable

                        The normalizer folds "twenty-two hundred" and "22:00" together, correctly - they are the same words. But if you are parsing output, one is a number and the other is a sentence, and WER is structurally blind to the difference.

                          All engines

                          pooled WER, macro over languages · click a header to sort · - is not measured, never zero · de marks a figure from German alone, because that engine is German-only

                          Every metric on this page, defined

                          Each one says what it measures, how many engines carry it, and - the column most leaderboards leave out - what it cannot tell you.

                          How this compares to other public benchmarks

                          We read seven public STT benchmarks against ours. The most useful thing to report is not where the numbers differ - it is that three of the seven run no audio of their own, and that none of them publishes a confidence interval.

                          Where we agree, and where we don't

                          Agreement. ElevenLabs and AssemblyAI are top-tier in every benchmark that runs its own audio, and Deepgram Nova-3 is weak in all of them. gpt-4o's clean-brittleness reproduces independently too: Artificial Analysis, on harder real-world audio, drops it below both - which is exactly the re-ranking we measure going clean → noise. Different team, different data, same collapse.

                          ElevenLabs is the instructive disagreement. We rank it a robust #1 on clean audio; Pipecat ranks it mid-pack. Four reasons, none of them a contradiction: they test the realtime checkpoint and we test the batch one; they test English only and we average five languages; they score with an LLM judge and we use a deterministic normalizer; their audio is short agent turns and ours is read and parliamentary speech. Two careful benchmarks, opposite verdicts, and the disagreement is entirely explained by what each chose to measure. That is this page's thesis in one example.

                          Qwen is the cautionary one. We score it mid-field; Artificial Analysis scores the same family near-worst - roughly a 5× gap. Loading Qwen3-ASR through generic transformers silently initialises a random audio tower: the whole audio stack reports as missing from the checkpoint and is newly initialised, and a model whose audio encoder is random weights cannot transcribe at all. We confirmed the broken load; we did not reproduce their harness, and their artifact may differ. The lesson stands either way - a 53-model public leaderboard can silently mis-load a model, and only a per-model sanity check catches it.

                          Four times we were wrong

                          A benchmark nobody can falsify is not a benchmark. The error log ships with the results rather than being quietly corrected.

                          How this was measured

                          WER is pooled, not averaged: total errors over total reference words, so one short clip with a 300% score cannot dominate a hundred good ones. Every cell carries a 95% confidence interval from a , and two engines are called separable only when the interval of their paired difference excludes zero.

                          The expensive artifact - the raw transcripts - is committed. Scoring needs no GPU and no API key, and reproduces these numbers byte-for-byte in about two minutes.

                          Normalisation - applied identically to both sides

                          Reference and hypothesis pass through the same published normalizer before a single edit is counted, so no engine is penalised for a house style. For English that is Whisper's EnglishTextNormalizer - spelled numbers unified to digits, contractions and abbreviations expanded, US/UK spelling folded. For German, French, Italian and Spanish: lowercase → abbreviation table → spoken-variant folding → thousands, decimal and time handling → digits back to words → BasicTextNormalizer.

                          The residual limitation, stated rather than hidden: number expansion picks the canonical num2words form, and spoken variants fold back to it only where a rule exists - German elfhunderteintausendeinhundert, for instance. Unlisted variants still count as errors. Sampling excludes digit-bearing references from the headline lanes, so this is a backstop rather than something the score leans on; the digit lane measures formatting deliberately and separately.

                          The lanes, and what each one is

                          Exactly what was run

                          A benchmark you cannot pin to a checkpoint is a benchmark you cannot reproduce. Local weights carry a commit hash; cloud entries carry the model string the vendor returned, because that is the most an API can be pinned to - and it can change under you without notice.

                          What this benchmark does not cover

                          Stated up front, because a benchmark that only lists what it measured invites you to assume the rest.

                          Caveats that could move a number

                          • Training contamination is unknowable for engines whose training sets are undisclosed - which cuts both ways. One case is known rather than suspected: canary and parakeet were trained on Granary, which builds on MOSEL, which incorporates VoxPopuli audio. Treat their parliament cells as potentially contaminated.
                          • Italian VoxPopuli is consensus-filtered. A 17-engine minimum-WER audit found 17 of 128 clips with misaligned references; those are excluded and the remaining 111 rank normally. Consensus filtering mildly favours this cell, which is why it is disclosed here rather than left implicit.
                          • VoxPopuli references are aligned official records, lightly edited rather than verbatim - so the reference can carry words the audio does not, and every engine's deletion rate is inflated in the same direction. Ranking within the parliament lane is unaffected. The gap between the clean and parliament lanes is therefore part audio difficulty and part reference convention, and the headline multiple above should be read that way.
                          • Cloud models change silently. Every cloud figure is a dated snapshot; the same endpoint may return a different model tomorrow with no version bump. Local weights are pinned to a commit and will not.
                          • No multiple-comparison correction. With 18 engines there are hundreds of pairwise comparisons, so an occasional pair will separate by chance. Headline claims are limited to comfortably separated pairs; everything else is exploratory.
                          • Additive noise only - no reverberation, no Lombard effect, no codec artefacts beyond the telephony lane. Real rooms are harsher than MUSAN mixed at a fixed SNR.
                          • The local cost model is marginal electricity, not total cost of ownership. It is computed per engine - measured realtime factor × 236 W at the wall (a 175 W laptop GPU plus 35% for CPU, RAM and supply losses) × $0.35/kWh - and it excludes the GPU, the engineer and the uptime you would have to provide yourself. The draw is the GPU's rated maximum rather than a meter reading, which over-states an engine that does not saturate the card. Cloud figures are vendor list prices, so the two sides of the price chart are not the same kind of number: one is a power bill, the other a service contract.