Convert OPUS to WAV

This is the fact worth knowing before anything else. Opus runs on a fixed 48,000 Hz clock — a decoder reports 48 kHz regardless of what the encoder was given — so the WAV that comes out of this conversion is a 48 kHz file, even when the underlying voice note was captured much more narrowly than that.

Almost every speech model expects 16,000 Hz. Whisper resamples internally, `torchaudio` and `librosa` resample on load, and a forced-alignment tool will usually do it too. The failure mode is not noise, it is silence: a pipeline that assumes 16 kHz and reads a 48 kHz file without checking the header produces output that looks plausible and is wrong by a factor of three. Read the header, or resample explicitly, and the rest of the pipeline behaves.

A WAV declares itself. The first chunk states the format tag, the channel count, the sample rate, the byte rate and the bits per sample; the next states how many bytes of audio follow; and the data chunk is the samples themselves. Reading it needs no decoder, which is why the Python standard library ships a `wave` module and does not ship an Opus one.

Supporting Opus means linking libopus or calling out to FFmpeg, which is a dependency, a build problem on three platforms and a class of bug reports. Research and transcription code is written by people who would rather not own any of that, so the ingest list says WAV and occasionally MP3 and FLAC. Your file is not unsuitable; their loader is narrow, and this conversion is how you meet it.

It is worth stating plainly, because the expectation is common. Opus compressed the speech and discarded what it judged inaudible; the WAV holds the survivors at full width. Word error rate is set by the recording — the room, the microphone, the overlap between speakers, the bitrate the app chose — and none of that changes when the container does.

There is one case where converting genuinely helps, and it is the case this page exists to prevent. If your alternative was re-encoding to MP3 to satisfy the same upload form, you would be adding a second round of lossy compression on top of speech that was already encoded at 16 to 32 kbps, with a codec that is markedly less efficient than Opus at those rates. WAV adds nothing and destroys nothing, which is the right property for an intermediate.

Opus is extraordinarily efficient at speech, and that efficiency is exactly what makes the ratio dramatic. A voice note is mono at somewhere between 16 and 32 kbps, so a two-minute message is around 300 kilobytes. As 16-bit mono PCM at 48,000 Hz that same two minutes is about 11.5 megabytes — thirty to forty times larger, holding not one additional detail.

For one recording this is irrelevant. For a set of four hundred voice notes off a phone backup it is the difference between 120 megabytes and four and a half gigabytes, and it will decide whether the job fits on the disk you were planning to use. Convert in the batches your pipeline consumes rather than converting the archive up front.

Opus is the mandatory codec for WebRTC, which is why every browser ships it and why every app built on browser technology reaches for it. WhatsApp and Telegram voice messages, Signal, Discord recordings, Google Meet captures, in-browser recorders and `yt-dlp` taking the best audio stream all produce it.

That origin shapes the material. The recordings are short, mono, conversational and frequently made on a phone in a room with no acoustic treatment. They also tend to arrive in quantity, named with timestamps and no metadata, which is why the batch path and the filename discipline matter more here than the audio settings do.

The output is signed 16-bit little-endian PCM — the depth every default assumes, the one `wave.open` returns without configuration and the one `scipy.io.wavfile.read` hands back as an `int16` array.

Opus decodes to floating-point samples internally, so a 32-bit float WAV is technically expressible and would be twice the size for no gain: the information content was fixed the moment the encoder ran. Speech models normalise to floats on load anyway, and they do it from whatever depth they are given. Sixteen bits is not a compromise here, it is the right answer.

Ogg Opus carries a pre-skip value that tells a decoder how many samples at the head of the stream are encoder priming and should be discarded. That is how a call can begin cleanly rather than with a click, and it is honoured during decoding.

What a WAV cannot carry is any of that bookkeeping — it has a start and a length and nothing else. For a transcript that is immaterial. It matters if you are aligning a converted recording against video, against a second microphone or against a timecode: do the alignment on the WAV, after conversion, using a shared reference in the audio, rather than assuming sample-zero in the two files refers to the same instant.

This bears saying directly rather than as a feature bullet. The files that arrive as `.opus` are voice messages, recorded calls, interviews, clinical notes, research sessions captured under a consent form that named who would hear them. A conversion site that takes an upload creates a copy on infrastructure you have not assessed, governed by terms you did not negotiate.

Here the decode uses the Opus decoder your browser already contains and the WAV is a RIFF header assembled around the samples, so no encoder package is fetched and no request carries the audio. That is checkable rather than promised: open the network tab of your developer tools, convert a file, and look. You will see the page and the advertising that funds it and nothing else.

Drop a hundred recordings at a time. Each converts on its own and they come back as a single ZIP, with a 100 MB per-file ceiling — far above any voice note — and no daily allowance to spend, because nothing is being uploaded and there is nothing to meter.

Watch the total rather than the individual files, since the multiple is what bites: four hundred two-minute notes are around 120 MB as Opus and roughly four and a half gigabytes as WAV, assembled inside a browser tab. Convert in groups of fifty or a hundred, feed each group to the pipeline, and delete the WAVs once the transcripts exist — they are intermediates, and the Opus files are the originals worth keeping.