WebM to MP4: Convert Screen Recordings and Browser Downloads

You recorded a five-minute tutorial on your phone or grabbed a clip with a browser-based capture tool, dropped the file into iMovie, and got "the file format is not supported." Or you AirDropped it to an iPhone and Photos showed a grey box. The recording is fine — the container and codecs aren't. Converting WebM to MP4 isn't a rename job: you have to re-encode the video to H.264 and the audio to AAC, and while you're at it, lock the frame rate. Below is exactly how to do that, both in a browser and with one ffmpeg command.

Why WebM breaks in editors and on older iPhones

WebM is a container, like MP4 or MOV. What matters is what's inside it — and WebM only ever holds codecs that consumer editing software has been slow to adopt.

The codec mismatch: VP8, VP9, AV1 and Opus

A WebM file carries VP8, VP9 or AV1 video plus Vorbis or Opus audio. Chrome, Firefox and Android decode all of that natively, which is why the recording plays perfectly on the device that made it. Desktop editors are a different story: iMovie and Final Cut expect H.264, HEVC or ProRes; Premiere Pro can be hit-or-miss with VP9 and usually refuses Opus audio outright; Windows Media Player on older installs shows the classic "can't play" error for an Android screen recording.

The VP9 vs H.264 compatibility gap is the whole problem in one line: VP9 is royalty-free and great for streaming, H.264 is the format every camera, phone, TV and NLE has been able to decode in hardware for over a decade. iPhones before the iPhone 12 era have no VP9 hardware decoder at all, so a WebM file simply won't open in Photos — the share sheet will hand it to a third-party player or nothing at all.

The second trap: variable frame rate

Screen recorders are lazy on purpose. When nothing moves on screen, they emit fewer frames; when you scroll, they emit more. That's variable frame rate (VFR), and it keeps file sizes tiny. Editors hate it. Drop a VFR clip on a 30 fps timeline and audio drifts out of sync — usually a few frames at the start, half a second by minute four.

So a proper conversion does two things: swap the codecs, and resample the timeline to a constant frame rate (CFR).

The fast route: convert WebM to MP4 in your browser

If you have one or two clips and no appetite for the command line, use our WebM to MP4 converter — drop the file in, get an H.264 + AAC MP4 back, no install, no account.

Practical notes for screen recordings specifically:

• Expect the file to grow. A 5-minute 1080p60 VP9 screen capture might be 38 MB. The same content as H.264 at a good quality setting lands around 90–120 MB. VP9 is simply more efficient; you're trading bytes for compatibility.
• Keep the original. Re-encoding is lossy. Archive the WebM, edit from the MP4.
• Check the audio. If the source had Opus, the output should report AAC. Anything still labelled Opus inside an MP4 will fail on iOS.
• Do it before you edit, not after. Converting a finished export twice compounds the quality loss.

If your workflow also involves MKV, MOV or AVI files from other tools, the video converter hub covers the same round trips.

The precise route: one ffmpeg command

For batches, long recordings, or when you want to dictate the exact frame rate, ffmpeg is the tool. Start by looking at what you actually have:

ffprobe -v error -select_streams v:0 \
  -show_entries stream=codec_name,width,height,r_frame_rate,avg_frame_rate \
  -of default=noprint_wrappers=1 screen-recording.webm

Typical output for an Android capture:

codec_name=vp9
width=1080
height=2400
r_frame_rate=60/1
avg_frame_rate=2937/64

r_frame_rate says 60, avg_frame_rate works out to about 45.9. That mismatch is your VFR confirmation. Now convert:

ffmpeg -i screen-recording.webm \
  -c:v libx264 -preset medium -crf 20 \
  -pix_fmt yuv420p -fps_mode cfr -r 30 \
  -c:a aac -b:a 192k -ar 48000 \
  -movflags +faststart \
  screen-recording.mp4

What each flag buys you:

