mp3tomidiflowOpen converter

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
What each part of the render command does
OptionMeaningWhy it matters for MIDI to MP3
-niNo MIDI input device, no interactive shellLets the command finish on its own
-g 0.8Master gain (FluidSynth default 0.2)Sets the loudness of the WAV, and so of the MP3 (see the gain test)
-r 44100Sample rate in Hz44,100 Hz is the usual rate for MP3 music files
-F song.wavFast render to a file instead of the speakersWrites the audio as fast as the computer can, not in real time
FluidR3_GM.sf2The SoundFontDecides 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:

Same MIDI, five WAV settings. Size formula = sample rate × channels × bytes per sample × seconds + header. Header measured as file size minus the audio data.
WAV settingHow we made itAudio data (formula)HeaderFile sizePer minute of audio
16-bit, 44,100 Hz, stereo-r 44100 (default format)44,100 × 2 × 2 × 11.379229 s = 2,007,296 bytes44 bytes2,007,340 bytes10,584,000 bytes
24-bit, 44,100 Hz, stereo-O s2444,100 × 2 × 3 × 11.379229 s = 3,010,944 bytes44 bytes3,010,988 bytes15,876,000 bytes
32-bit float, 44,100 Hz, stereo-O float44,100 × 2 × 4 × 11.379229 s = 4,014,592 bytes88 bytes (adds fact and PEAK chunks)4,014,680 bytes21,168,000 bytes
16-bit, 48,000 Hz, stereo-r 4800048,000 × 2 × 2 × 11.380 s = 2,184,960 bytes44 bytes2,185,004 bytes11,520,000 bytes
16-bit, 44,100 Hz, mono16-bit file, then ffmpeg -ac 144,100 × 1 × 2 × 11.379229 s = 1,003,648 bytes78 bytes (FFmpeg adds a LIST chunk)1,003,726 bytes5,292,000 bytes

The formula matched every file to the byte once the header was counted. Three findings change what you should pick:

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.

Live run of the converter at the top of this page on 2026-10-20 (headless Chrome, file chosen through the page's own file input; the blob the page produced was saved and measured with ffprobe and a loudness meter).
OutputSizeLengthFormatLoudness / peakSize vs MIDI
WAV3,175,244 B18.00 s44.1 kHz, 16-bit, stereo-16.3 LUFS / -1.0 dBFS2,323×
MP3433,214 B18.05 s192 kbps, stereo-16.6 LUFS / -1.3 dBFS317×

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:

Same MIDI, FluidR3_GM, program 0. Predicted peak = -13.51 dBFS + 20 × log10(gain ÷ 0.8). Samples over full scale counted from the audio data.
GainPredicted peak16-bit WAVFloat 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 dBFS0.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.

Same MIDI, same command (gain 0.8, 44,100 Hz, reverb and chorus at default), two General MIDI SoundFonts, program 0
SoundFont (file size)Preset usedIntegrated loudnessSample peakRendered lengthMP3 at 192 kbpsListen
FluidR3_GM (148,398,306 bytes)Yamaha Grand Piano-27.9 LUFS-13.5 dBFS11.379 s274,642 bytes
TimGM6mb (5,969,788 bytes)Piano 1-33.0 LUFS-17.4 dBFS11.919 s287,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:

One melody, four programs (FluidR3_GM, gain 0.8). Program numbers count from 0; some lists count from 1, so program 52 appears there as 53.
ProgramPreset name in FluidR3_GMIntegrated loudnessRendered lengthSound below -60 dBFS fromMIDI and MP3
0Yamaha Grand Piano-27.9 LUFS11.379 s9.524 sMIDI ·
48Strings-29.5 LUFS13.063 s9.782 sMIDI ·
52Ahh Choir-28.9 LUFS12.829 s9.772 sMIDI ·
73Flute-31.9 LUFS11.130 s9.370 sMIDI ·

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 formula and measured result (FluidR3_GM, program 0, vocal MIDI)
GainPredicted changeIntegrated loudnessSample peak
0.2 (default)—-39.9 LUFS-25.6 dBFS
0.820 × 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):

Same WAV, four MP3 settings (libmp3lame)
SettingFormula estimateActual file
128 kbps constant128,000 ÷ 8 × 11.416 = 182,656 bytes183,109 bytes
192 kbps constant192,000 ÷ 8 × 11.416 = 273,984 bytes274,642 bytes
320 kbps constant320,000 ÷ 8 × 11.416 = 456,640 bytes457,708 bytes
Variable, -q:a 2depends on the audio177,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.

Headless run of this page’s converter, 2026-11-10, Asia/Shanghai. Expected note length is computed from the MIDI tempo map, not from the output file.
Input MIDIExpected notes (tempo map)Converter midiSecondsWAV (ffprobe)WAV sizeMP3 (ffprobe)MP3 size
tempo-map 120 → 60 BPM (61 B)6.000 s68.000 s1,411,244 B8.045708 s193,097 B
Same notes, flat 120 BPM4.000 s46.000 s1,058,444 B6.034250 s144,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.

Windowed comparison of this page’s WAVs, 2026-11-10. Correlation is scale-invariant; centroids are from a Hann-windowed rFFT of the mono mix.
Window in the mid-track filevs all program 0vs all program 73Centroid (Hz)What it played
0.0–1.0 s (after program 0)correlation 1.0000correlation −0.0789834.4 (piano control 830.7)Program 0, Piano 1
1.5–2.5 s (after program 73)correlation −0.0767correlation 1.00001,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.

This page’s converter, 2026-11-10, TimGM6mb. “Missing” means the bank is absent from the SoundFont, not that GM program 0 is undefined.
RequestIn TimGM6mb?Converter resultWAV / MP3Evidence it is Piano 1, not silence
Bank MSB 16, program 0, 2 s C4No (banks present: 0 and 128 only)Audio written; no silent error; peak 0.067734.000 s / 705,644 B WAV; 4.048958 s / 97,175 B MP3Byte-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 noteNoSame fallbackSame four-byte-identical WAVs (md5 ddd66f59…)Same peak, same length, same md5
Bank MSB 16 then bank 0 program 0Second select is the default bankBoth notes audible6.500 s / 1,146,644 B WAV; 6.530583 s / 156,734 B MP3First 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

How the tests on this page were made
ItemValue
Input MIDIOutput 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 recordingClip 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 variantsSame file with only the program number changed (rewritten with the mido library, 382 bytes)
SynthesizerFluidSynth 2.4.4, 44,100 Hz stereo, reverb and chorus on (defaults)
SoundFontsFluidR3_GM 3.1 and TimGM6mb 1.3 (Debian packages)
EncoderFFmpeg 7.1.5 with libmp3lame
MeasurementsLoudness 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
LimitsOne 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

Open the free MP3 to MIDI converter