MyMediaTools

Compress MOV Online — Free File Size Reducer

Compress MOV files while keeping them in the QuickTime container, re-encoding video with H.264 (libx264) and audio with AAC at configurable quality levels. Ideal for reducing file sizes from Final Cut Pro, Premiere, or camera exports without leaving Apple's native format.

FFmpeg Command

Copy this command to run the same conversion locally with FFmpeg on your desktop. Download FFmpeg

Free — no uploads, no signups. Your files never leave your browser.

Estimated output:

Conversion Complete!

Download

How It Works

Because the input and output are both MOV containers, this tool performs a full re-encode rather than a simple remux. The video stream is decoded and re-encoded using H.264 (libx264) with a Constant Rate Factor of 23, which targets a perceptually consistent quality level while discarding redundant visual data to reduce file size. The audio is simultaneously decoded and re-encoded to AAC at 128k bitrate, which is standard for stereo dialogue and music. The -movflags +faststart flag rewrites the MOV atom structure so that playback metadata sits at the beginning of the file — important for streaming or sharing the compressed file over the web. Multiple audio tracks, chapter markers, and subtitle tracks that exist in the source MOV are preserved in the output container where codec compatibility allows.

What Each Flag Does

Flag What it does
ffmpeg Invokes the FFmpeg command-line tool, the same underlying engine running in your browser via WebAssembly. Running this locally requires FFmpeg to be installed on your system.
-i input.mov Specifies the input QuickTime MOV file. FFmpeg will detect the container and all contained streams — video, audio, chapters, and subtitles — automatically from this file.
-c:v libx264 Re-encodes the video stream using the H.264 codec via the libx264 encoder. This replaces whatever video codec was in the source MOV (e.g., ProRes, HEVC, or MJPEG) with H.264, which offers much better compression efficiency while remaining fully compatible with QuickTime Player and Final Cut Pro.
-crf 23 Sets the Constant Rate Factor for the H.264 encode to 23, which is libx264's default and represents a balanced quality-to-file-size tradeoff. Lower values (e.g., 18) produce larger, higher-quality files; higher values (e.g., 28–35) produce smaller files with more visible compression. This single parameter is the primary lever for controlling output file size.
-c:a aac Re-encodes the audio stream to AAC, the standard audio codec for QuickTime and Apple platforms. This ensures the compressed MOV plays correctly in QuickTime Player, iMovie, and Final Cut Pro regardless of what audio codec (e.g., PCM, ALAC, or MP3) was present in the source file.
-b:a 128k Sets the AAC audio bitrate to 128 kilobits per second, which is a standard quality level for stereo audio that balances file size and clarity for speech, music, and mixed content typical in MOV video files.
-movflags +faststart Moves the MOV file's index metadata (the 'moov' atom) to the beginning of the output file during a post-processing pass. This enables progressive playback — QuickTime Player and web-based video players can start playing the compressed MOV before the entire file has downloaded, which is essential for streaming or web delivery.
output.mov Specifies the output filename with a .mov extension, directing FFmpeg to wrap the re-encoded H.264 video and AAC audio into a QuickTime MOV container, preserving compatibility with Apple's native format ecosystem.

Common Use Cases

  • Shrink a large Final Cut Pro export from a camera like the Sony FX3 or Canon R5 that shoots ProRes or HEVC inside MOV, making it easier to share with a client via email or Dropbox
  • Reduce the file size of a screen recording made with QuickTime Player on macOS before uploading it to Loom, Notion, or a project management tool with file size limits
  • Compress a wedding or event video delivered in MOV format for archiving on a portable drive without abandoning the QuickTime container expected by the client's Mac-based editing suite
  • Optimize a MOV file from DJI drone footage for review on an iPad or Apple TV without converting to a different container that might break chapter markers or metadata
  • Prepare a compressed proxy version of a high-bitrate MOV master file to speed up remote collaboration in editing workflows where the original is too large to transfer quickly
  • Re-encode a raw camera MOV with a more efficient H.264 encode for long-term storage, reducing disk usage while maintaining compatibility with iMovie and QuickTime Player

Frequently Asked Questions

