How to convert MP4 to MOV on Mac (lossless, batch, 2026)

The footage is fine. It plays in QuickTime, it AirDrops, it uploads anywhere modern. But the destination in front of you — the agency’s delivery spec, the broadcast ingest portal, the ancient-but-load-bearing Mac app in the middle of your pipeline, the client who wrote “please send as QuickTime” — wants a .mov, and your file ends in .mp4. The upload form rejects it at the door, or the app greys it out in the open dialog, and no amount of “but it’s the same thing” typed into an email changes the validator’s mind.

Here’s the good news, and it’s better than in almost any other conversion: to convert MP4 to MOV on a Mac is very often a lossless, seconds-fast job. The two formats are so closely related that in the common case nothing needs to be re-encoded at all — the video just moves into a different box. This guide covers when that applies (almost always, in this direction), the built-in route, the Terminal route, and the drag-a-folder batch route — all on-device, all offline.

In this guide8 sections

MP4 and MOV: the same family, and this direction is the easy one

MOV is Apple’s QuickTime container. MP4 is the international standard that was literally derived from it — the MPEG-4 file format was based on Apple’s QuickTime format, which is why the two look so similar under the hood. Both are just boxes; the actual picture and sound inside are produced by codecs, most commonly H.264 or HEVC video with AAC audio.

That family relationship has a useful asymmetry. Going MOV to MP4, you occasionally hit contents MP4 can’t hold — ProRes video, PCM audio — and need a real re-encode. Going the other way, MP4 to MOV, that trap barely exists: MOV is the more permissive container. Everything an MP4 commonly carries — H.264, HEVC, AAC, even MP3 audio — sits in a MOV without complaint. So in this direction, a remux (also called a stream copy: the streams are copied bit-for-bit into the new container, nothing decoded, nothing recompressed) works essentially every time. It runs at disk speed rather than encoding speed, and the output is pixel-identical to the input.

Which also frames the one shortcut to rule out: renaming the file from .mp4 to .mov. Because the containers are cousins, some apps will open the renamed file — and that’s precisely why the trick is a gamble. The file is still an MP4 inside, and the strict software you’re doing this for — ingest systems, QC validators, delivery portals — is exactly the software most likely to inspect the container and bounce it. A remux takes barely longer than a rename and produces a file that is actually what its extension claims.

Who actually needs this conversion

Worth naming, because “MP4 to MOV” puzzles people who know the formats are near-twins:

• Delivery specs. Broadcast, agency, and stock-footage delivery requirements routinely specify “QuickTime .mov” — sometimes for historical reasons, sometimes because their QC pipeline was built on QuickTime tooling. The spec doesn’t care that your MP4 holds the same H.264; it checks the box, and the box must say MOV.
• Extension-whitelisting apps and portals. Plenty of upload forms, media asset managers, and older Mac applications filter the open dialog by extension. .mov is selectable; .mp4 is greyed out. The gatekeeping is dumb, but it’s their gate.
• Legacy Mac and pro-video workflows. Pipelines that grew up on QuickTime — compositing tools, mograph render chains, review systems — often expect MOV in and MOV out, and misbehave or refuse on MP4.
• Consistency. A project where every other asset is a MOV, and one MP4 from a phone or a download is the odd file out that keeps tripping the batch script.

In every one of those cases the pixels are already fine. You’re converting the label on the box — which is why the lossless path matters so much here.

Built-in route: QuickTime Player (finally in its element)

QuickTime Player has a running joke against it in the reverse direction: its File → Export As can’t produce an MP4 at all — everything it exports comes out as a .mov. For this conversion, that limitation is the feature:

1. Open the .mp4 in QuickTime Player (it opens MP4s containing H.264 or HEVC natively).
2. Choose File → Export As and pick a resolution — use the one matching your source; exporting 1080p footage “as 4K” invents nothing.
3. Save. The output is a genuine .mov.

Free, already installed, no Terminal. The catch: Export As always re-encodes. Even when the source is already H.264, QuickTime decodes and recompresses every frame — slow on long clips, and it costs a small, permanent slice of quality for no reason. It also does one file at a time, with a full export wait per file. For a single short clip headed to a mildly picky app, it’s fine. For anything under a delivery spec — where quality is being graded — or anything plural, use a remux instead.

Method 2: ffmpeg (free, lossless, command-line)

If you’re comfortable in Terminal, ffmpeg (installable via Homebrew: brew install ffmpeg) does the perfect version of this conversion:

ffmpeg -i input.mp4 -c copy output.mov

-c copy is the stream copy — no re-encoding, zero quality loss, finished in seconds even for multi-gigabyte files. Because MOV accepts everything an MP4 normally contains, this command succeeds where the reverse trip sometimes needs fallbacks. A whole folder:

cd ~/Movies/todeliver
for f in *.mp4; do
  [ -e "$f" ] || continue
  ffmpeg -i "$f" -c copy "${f%.*}.mov"
done