• -c:v libx264 — H.264 video, the universally decodable choice.
• -crf 20 — quality target. 18 is near-transparent and large, 23 is the default, 20 is a good balance for text-heavy screen content. Lower number = better quality = bigger file.
• -pix_fmt yuv420p — forces 4:2:0 chroma. Without it, some sources produce yuv444p, which QuickTime and Premiere refuse to open.
• -fps_mode cfr -r 30 — constant 30 fps output, duplicating or dropping frames as needed. On older ffmpeg builds use -vsync cfr instead. Use -r 60 if your recording is genuinely 60 fps gameplay.
• -c:a aac -b:a 192k — converts Opus/Vorbis to AAC. Non-negotiable for iOS and most editors.
• -movflags +faststart — moves the index to the front of the file so it starts playing before it fully downloads. Essential if the MP4 is going on a website.

On a modern laptop that runs faster than real time; a 10-minute 1080p clip takes roughly two to four minutes.

Batch converting a folder of captures

Tutorial creators rarely have one file. On macOS or Linux:

for f in *.webm; do
  ffmpeg -i "$f" -c:v libx264 -preset medium -crf 20 \
    -pix_fmt yuv420p -fps_mode cfr -r 30 \
    -c:a aac -b:a 192k -movflags +faststart \
    "${f%.webm}.mp4"
done

Windows PowerShell equivalent:

Get-ChildItem *.webm | ForEach-Object {
  ffmpeg -i $_.Name -c:v libx264 -crf 20 -pix_fmt yuv420p `
    -fps_mode cfr -r 30 -c:a aac -b:a 192k `
    "$($_.BaseName).mp4"
}

Targeting a specific device or platform

If the MP4 still misbehaves on an older phone or a smart TV, constrain the H.264 profile:

-profile:v high -level 4.0

For really old hardware, -profile:v baseline -level 3.1 at 720p is the safest combination ever shipped. And if your phone recorded a tall 1080x2400 frame, most editors handle it fine — but if you need a standard canvas, add -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2".

A five-point checklist before you hit the timeline

• Run ffprobe (or check the file info panel) — confirm the output says h264 and aac, not vp9 and opus.
• Confirm a single frame rate value: r_frame_rate and avg_frame_rate should now match.
• Play the last 30 seconds and watch lip sync or click sync. Drift shows up at the end, not the start.
• Verify the pixel format is yuv420p if any Apple software is involved.
• Keep the WebM original in a /source folder until the project is delivered.

Do this once and the WebM problem stops being a problem: your recorder keeps saving small, efficient files, and you spend thirty seconds turning each one into something every editor and every iPhone will happily open.

Frequently asked questions

Can I just rename .webm to .mp4?

No. The extension doesn't change the bytes inside. A renamed file may even open in VLC (which ignores extensions) and then fail everywhere else, which is the most confusing possible outcome. You need a real re-encode.

Why won't my WebM file open on iPhone?

iOS Photos doesn't import WebM, and older iPhone chips have no VP9 hardware decoder. Some third-party players will play it, but you can't edit it, share it to most apps, or add it to a Photos album. Converting to H.264 + AAC MP4 fixes all three.

Will converting lose quality?

Slightly — any lossy-to-lossy re-encode does. At -crf 18 to -crf 20 the difference is invisible on screen recordings, which are mostly flat UI and text. Convert once, from the original, and don't re-export the MP4 repeatedly.

Why is my MP4 bigger than the WebM?

VP9 and AV1 compress roughly 30–50% better than H.264 at the same visual quality. Growing from 38 MB to 100 MB is normal and expected. If size matters, raise CRF to 23 or drop the resolution to 720p.

Why does my Android screen recording not play on Windows?

Either the container is WebM, or it's an MP4 with HEVC inside and Windows lacks the HEVC extension. Check the codec first with ffprobe or MediaInfo — the fix is the same either way: re-encode to H.264 + AAC.

Does the online converter work for large files?

For typical tutorial clips, yes. For hour-long lecture captures or dozens of files at once, the ffmpeg loop above is faster and avoids uploading gigabytes.