MIDI TO MP3 & WAV · RENDERING TESTED · UPDATED 2026-10-20
MIDI to MP3 and MIDI to WAV: How to Convert a MIDI File
To convert MIDI to MP3 (or convert mid to mp3 — same .mid file), a synthesizer must play the notes with an instrument sound (a SoundFont or virtual instrument), and the recording is then encoded as MP3. That recording is already a WAV, so MIDI to WAV is the same job without the last step. The converter below does both in your browser, with no upload. Offline, FluidSynth plus FFmpeg does the same; raise FluidSynth’s default gain, or the MP3 comes out very quiet.
Convert MIDI to WAV or MP3 in your browser
Choose a .mid or .midi file, then pick WAV or MP3. The notes are played by a General MIDI SoundFont (TimGM6mb) and encoded on this device; the file is never uploaded. Up to 10 minutes of music; output is 44,100 Hz 16-bit stereo, peak-normalized to -1 dBFS; MP3 at 192 kbps.
Open-source parts: spessasynth_core (Apache-2.0) synthesizer, lamejs (LGPL-3.0) MP3 encoder, TimGM6mb SoundFont (GPL-2.0). Licenses. The test renders further down were made with FluidSynth and the larger FluidR3_GM SoundFont, so they sound different from this tool.
Updated 2026-11-10 (tempo-map duration / mid-track program change / missing-bank fallback; prior 2026-10-23 size and loudness tests). Every number on this page comes from renders we made on 2026-10-18, 2026-10-19 and 2026-10-20 of the same MIDI file produced by our MP3 to MIDI converter; the files are linked so you can listen and check.
How do I convert a MIDI file to MP3 for free?
You can convert midi to mp3 for free in two steps: render it to a 44,100 Hz WAV with a software synthesizer such as FluidSynth at gain 0.8, then encode the WAV as a 192 kbps MP3 with FFmpeg; for MIDI to WAV, the first command is the whole job. These are the two commands we ran for the tests below (FluidSynth 2.4.4 and FFmpeg 7.1.5 on Linux; both programs also run on Windows and macOS):
fluidsynth -ni -q -g 0.8 -r 44100 -F song.wav FluidR3_GM.sf2 song.mid
ffmpeg -i song.wav -c:a libmp3lame -b:a 192k song.mp3
| Option | Meaning | Why it matters for MIDI to MP3 |
|---|---|---|
-ni | No MIDI input device, no interactive shell | Lets the command finish on its own |
-g 0.8 | Master gain (FluidSynth default 0.2) | Sets the loudness of the WAV, and so of the MP3 (see the gain test) |
-r 44100 | Sample rate in Hz | 44,100 Hz is the usual rate for MP3 music files |
-F song.wav | Fast render to a file instead of the speakers | Writes the audio as fast as the computer can, not in real time |
FluidR3_GM.sf2 | The SoundFont | Decides what every instrument sounds like |
Other routes do the same two steps: a DAW or notation program renders the MIDI with its built-in instruments and exports audio, and online MIDI to MP3 converters run a synthesizer for you. Many online converters upload your file to their server, while some render in the browser, so read the tool’s privacy note if the music is private.
MIDI to WAV: which WAV settings, and what each costs
For MIDI to WAV, choose the WAV format in the render command itself: -O sets the sample format and -r the sample rate. FluidSynth writes 16-bit stereo by default. We rendered the same MIDI (FluidR3_GM, gain 0.8) five ways and read each file's header:
| WAV setting | How we made it | Audio data (formula) | Header | File size | Per minute of audio |
|---|---|---|---|---|---|
| 16-bit, 44,100 Hz, stereo | -r 44100 (default format) | 44,100 × 2 × 2 × 11.379229 s = 2,007,296 bytes | 44 bytes | 2,007,340 bytes | 10,584,000 bytes |
| 24-bit, 44,100 Hz, stereo | -O s24 | 44,100 × 2 × 3 × 11.379229 s = 3,010,944 bytes | 44 bytes | 3,010,988 bytes | 15,876,000 bytes |
| 32-bit float, 44,100 Hz, stereo | -O float | 44,100 × 2 × 4 × 11.379229 s = 4,014,592 bytes | 88 bytes (adds fact and PEAK chunks) | 4,014,680 bytes | 21,168,000 bytes |
| 16-bit, 48,000 Hz, stereo | -r 48000 | 48,000 × 2 × 2 × 11.380 s = 2,184,960 bytes | 44 bytes | 2,185,004 bytes | 11,520,000 bytes |
| 16-bit, 44,100 Hz, mono | 16-bit file, then ffmpeg -ac 1 | 44,100 × 1 × 2 × 11.379229 s = 1,003,648 bytes | 78 bytes (FFmpeg adds a LIST chunk) | 1,003,726 bytes | 5,292,000 bytes |
The formula matched every file to the byte once the header was counted. Three findings change what you should pick:
- The 16-bit WAV is 7.3 times the 192 kbps MP3 of the same render (2,007,340 vs 274,642 bytes). Bit depth does not change loudness: the 16-bit, 24-bit and float files all measured -27.9 LUFS with a -13.51 dBFS peak.
- Render at your project's sample rate rather than converting later. If your video or DAW project runs at 48 kHz, use
-r 48000. Our 48 kHz render measured -28.2 LUFS, within 0.3 LU of the 44.1 kHz file. - Mono is not free: folding our stereo render to mono with
-ac 1halved the size but measured -32.4 LUFS, 4.5 LU quieter, because FFmpeg averages the two channels (we checked: every mono sample equals (left + right) ÷ 2 to within half a 16-bit step). Check the level if a platform asks for mono.
How big is the WAV from the MIDI to WAV converter on this page?
About 10.6 MB per minute of audio: the converter above writes 44,100 Hz 16-bit stereo, which is 176,400 bytes per second, so our 1,367-byte test MIDI (16.0 s of music) became a 3,175,244-byte WAV of 18.00 s, about 7.3 times the 433,214-byte MP3 made from the same file.
| Output | Size | Length | Format | Loudness / peak | Size vs MIDI |
|---|---|---|---|---|---|
| WAV | 3,175,244 B | 18.00 s | 44.1 kHz, 16-bit, stereo | -16.3 LUFS / -1.0 dBFS | 2,323× |
| MP3 | 433,214 B | 18.05 s | 192 kbps, stereo | -16.6 LUFS / -1.3 dBFS | 317× |
The WAV runs 2.0 s longer than the notes because the last notes are allowed to ring out instead of being cut. Size grows with length, not with the number of notes or tracks: a 3-minute song comes out near 31.8 MB as WAV (180 s × 176,400 B) and about 4.3 MB as 192 kbps MP3. Pick WAV when you will edit or master the audio, and MP3 when you only need to share or play it.
Why render MIDI to a float WAV before you edit it
A 32-bit float WAV keeps peaks above full scale, so a render that is too loud can still be turned down without damage; a 16-bit WAV cuts them off for good. We raised FluidSynth's gain on the same MIDI and rendered both formats each time:
| Gain | Predicted peak | 16-bit WAV | Float WAV |
|---|---|---|---|
| 0.8 | -13.51 dBFS | -13.51 dBFS, 0 clipped | -13.51 dBFS, 0 over |
| 2.0 | -5.55 dBFS | -5.55 dBFS, 0 clipped | -5.55 dBFS, 0 over |
| 4.0 | +0.47 dBFS | 0.00 dBFS, 7 samples cut off at full scale | +0.47 dBFS, 7 samples over 0 dBFS, kept |
4.0, then -af volume=-1dB | -0.53 dBFS | -1.00 dBFS, the 7 flattened tops stay flat | -0.53 dBFS, original peaks restored, 0 over |
The prediction matched each measurement to 0.01 dB. A single melody needed gain 4.0 to clip; a MIDI with chords or many tracks adds voices together and clips at a much lower gain. So when the WAV goes into a DAW or editor for mixing, render it with -O float and set the final level there. Convert to 16-bit, or encode to MP3, only once the level is final.
Does the SoundFont change the MP3? Our same-MIDI test
Yes: the same MIDI file came out 5.1 LU quieter and 0.54 s longer when we swapped the 148 MB SoundFont for the 6 MB one, with every other setting unchanged. Our input was vocadito_10-output.mid, the 384-byte file our converter made from a real singing clip in the real vocal to MIDI example: 40 notes, one track, 8.875 seconds.
| SoundFont (file size) | Preset used | Integrated loudness | Sample peak | Rendered length | MP3 at 192 kbps | Listen |
|---|---|---|---|---|---|---|
| FluidR3_GM (148,398,306 bytes) | Yamaha Grand Piano | -27.9 LUFS | -13.5 dBFS | 11.379 s | 274,642 bytes | |
| TimGM6mb (5,969,788 bytes) | Piano 1 | -33.0 LUFS | -17.4 dBFS | 11.919 s | 287,808 bytes |
What this means in practice: if you compare SoundFonts by ear, match their loudness first, because in a quick A/B the louder file usually seems better. A larger SoundFont is not automatically the right choice; it is a download size and memory cost, and the sound is a matter of taste. Listen to both files above.
Which instrument will my MIDI play with?
Your MIDI plays with whatever instrument its program number selects, and files from our converter are set to program 0, which General MIDI maps to acoustic grand piano. We checked all four converter MIDI files published on this site: each contains program_change 0 on channel 0. To render a different sound, change that number in a MIDI editor or DAW, or pick another instrument for the track before you export.
We changed only the program number of the vocal MIDI and rendered each version with FluidR3_GM at gain 0.8:
| Program | Preset name in FluidR3_GM | Integrated loudness | Rendered length | Sound below -60 dBFS from | MIDI and MP3 |
|---|---|---|---|---|---|
| 0 | Yamaha Grand Piano | -27.9 LUFS | 11.379 s | 9.524 s | MIDI · |
| 48 | Strings | -29.5 LUFS | 13.063 s | 9.782 s | MIDI · |
| 52 | Ahh Choir | -28.9 LUFS | 12.829 s | 9.772 s | MIDI · |
| 73 | Flute | -31.9 LUFS | 11.130 s | 9.370 s | MIDI · |
The four instruments differ by 4.0 LU in loudness at identical settings, so a mix of instruments needs level balancing before export. For a MIDI made from a voice, a sustained preset such as choir or flute often follows the sung line more naturally than a piano, whose notes decay; that is a listening judgement, so compare the files yourself.
Why is my MIDI to MP3 render so quiet?
A MIDI to MP3 render from FluidSynth is quiet because its master gain defaults to 0.2, and at that setting our render measured -39.9 LUFS with a peak of -25.6 dBFS, far below full scale. Gain is a linear amplitude factor, so the change in level is 20 × log10(new gain ÷ old gain).
| Gain | Predicted change | Integrated loudness | Sample peak |
|---|---|---|---|
| 0.2 (default) | — | -39.9 LUFS | -25.6 dBFS |
| 0.8 | 20 × log10(0.8 ÷ 0.2) = +12.04 dB | -27.9 LUFS (+12.0 LU) | -13.5 dBFS (+12.1 dB) |
The measurement matched the formula, and the peak stayed 13.5 dB below clipping. Our test file is a single melody line; a MIDI with chords or many tracks sums more voices at once, so check the peak after raising the gain. If you need a specific loudness, FFmpeg’s loudnorm filter can set it: loudnorm=I=-23:TP=-1:LRA=11 (the EBU R 128 broadcast target) brought our render to -23.3 LUFS in a single pass.
Why is the MP3 longer than the MIDI?
An MP3 rendered from MIDI runs longer than the MIDI because the synthesizer keeps writing audio after the last note-off while the instrument releases and the reverb fades: our MIDI ends at 8.875 s, and the renders ran 11.130 s to 13.063 s (2.255 to 4.188 s longer), but the sound dropped below -60 dBFS between 9.201 s and 9.782 s.
Keep the tail if the last note should ring out. To cut the near-silent end, this FFmpeg filter removes trailing audio below -60 dB; it shortened our piano render from 11.379 s to 9.200 s:
ffmpeg -i song.wav -af "areverse,silenceremove=start_periods=1:start_threshold=-60dB,areverse" trimmed.wav
The start of the MP3 is not trimmed by the synth: our file begins with 0.534 s of silence because the first note in the MIDI starts there. If your MP3 starts late, check the first note, as in first note starts late.
What bitrate should I use for MIDI to MP3?
192 kbps is a reasonable default for a rendered MIDI file, and the file size follows the bitrate almost exactly: size in bytes ≈ kbps × 1000 ÷ 8 × seconds. We encoded the same 11.379-second piano render four ways (FFmpeg reports 11.416 s for each MP3 because the encoder adds padding):
| Setting | Formula estimate | Actual file |
|---|---|---|
| 128 kbps constant | 128,000 ÷ 8 × 11.416 = 182,656 bytes | 183,109 bytes |
| 192 kbps constant | 192,000 ÷ 8 × 11.416 = 273,984 bytes | 274,642 bytes |
| 320 kbps constant | 320,000 ÷ 8 × 11.416 = 456,640 bytes | 457,708 bytes |
Variable, -q:a 2 | depends on the audio | 177,209 bytes (average 124 kbps) |
For comparison, the MIDI that produced all of this is 384 bytes, so the 192 kbps MP3 is about 715 times larger. That is the difference between storing note instructions and storing sound. The variable setting came out smaller than 128 kbps constant here because the render is sparse and quiet; a dense mix would use more bits.
Does a mid-file tempo change change this page’s WAV and MP3 length?
Yes. This page’s in-browser converter follows a tempo map written in the middle of the file, and the output length matches the duration computed from that map plus the converter’s fixed 2.0 s tail. We built a 61-byte Type 0 MIDI at 480 ticks per quarter: four beats at 120 BPM (500,000 µs per quarter) on C4, then a set-tempo event to 60 BPM (1,000,000 µs per quarter) and four beats on E4. The tempo-map duration is 4 × (60 / 120) + 4 × (60 / 60) = 2.000 + 4.000 = 6.000 s to the last note-off, computed from the ticks and tempo events before any render.
On 2026-11-10 we chose that file through this page’s own file input in headless Chrome, running the local copy of the same /vendor/midi-render/midi-render.js worker and TimGM6mb SoundFont the live tool uses. The converter reported midiSeconds = 6 and wrote a WAV of 8.000 s (ffprobe; 1,411,244 bytes at 44,100 Hz 16-bit stereo, which is 8 × 176,400 + 44) and an MP3 of 8.045708 s / 193,097 bytes at 192 kbps. The extra 2.000 s of WAV is the same ring-out tail already described on this page (the worker renders midiSeconds + 2 seconds).
A control file with the same two notes but no second tempo event lasts 4.000 s of notes. The converter reported midiSeconds = 4, and the WAV is 6.000 s / 1,058,444 bytes, with the MP3 at 6.034250 s / 144,822 bytes. The first 2.000 s of the tempo-map WAV is sample-identical to the first 2.000 s of that control (correlation 1.000). The slowdown appears only after the mid-file tempo event: the second note occupies 4.000 s of audio, not 2.000 s. If the renderer had ignored the 60 BPM change, both files would have been 6.000 s of WAV. They were not.
| Input MIDI | Expected notes (tempo map) | Converter midiSeconds | WAV (ffprobe) | WAV size | MP3 (ffprobe) | MP3 size |
|---|---|---|---|---|---|---|
| tempo-map 120 → 60 BPM (61 B) | 6.000 s | 6 | 8.000 s | 1,411,244 B | 8.045708 s | 193,097 B |
| Same notes, flat 120 BPM | 4.000 s | 4 | 6.000 s | 1,058,444 B | 6.034250 s | 144,822 B |
The 2.000 s gap between midiSeconds and the WAV length is the converter’s tail, not a second tempo bug. A tool that only multiplied “beats ÷ starting BPM” would have called the tempo-map file 4 seconds long and would have missed the 8.000 s WAV we actually got.
Does a mid-track program change switch the instrument in the render?
Yes. A program change in the middle of the track is followed by this page’s renderer; the second note is not left on the first patch. This is a different question from the existing instrument test, which compared four whole files that each carried a single program number.
The test MIDI (58 bytes, 120 BPM) plays C4 for 1.000 s on program 0 (acoustic grand / Piano 1), rests 0.500 s, then sends program 73 (flute) and plays the same C4 for 1.000 s. Note-off of the second note is at 2.500 s. Two control MIDIs used the same timing but stayed on program 0 or program 73 for both notes. All three files were converted on this page on 2026-11-10. Each produced a 4.500 s WAV (793,844 bytes) and a 4.545292 s / 109,087-byte MP3, matching midiSeconds 2.5 plus the 2.0 s tail.
We compared the first-note window (0.0–1.0 s) and the second-note window (1.5–2.5 s) of the mid-track file to the same windows of the two controls, after the converter’s own −1 dBFS normalization. The first note correlates 1.0000 with the all-program-0 control and −0.0789 with the all-program-73 control; its spectral centroid is 834.4 Hz versus 830.7 Hz (piano) and 1,525.7 Hz (flute). The second note correlates 1.0000 with the all-program-73 control and −0.0767 with the all-program-0 control; its centroid is 1,524.4 Hz versus 1,524.8 Hz (flute) and 829.4 Hz (piano). The mid-track file’s pre-normalization peak was 0.09085, matching the flute control (0.09081) rather than the piano control (0.06773), because the flute note is the louder voice and sets the file peak.
| Window in the mid-track file | vs all program 0 | vs all program 73 | Centroid (Hz) | What it played |
|---|---|---|---|---|
| 0.0–1.0 s (after program 0) | correlation 1.0000 | correlation −0.0789 | 834.4 (piano control 830.7) | Program 0, Piano 1 |
| 1.5–2.5 s (after program 73) | correlation −0.0767 | correlation 1.0000 | 1,524.4 (flute control 1,524.8) | Program 73, flute |
The renderer switched patches at the mid-track program change. If it had ignored program 73, the second window would have matched the piano control, not the flute control.
What does this converter play when the bank is not in TimGM6mb?
It does not go silent. It falls back to bank 0, program 0 (Piano 1), and it does that for every non-GM bank we tried. Honesty first: we listed the presets in the same TimGM6mb SoundFont this page loads (5,969,788 bytes). Bank 0 contains all 128 General MIDI programs, and bank 128 contains 8 drum kits. There is no missing GM program number on the default bank, so a “missing program 0–127 on bank 0” test cannot fail here. The case we could actually run is a bank the SoundFont does not include.
We wrote 2.000 s C4 notes at velocity 96 with program 0 after a bank-select (CC0 / CC32) of MSB 1, 8, 16, or 127 — none of those banks exist in TimGM6mb. Each file was converted on this page on 2026-11-10. The worker did not return its silent error. Every run reported the same pre-normalization peak, 0.06772678345441818, which is also the peak of our all-program-0 piano control. All four WAVs are byte-identical (md5 ddd66f597cf87c4c4895c54c2711d91e), 4.000 s / 705,644 bytes, with matching 4.048958 s / 97,175-byte MP3s.
The first 1.000 s of each missing-bank WAV, peak-normalized, correlates 1.0000 with the first 1.000 s of the program-0 piano control. A fifth file played the bank-16 note for 2.000 s and then selected bank 0, program 0 for a G4 at 2.5–4.5 s: the first 2.000 s is identical in correlation (1.0000) to the bank-16-only file, and the later G4 is also audible piano (RMS 0.1209, centroid 988.8 Hz), not silence. The 0.5 s rest between those notes is only a release tail (RMS 0.00674), not a missing-patch mute.
| Request | In TimGM6mb? | Converter result | WAV / MP3 | Evidence it is Piano 1, not silence |
|---|---|---|---|---|
| Bank MSB 16, program 0, 2 s C4 | No (banks present: 0 and 128 only) | Audio written; no silent error; peak 0.06773 | 4.000 s / 705,644 B WAV; 4.048958 s / 97,175 B MP3 | Byte-identical to the MSB 1, 8 and 127 runs; 1.0000 correlation with the program-0 piano control |
| Bank MSB 1, 8 or 127, program 0, same note | No | Same fallback | Same four-byte-identical WAVs (md5 ddd66f59…) | Same peak, same length, same md5 |
| Bank MSB 16 then bank 0 program 0 | Second select is the default bank | Both notes audible | 6.500 s / 1,146,644 B WAV; 6.530583 s / 156,734 B MP3 | First 2 s matches the bank-16-only WAV (corr 1.0000); later G4 RMS 0.1209, not zero |
If you send a GS or XG variation bank this tool does not have, expect the default piano, not a hole of silence, and not a unique variation preset. A bank-0 program that does exist in TimGM6mb will play as that GM instrument; that case is not “missing.”
Method and assumptions
| Item | Value |
|---|---|
| Input MIDI | Output of our live converter from a real singing clip (2026-10-10): type 0, 1 track, 480 ticks per beat, 120 BPM, 40 notes |
| Original recording | Clip vocadito_10 from vocadito, version v3 (2021) by Rachel Bittner, Katherine Pasalo, Juan José Bosch, Gabriel Meseguer Brocal and David Rubinstein, CC BY 4.0; the MIDI and the renders are machine-generated from it |
| Instrument variants | Same file with only the program number changed (rewritten with the mido library, 382 bytes) |
| Synthesizer | FluidSynth 2.4.4, 44,100 Hz stereo, reverb and chorus on (defaults) |
| SoundFonts | FluidR3_GM 3.1 and TimGM6mb 1.3 (Debian packages) |
| Encoder | FFmpeg 7.1.5 with libmp3lame |
| Measurements | Loudness and sample peak: FFmpeg ebur128; end of audible sound: silencedetect at -60 dB for at least 0.3 s; durations: ffprobe |
| WAV tests (2026-10-19) | Same MIDI and FluidR3_GM re-rendered with FluidSynth 2.4.4 at -O s16/s24/float, -r 44100/48000 and gain 0.8/2.0/4.0; mono and -1 dB versions with FFmpeg 7.1.5; peaks and over-full-scale samples counted from the audio data; values in wav-results.json |
| Limits | One short single-line melody, one computer. Loudness and length will differ for other files and SoundFonts; the method is what transfers. |
All values are in results.json.
Want the other direction?
If you have an MP3 or WAV and want the notes as MIDI, that is what this site does, free and without uploading your audio: open the MP3 to MIDI converter. For how the two directions relate, see the MIDI converter round-trip test.
Questions
Can this site convert MIDI to MP3 or WAV?
Yes. The converter at the top of this page renders a MIDI file to a 44,100 Hz stereo WAV or a 192 kbps MP3 in your browser, using the TimGM6mb SoundFont; the file is not uploaded. Offline, FluidSynth with a SoundFont makes the WAV and an encoder such as FFmpeg makes the MP3.
Why does my MIDI play as piano in the MP3?
A MIDI plays as piano in the MP3 because most MIDI files, including every file our converter writes, carry program 0, which General MIDI players map to an acoustic grand piano. Change the program number or the track instrument before rendering to get another sound.
Why is my MIDI to MP3 file so quiet?
A MIDI to MP3 file rendered with FluidSynth's default master gain of 0.2 is quiet: it measured -39.9 LUFS in our test, and a gain of 0.8 raised it by 12.0 LU to -27.9 LUFS with the peak still at -13.5 dBFS.
Why is the MP3 longer than the MIDI file?
The MP3 is longer than the MIDI because the synthesizer keeps rendering while notes release and reverb fades: our 8.875-second MIDI produced MP3s of 11.1 to 13.1 seconds of audio, depending on the instrument; the sound was below -60 dBFS for the last 1.8 to 3.3 seconds.
Should I render MIDI to a 16-bit, 24-bit or float WAV?
Render MIDI to a 32-bit float WAV when you will still change the level, because float keeps peaks above full scale: at gain 4.0 our float WAV peaked at +0.47 dBFS and a -1 dB change brought it back intact, while the 16-bit render of the same notes had 7 samples cut off at 0 dBFS. For a finished file, 16-bit is half the size of float.
How big is a WAV rendered from MIDI?
A WAV rendered from MIDI is sample rate × channels × bytes per sample × seconds, plus a small header: our 11.379-second 16-bit 44,100 Hz stereo render is 2,007,340 bytes (44-byte header), 7.3 times the 192 kbps MP3 of the same render. 24-bit is 1.5 times and float 2 times the 16-bit size.
Will converting MIDI to MP3 give back the original recording?
No, converting MIDI to MP3 cannot give back the original recording, because a MIDI file holds notes, not sound. The MP3 contains whatever instrument you render with, so a MIDI made from a singer will be played by piano, choir, flute or any other preset you choose.
Sources
- FluidSynth user manual (command-line options, fast render, gain,
-Osample format,-rsample rate) - FFmpeg filters documentation (ebur128, silencedetect, silenceremove, loudnorm)
- FFmpeg MP3 encoding guide (libmp3lame constant and variable bitrate)
- The MIDI Association: General MIDI (program numbers select instrument sounds)
- EBU R 128 (loudness normalisation, -23 LUFS target)