Convert MOV to MP4 online

How to convert MOV to MP4 in your browser

1. 01

   Open the file

   Drag your MOV onto the drop zone above, or click it and pick the file. If a dragged file appears to do nothing, click the drop zone and choose it instead — the drag handler only accepts files your operating system has labelled as video, and it labels some MOV files as nothing at all. Either way it is read straight off your disk into the browser tab; nothing is sent anywhere.

2. 02

   Check that MP4 is selected

   The Output format control below the timeline is already set to MP4 on this page. If you also want to trim the clip, add a cut now — it costs nothing extra because the video is being re-encoded anyway.

3. 03

   Optionally cap the resolution or mute

   Max resolution caps the height at 1080p, 720p or 480p (it never upscales), and Mute audio drops the audio track. Both are optional and both are applied in the same pass as the conversion.

4. 04

   Press Convert video

   With no cuts or speed changes queued, the apply button reads "Convert video". Press it. The first run downloads the ~32 MB FFmpeg engine, which the browser caches for next time.

5. 05

   Download

   When the encode finishes a download link appears with the size of the finished file next to it. Compare it against the original before you delete anything.

Who has a MOV file, and why it will not play

MOV is Apple's QuickTime container. iPhones and iPads record into it, so does the macOS screen recorder, and so do a lot of cameras that grew up in Apple-centric workflows. If someone AirDropped you a video or you pulled one off an iPhone with a cable, it is almost certainly a .mov.

The trouble is rarely the container. Since iOS 11 an iPhone records HEVC (H.265) video by default, under the Camera setting called "High Efficiency". HEVC is a good codec, but a lot of software still does not decode it: older Windows machines without the paid extension, many web upload forms, a good number of Android phones and most in-browser players. So the file "will not open", and the extension gets the blame.

Converting here fixes both halves at once. The container becomes MP4, and the video is re-encoded to H.264 with AAC audio, which is the single most widely playable combination there is. If your MOV was already H.264 — an iPhone set to "Most Compatible", or a camera that records that way — the container change is the only part you needed, and a lossless remux (below) would have done it without touching the picture.

What actually changes between MOV and MP4

Less than you would think. MP4 was derived from the QuickTime format in 2001, and both are members of the ISO base media file family: the same atom/box structure, the same moov and mdat layout, the same track model. A MOV and an MP4 carrying the same H.264 stream differ by a few header bytes and a brand identifier. That is why the two open interchangeably in most software and why renaming one to the other occasionally even works, although you should not rely on it.

What changes on this page is the encode, not just the wrapper. FFmpeg decodes whatever is inside the MOV — H.264, HEVC, ProRes if the build can read it — and writes H.264 with libx264 at the ultrafast preset and CRF 28, plus AAC audio. The output is written fragmented (+frag_keyframe+empty_moov) so it can stream straight out of the in-memory filesystem the WebAssembly build runs on. The formats page covers what that means for very old players.

Extra tracks do not survive. iPhone MOVs often carry a timecode track and a metadata track alongside the video and audio; only one video stream and one audio stream are mapped to the output.

Quality and file size to expect

Going from HEVC to H.264 at the same visual quality normally costs file size, because HEVC is the more efficient codec, and ultrafast makes that worse: it is the preset that spends bits to save CPU time, which is the right trade for an encoder running in a browser tab on your own machine. Expect the MP4 to be larger than the MOV it came from, sometimes noticeably. CRF 28 keeps the picture at a quality most people cannot distinguish from the source on ordinary footage, but it is a generation of lossy compression and it is not lossless.

If size matters more than resolution, set Max resolution to 1080p before converting: 4K iPhone footage capped at 1080p is a quarter of the pixels, encodes noticeably faster and comes out far smaller. Resizing a video explains what each tier is good for.

When a lossless remux is the better answer

ffmpeg -i in.mov -c copy out.mp4

If your MOV is already H.264 with AAC audio and the only thing you need is the .mp4 extension — because a form rejects .mov, say — do not re-encode it at all. On a machine with FFmpeg installed, -c copy rewraps the streams into an MP4 in seconds, byte-for-byte identical picture and sound. The FFmpeg guide has the details.

The same command works for HEVC MOVs, but check whether that helps you: the result is an HEVC MP4, and the players that could not decode the HEVC MOV will not decode the HEVC MP4 either. That case is exactly where a re-encode to H.264, which is what this page normally does, is the right tool.

There is one exception worth knowing, because it is easy to trigger by accident on this page. The editor attempts a lossless stream copy whenever mute is the only change — no cuts, no speed changes, no resolution cap — and the output container is MP4, MKV or MOV. MOV to MP4 with Mute audio ticked meets that description, so FFmpeg runs -c:v copy -an and you get a remux rather than a re-encode. On an H.264 MOV that is the ideal outcome: an MP4 with the picture untouched. On an HEVC MOV it is probably not what you wanted, because the copy succeeds and hands back an HEVC MP4 — the file the paragraph above warns about. If you are converting an iPhone MOV specifically to escape HEVC, leave Mute audio off, or set a Max resolution, so the re-encode to H.264 runs.

Everything else on this page is a genuine re-encode. Cuts, speed changes and the resolution cap all run through a filter graph, and a stream that is being filtered cannot be copied.

What stays the same on every conversion here

Nothing is uploaded. The file is read from your disk into the tab, FFmpeg compiled to WebAssembly does the decode and the encode there, and the result is handed back as a download. What does and does not leave your device is spelled out in full. There is no account, no watermark and no size cap other than the memory of the device you are on, since the whole file lives in RAM while it is being worked on.

The first conversion downloads the engine, roughly 32 MB, which the browser caches afterwards. Where SharedArrayBuffer is available the multi-threaded core is used and the encode runs across your CPU cores; otherwise a single-threaded build takes over and the same job takes several times longer. How it works walks through the pipeline, and the FAQ covers the rest.

Questions about converting MOV to MP4