At the default CRF 23 setting, quality loss is minimal and generally imperceptible on most displays for standard content like interviews, screen recordings, and event footage. However, this is a lossy re-encode — each compression pass discards some visual information, so if your source MOV is already H.264-encoded, you are compressing an already-compressed signal. For archival purposes or repeated editing, it is better to keep the highest-quality source and only compress final deliverables. If your source is ProRes or another high-bitrate format, CRF 23 will produce a dramatically smaller file with very good visual fidelity.
The MOV container supports chapters, multiple audio tracks, and subtitle tracks, and FFmpeg will attempt to map and preserve these when re-encoding. However, only audio tracks encoded in AAC, MP3, Opus, FLAC, or Vorbis can be passed through or re-encoded to the output — tracks in PCM or other formats will be re-encoded to AAC at 128k by default. Chapter markers stored as QuickTime chapter tracks are typically preserved. If your MOV contains complex multi-track layouts, using the FFmpeg command directly with explicit -map flags gives you finer control.
MOV files from cameras or professional editing applications often contain high-bitrate codecs like Apple ProRes, HEVC High, or even RAW video, which compress very differently than H.264. At CRF 23, H.264 targets a quality level rather than a specific file size, so the output bitrate depends heavily on the complexity and motion in your footage. A file with lots of fast motion, grain, or detail will always produce a larger output than a static or low-complexity scene. To target a smaller file, increase the CRF value (e.g., CRF 28 or 30) in the FFmpeg command, accepting a slight reduction in quality.
H.264 video inside a MOV file and H.264 video inside an MP4 file use essentially the same encoded bitstream — the difference is the container wrapper. MOV is Apple's container and carries additional metadata atoms, chapter track support, and better compatibility with Final Cut Pro and QuickTime-based workflows. MP4 is more universally compatible with non-Apple platforms, web players, and Android devices. If your destination is a Mac-based editing or playback environment, staying in MOV is the right choice. For web upload or cross-platform sharing, MP4 is generally preferable.
The -crf flag controls the quality-to-size tradeoff for the H.264 encode. Lower values produce higher quality and larger files (CRF 18 is near-visually lossless for most content), while higher values produce smaller files with more compression artifacts (CRF 28–35 is suitable for web previews or low-priority archives). To adjust, modify the command like this: ffmpeg -i input.mov -c:v libx264 -crf 28 -c:a aac -b:a 128k -movflags +faststart output.mov. The audio bitrate can similarly be adjusted by changing -b:a 128k to -b:a 96k or -b:a 192k depending on whether you want to save more space or preserve audio fidelity.
Yes, the FFmpeg command shown can be adapted for batch processing on your local machine using a shell loop. On macOS or Linux, you can run: for f in *.mov; do ffmpeg -i "$f" -c:v libx264 -crf 23 -c:a aac -b:a 128k -movflags +faststart "compressed_$f"; done. On Windows using PowerShell: Get-ChildItem *.mov | ForEach-Object { ffmpeg -i $_.Name -c:v libx264 -crf 23 -c:a aac -b:a 128k -movflags +faststart ("compressed_" + $_.Name) }. The browser tool processes one file at a time, so the command-line approach is recommended for batch workflows or files larger than 1GB.

Technical Notes

Compressing MOV to MOV with FFmpeg using libx264 and AAC is one of the most reliable workflows for reducing QuickTime file sizes without leaving Apple's ecosystem. The libx264 encoder's CRF mode is well-suited for this use case because it adapts the bitrate to the visual complexity of each frame rather than targeting a fixed bitrate, which avoids wasting bits on simple scenes and over-compressing complex ones. One important consideration is that MOV files from professional cameras often carry metadata in Apple-specific container atoms — including color space tags, timecode tracks, and spatial audio descriptors — that may not survive a full re-encode unchanged. The -movflags +faststart flag is particularly valuable when the compressed MOV will be served from a web server or uploaded to a CDN, as it allows QuickTime Player and browser-based players to begin playback before the file finishes downloading. Transparency (alpha channel) support is available in the MOV container using codecs like PNG or MJPEG, but libx264 does not support an alpha channel; if your source MOV contains transparency, you must use a different output codec such as PNG or switch to a ProRes-compatible workflow. The AAC encoder at 128k is appropriate for stereo content but may be insufficient for 5.1 surround audio tracks; in those cases, increase the audio bitrate to 192k or 256k in the command.

Related Tools

Compress MP4 Compress OGG Compress WMA Compress M4V Compress AIFF Compress MOD Convert MOV to MP4 Extract Audio MOV to MP3