The rare exception: if a destination demands a specific codec inside the MOV — some legacy specs want H.264 regardless of source — and your MP4 contains HEVC (default iPhone footage), copy won’t fix that. Re-encode the video and keep the audio:

ffmpeg -i input.mp4 -c:v libx264 -crf 18 -preset medium -c:a copy output.mov

ffmpeg is free and scriptable; the cost is that you’re the logic. You read the spec, inspect the source (select the file, press ⌘I, read the codec line), and pick the command. For one file that’s a minute’s work. For recurring deliveries it’s a script you now maintain.

Method 3: Zumkor (drag the folder, pick MOV, done)

Zumkor turns the whole job into a drag-and-drop (it needs macOS 14 or later on an Apple silicon Mac — any M-series machine):

1. Open Zumkor and drag in your MP4 files — or the whole folder, subfolders included if you tick “Look inside subfolders”.
2. Pick MOV as the output format. (M4V and MKV are there too, alongside MP4, if a different destination wants a different box — see the full formats list.)
3. Click Convert and choose where the MOVs land.

The parts that matter when this is a real workflow and not a one-off: the queue takes up to 2,000 files in one pass; output goes to a folder you choose — originals stay put, nothing is overwritten — with your folder structure mirrored if you want it; and everything runs on-device, offline, so a client’s unreleased footage never touches a converter site’s server. Conversions keep running with the window closed. If the clip also needs a trim first — the delivery is the middle 40 seconds, not the whole recording — Zumkor’s QuickTime-style trim (the familiar yellow handles) converts only the range you keep, in the same pass. And for a recurring pipeline, Zumkor’s “Convert Files” action in Apple’s Shortcuts app runs the same conversion headless: a folder-watch shortcut can turn every MP4 that lands in a drop folder into a MOV automatically.

Zumkor is free for 7 days, full-featured; after that it’s a one-time $19.99 purchase — buy once, keep it forever, no subscription. The honest trade-off: for one file, QuickTime Player is free and ffmpeg costs only a Homebrew install. Zumkor earns its slot when deliveries recur, when the folder has forty clips, and when the same Mac also collects MKVs that need to become MP4, videos too big to email, and clips that should be GIFs — one app converts all of it.

Getting the output right

• Prefer the remux. In this direction it almost always works, it’s lossless, and it’s instant. Save re-encoding for the one case that demands it: a spec that pins the codec, not just the container.
• Read the spec twice. “QuickTime .mov” sometimes comes with fine print — H.264 only, a resolution, an audio requirement. A remuxed MOV inherits whatever the MP4 contained; if the source is HEVC iPhone footage and the spec says H.264, that’s the one time a re-encode is the correct answer.
• Don’t upsize. Exporting 1080p as “4K” quadruples the file and invents no detail. Match the source resolution.
• Keep the MP4. The MOV is a repackaged copy you can regenerate in seconds. If storage is tight, the original is the file to keep.
• If the MOV also has to be small, that’s a compression job with a size target, not a container swap — the email-compression guide covers landing under Gmail’s 25 MB and friends.
• If what you actually need is the sound, skip the container entirely and extract the audio to MP3 or WAV — converting to MOV first adds nothing.

Bottom line

• One clip, free, re-encoding acceptable: QuickTime Player → File → Export As. Its .mov-only export is, for once, exactly what you want.
• Comfortable in Terminal: ffmpeg -i input.mp4 -c copy output.mov — lossless, done in seconds, loopable over a folder.
• Batches, recurring deliveries, or a drop-folder pipeline: Zumkor — drag the folder, pick MOV, output lands where you choose, up to 2,000 files offline in one pass, one-time $19.99.
• Never: renaming the extension and hoping, or uploading a client’s footage to a web converter to perform a container swap your Mac finishes locally in seconds.

The pixels were never the problem — the box was. Change the box, keep the pixels, stay offline.

FAQ

Can I just rename a .mp4 file to .mov?

Sometimes it will open, because the two containers are close cousins — which is exactly what makes the trick unreliable. The file is still an MP4 internally, and stricter software (ingest systems, upload validators, delivery QC checks) will reject or misread it. A proper remux takes seconds, is lossless, and produces a genuinely valid MOV; renaming saves you nothing but those seconds.

Does converting MP4 to MOV lose quality?

Not if you remux instead of re-encoding. MOV accepts every codec commonly found in an MP4 — H.264, HEVC, AAC — so the streams can be copied bit-for-bit into the new container with zero quality loss, in seconds. Only QuickTime Player’s Export As re-encodes; a stream copy in ffmpeg or a converter app keeps the pixels untouched.

Why does my editor or delivery spec want MOV instead of MP4?

MOV is the QuickTime container that Mac-native and broadcast tooling grew up on, so plenty of delivery specs, ingest systems, and older Mac apps whitelist .mov by extension and refuse everything else — even when the codecs inside are identical to an MP4’s. Converting the container satisfies the validator without touching the video itself.