How to convert mp3 to pcm wav online — free, no account
- Step 1
- Step 2Drop one MP3 — Add a single
.mp3. It's read in-browser and decoded locally by FFmpeg WASM — no upload. - Step 3Set the dataset sample rate — Pick the rate your pipeline standardizes on: 16 kHz is common for speech/ASR, 44.1 kHz for general audio, 48 kHz for video-sourced corpora, 96 kHz for high-rate analysis. Apply the same choice to every file for consistency.
- Step 4Set channels — Choose Mono for single-channel model input (most speech features), or Stereo to preserve both channels. FFmpeg uses
-acto enforce the count. - Step 5Generate the PCM WAV — Run it. The output is
pcm_s16leWAV — interleaved 16-bit little-endian samples behind a standard RIFF header. - Step 6Load it in your pipeline — Read with your library of choice (e.g.
soundfile.read('x.wav')returns float in [-1, 1], orscipy.io.wavfile.readreturns int16). Confirm the rate and channel count match your expectation before training/analysis.
Output PCM WAV specification
Exactly what the tool writes. Verified: encoder is pcm_s16le; sample rate and channels are user-set; bit depth is fixed at 16.
| Property | Value | Notes |
|---|---|---|
| Container | RIFF/WAVE (.wav) | Standard 44-byte header for PCM |
| Codec | pcm_s16le | 16-bit signed integer, little-endian |
| Bit depth | 16-bit (fixed) | No 24/32-bit option in this tool |
| Sample rate | 44100 / 48000 / 96000 / 16000 Hz | Set in the UI via -ar |
| Channels | 1 (mono) or 2 (stereo) | Set in the UI via -ac; stereo is interleaved L,R,L,R… |
| Sample range (int16) | -32768 … 32767 | What scipy.io.wavfile.read returns |
| Sample range (float) | -1.0 … 1.0 | What soundfile/librosa return after scaling |
How to read the output in common libraries
The WAV is a plain PCM file; every standard reader handles it. dtype/scaling shown for clarity.
| Library | Call | Returns |
|---|---|---|
| scipy | wavfile.read('x.wav') | (rate, int16 array) |
| soundfile | sf.read('x.wav') | (float64 array in [-1,1], rate) |
| librosa | librosa.load('x.wav', sr=None) | (float32 array, rate) — sr=None keeps original |
| wave (stdlib) | wave.open('x.wav') | raw bytes; 2 bytes/sample/channel |
| numpy (raw) | skip 44-byte header, np.frombuffer(..., '<i2') | interleaved int16 |
Size and duration limits
Per-file caps apply. PCM output is large; the cap is on the MP3 input.
| Tier | Max size | Max duration | Files |
|---|---|---|---|
| Free | 50 MB | 30 min | 1 |
| Pro | 200 MB | 120 min | 10 |
| Pro-media | 100 GB | Unlimited | 100 |
| Developer | 100 GB | Unlimited | Unlimited |
Cookbook
Pipeline-oriented recipes. Output is always 16-bit little-endian PCM WAV; only rate/channels vary.
Normalize an MP3 to 16 kHz mono for an ASR model
Speech models commonly train on 16 kHz mono PCM. Convert each source MP3 to that exact shape so the feature extractor sees consistent input.
Input: utt001.mp3 (96 kbps, 44.1 kHz, stereo)
Options: Sample rate = 16 kHz · Channels = Mono (-ar 16000 -ac 1)
Output: utt001.wav (pcm_s16le, 16 kHz, mono)
>>> import soundfile as sf
>>> data, sr = sf.read('utt001.wav')
>>> sr, data.ndim
(16000, 1)Decode to PCM and read int16 with scipy
When you want raw integer samples for a fixed-point DSP routine, read the WAV as int16.
Options: Sample rate = 44.1 kHz · Channels = Mono
>>> from scipy.io import wavfile
>>> rate, x = wavfile.read('clip.wav')
>>> rate, x.dtype, x.min(), x.max()
(44100, dtype('int16'), -31000, 30875)
# values span the signed 16-bit range; header is the standard 44 bytesStereo PCM with interleaved layout
Keep both channels for a stereo-aware analysis. The PCM is interleaved L,R,L,R; readers return an (N, 2) array.
Options: Sample rate = 48 kHz · Channels = Stereo (-ac 2)
>>> import soundfile as sf
>>> data, sr = sf.read('stereo.wav')
>>> data.shape, sr
((230400, 2), 48000) # columns are L, RBuild a uniform corpus from mixed-rate MP3s
Source MP3s came at different rates. Convert each at the same target rate so every file in the dataset is identical in shape.
For each file: Sample rate = 22050? (not in UI) -> use 16 kHz or 44.1 kHz. UI offers 44.1 / 48 / 96 / 16 kHz only. Pick 16 kHz for speech; convert every MP3 with the same setting. Result: a corpus where rate and dtype are constant -> simpler batching.
Parse the raw PCM without a WAV library
For a minimal pipeline, skip the 44-byte header and read int16 directly with numpy.
Options: Sample rate = 16 kHz · Channels = Mono
>>> import numpy as np
>>> buf = open('mono.wav','rb').read()
>>> pcm = np.frombuffer(buf[44:], dtype='<i2') # little-endian int16
>>> pcm.shape
(160000,) # 10 s × 16000 Hz, monoEdge cases and what actually happens
Need 24-bit or 32-bit float PCM
16-bit onlyThis tool writes pcm_s16le (16-bit) exclusively. If your pipeline strictly requires 24-bit or float PCM, you'll need a different source — the converter has no bit-depth control. For most ML/analysis on decoded MP3, 16-bit is adequate since the MP3 carried no extra range.
Sample rate you need isn't in the dropdown
Limited choicesThe UI offers 44.1 / 48 / 96 / 16 kHz. Common dataset rates like 22.05 kHz or 8 kHz aren't selectable here. If you need 22.05 kHz, resample after loading (e.g. librosa.resample) or use a different rate target. The sample-rate-converter is the dedicated tool for arbitrary rate changes.
Reader returns int16 where you expected float
ExpectedPCM is integer. scipy.io.wavfile.read returns int16; soundfile/librosa scale to float [-1,1]. Pick the reader that matches your pipeline, or divide int16 by 32768.0 to get float.
PCM WAV is much larger than the MP3
By design16-bit/44.1 kHz/stereo is ~10.1 MB/min; mono 16 kHz is ~1.9 MB/min. Large corpora of WAVs use far more disk than the MP3 sources — plan storage accordingly, or keep WAV as an intermediate and stream into training.
Encoder-delay padding at the file head
PreservedMP3 adds a short priming/padding region. The decoded WAV reflects the audible audio; if your labels are frame-exact, account for a few ms of head offset or trim with audio-trimmer before alignment.
Input larger than the tier cap
rejectedA long MP3 may exceed the size or duration cap (Free 50 MB / 30 min). Split it first with audio-trimmer, or process on a higher tier. Caps are checked in-browser before decoding.
Multiple files for a dataset
single fileThe tool converts one file at a time. For a corpus, script the equivalent via the local runner/API or convert files individually. There's no in-UI batch queue.
Expecting WAV to denoise or clean the audio
ExpectedConversion only decodes; it doesn't denoise. For noisy speech datasets, run the ai-noise-reducer (RNNoise) as a separate step — it also outputs 48 kHz mono PCM internally.
Non-standard header expectations
SupportedFFmpeg writes a standard PCM RIFF/WAVE header (typically 44 bytes). Some files may include extra chunks (e.g. a LIST/INFO block from carried metadata) before data — robust readers walk chunks rather than assuming a fixed offset.
Stereo array shape surprises a mono-only model
AvoidableIf your model expects 1-D input, set Channels = Mono so the WAV is single-channel — otherwise readers return an (N, 2) array and you'd have to downmix in code.
Frequently asked questions
What exact PCM format does this output?
16-bit signed little-endian PCM (pcm_s16le) in a standard RIFF/WAVE container, at the sample rate and channel count you choose. Interleaved samples; 2 bytes per sample per channel.
Can I get 24-bit or float32 PCM?
No. The tool encodes 16-bit only. For decoded-MP3 audio that's lossless relative to the source, since the MP3 had no genuine extra dynamic range. If you require 24-bit/float, this isn't the tool.
Which sample rates are available?
44.1 kHz, 48 kHz, 96 kHz, and 16 kHz in the UI. For other rates like 22.05 kHz or 8 kHz, resample in your code after loading, or use the dedicated sample-rate-converter.
How do I read the output in Python?
scipy.io.wavfile.read gives (rate, int16 array); soundfile.read and librosa.load(..., sr=None) give float arrays in [-1,1] plus the rate. All standard WAV readers work because it's plain PCM.
Is the header a fixed 44 bytes?
For plain PCM it's typically 44 bytes, but carried metadata can add chunks before data. Robust code should walk the RIFF chunks to find data rather than hardcoding offset 44.
Why convert to PCM instead of decoding MP3 in my code?
Decoding once to a uniform PCM WAV removes per-library decoder differences, drops the compressed parse from your hot path, and lets you standardize rate/channels across the whole dataset.
Does this run on a server?
No. FFmpeg 8.1 runs as WebAssembly in your browser. Dataset audio stays local, which matters for proprietary or sensitive corpora. No account is required.
How big will the WAV files be?
About 10.1 MB/min at 16-bit/44.1 kHz/stereo, or ~1.9 MB/min at 16 kHz mono. PCM is uncompressed, so a corpus of WAVs is much larger than the MP3 sources.
Can I batch a whole dataset here?
The UI is single-file. For automation, drive the conversion via the local runner/API (the audio tools expose a per-tool schema with sampleRate and channels), or convert files individually.
Does WAV recover quality lost by MP3 compression?
No. PCM faithfully stores the already-lossy audio. It standardizes the format for your pipeline; it doesn't restore detail. For artifacts, no format change helps — only re-recording does.
How do I avoid frame-alignment errors from MP3 padding?
MP3 has encoder delay/padding at the head. The decoded WAV reflects the audible audio; if you need frame-exact labels, trim the first few ms with the audio-trimmer or compensate for the known offset in your alignment.
Should I keep stereo or go mono for ML?
Most speech/feature pipelines expect mono — set Channels = Mono for a 1-D signal. Keep stereo only when your analysis is genuinely stereo-aware; readers then return an (N, 2) array.
What if I later need MP3 or FLAC again?
Re-encode the PCM WAV with wav-to-mp3 for compressed distribution, or wav-to-flac for lossless-compressed archival of the dataset.
Privacy first
Every JAD Audio tool runs entirely in your browser via FFmpeg (WebAssembly) and RNNoise. Your audio files never leave your device — verified by zero outbound network requests during processing.