Convert 3GPP to MOV — Free Online Tool
Convert 3GPP mobile video files to Apple QuickTime MOV format, re-encoding the H.264 video and AAC audio streams into a container fully compatible with Final Cut Pro, iMovie, and professional macOS workflows. This tool runs entirely in your browser — no uploads, no servers, no waiting.
to
FFmpeg Command
Copy this command to run the same conversion locally with FFmpeg on your desktop. Download FFmpeg
Drop your 3GPP file here
or click to browse
Free — no uploads, no signups. Your files never leave your browser.
Settings
Note: Browser-based encoding uses approximate quality targets. For precise CRF compression, copy the FFmpeg command above and run it on your desktop.
Estimated output:
Conversion Complete!
DownloadHow It Works
3GPP (.3gp) files use H.264 video and AAC audio codecs contained in a mobile-optimized MPEG-4 variant originally designed for 3G cellular networks. MOV is Apple's QuickTime container, which also natively supports H.264 and AAC — but the two containers are not interchangeable by simple remuxing because of structural differences in how atom headers and metadata are arranged. This conversion re-encodes the video stream using libx264 at CRF 23 (a visually transparent quality level) and re-encodes the audio to AAC at 128k — a significant upgrade from the 64k audio bitrate common in 3GPP files. The -movflags +faststart flag reorganizes the MOV file's index data to the front of the file, enabling progressive playback before the full file downloads. Because 3GPP files are typically small and low-bitrate (designed for constrained mobile bandwidth), the output MOV file will often be larger and noticeably higher fidelity, particularly in audio.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg program — the open-source multimedia processing engine that handles all decoding, re-encoding, and container muxing in this conversion. In the browser version, this runs as FFmpeg.wasm compiled to WebAssembly. |
-i input.3gp
|
Specifies the input file — a 3GPP mobile video container (.3gp). FFmpeg reads the H.264 video and AAC audio streams from this mobile-format file and decodes them for re-encoding. |
-c:v libx264
|
Re-encodes the video stream using the libx264 encoder, producing H.264 video output. Since the 3GPP source may also carry H.264, this is technically a re-encode rather than a transcode to a different codec, but it ensures the stream is cleanly structured for the MOV container. |
-c:a aac
|
Re-encodes the audio stream to AAC using FFmpeg's native AAC encoder. This replaces the original low-bitrate 3GPP AAC track with a higher-quality AAC track at 128k, which is the standard bitrate for MOV audio in editing workflows. |
-crf 23
|
Sets the Constant Rate Factor for H.264 video quality at 23, FFmpeg's default and a good balance between quality and file size. For low-resolution 3GPP source material, this setting preserves all meaningful detail from the original without inflating the output file unnecessarily. |
-b:a 128k
|
Sets the audio output bitrate to 128 kilobits per second — double or quadruple the typical audio bitrate found in 3GPP files (32k–64k). This produces clean AAC audio suitable for editing and playback on Apple devices and software. |
-movflags +faststart
|
Moves the MOV file's metadata index (the 'moov' atom) to the beginning of the file after encoding completes. This enables the MOV file to begin playing in QuickTime or a browser before the entire file has loaded, which is especially useful when sharing these converted files over the web. |
output.mov
|
Specifies the output filename with the .mov extension, telling FFmpeg to write the converted streams into a QuickTime MOV container — the format natively used by Final Cut Pro, iMovie, and QuickTime Player on macOS. |
Common Use Cases
- Opening old mobile phone video recordings (from early Android or feature phones) in Final Cut Pro or iMovie, which prefer MOV containers for native timeline integration
- Archiving 3GPP clips captured by legacy Nokia, Samsung, or early smartphone cameras into a professionally compatible format before the source device becomes unavailable
- Preparing field footage shot on a basic handset for delivery to a video editor working in an Apple-centric post-production pipeline
- Uploading mobile-captured 3GPP clips to platforms like Vimeo that accept MOV more reliably than raw 3GP files
- Converting tutorial or reference clips recorded on older Android devices into a format that QuickTime Player on macOS can reliably scrub and export from
- Standardizing a batch of mixed-format mobile video clips into a single MOV format before importing into a documentary or social media editing project
Frequently Asked Questions
The video quality will be comparable or slightly better, as the output uses H.264 at CRF 23 — a high-quality setting that is generally more generous than the aggressive compression used in typical 3GPP files meant for 3G transmission. The audio quality will be meaningfully better: 3GPP files commonly use AAC at 32k–64k bitrate, while this conversion outputs AAC at 128k, resulting in noticeably cleaner audio. Keep in mind that the original mobile video resolution (often 176×144 or 320×240) does not increase — the conversion preserves source resolution.
While both 3GPP and MOV can carry H.264 and AAC streams, the container structures differ enough that simple remuxing with -c copy often fails or produces unplayable files in QuickTime. The 3GPP format uses a mobile-specific variant of the MP4 atom structure with metadata arrangements that QuickTime does not always interpret correctly. Re-encoding ensures the video and audio streams are cleanly wrapped in a standard MOV-compliant structure that Apple applications handle natively.
Basic metadata such as duration and stream information will be preserved, but 3GPP-specific tags like GPS coordinates, device model, and recording timestamps stored in proprietary mobile metadata atoms are typically not carried over into the MOV container. If preserving this metadata matters, you should extract it separately (using a tool like ExifTool) before converting, as the re-encoding process does not explicitly map 3GPP metadata atoms to MOV equivalents.
Yes — this page displays the exact FFmpeg command used for the conversion: ffmpeg -i input.3gp -c:v libx264 -c:a aac -crf 23 -b:a 128k -movflags +faststart output.mov. Install FFmpeg on your desktop (available at ffmpeg.org), replace 'input.3gp' with your actual filename, and run it in a terminal. This is also significantly faster than browser-based processing for large files because it uses your CPU's native performance rather than the WebAssembly runtime.
Change the -crf value to control video quality. Lower values produce higher quality and larger files — CRF 18 is near-visually lossless for H.264, while CRF 28 produces smaller files with more visible compression artifacts. For 3GPP source material that was already heavily compressed at low resolution, values between 20 and 26 are usually sufficient since the source quality is the limiting factor, not the re-encoding. Changing CRF below 18 on a 3GPP source will increase file size without improving perceived quality.
Yes. On macOS or Linux, use a shell loop: for f in *.3gp; do ffmpeg -i "$f" -c:v libx264 -c:a aac -crf 23 -b:a 128k -movflags +faststart "${f%.3gp}.mov"; done. On Windows Command Prompt, use: for %f in (*.3gp) do ffmpeg -i "%f" -c:v libx264 -c:a aac -crf 23 -b:a 128k -movflags +faststart "%~nf.mov". This processes each 3GPP file in a directory sequentially and outputs a corresponding MOV file with the same base filename.
Technical Notes
3GPP files are a constrained subset of the MPEG-4 Part 12 container, originally specified for 3GPP Release 4 and commonly encountered from devices manufactured between 2003 and 2012. They typically carry video at very low resolutions (QCIF 176×144, CIF 352×288, or occasionally 480×320) encoded with H.263 or H.264, and audio at low bitrates (often 32k–64k AAC-LC or AMR-NB). This tool assumes H.264 video and AAC audio input, which covers most modern 3GPP files — files using H.263 video or AMR audio (older feature phone recordings) will still be processed but may require FFmpeg to handle additional codec conversion automatically. The MOV container supports a significantly richer feature set: transparency via PNG or ProRes 4444, multiple audio tracks, chapter markers, and subtitle tracks — none of which are present in 3GPP sources, so those MOV capabilities remain unused in this conversion. The output file will be compatible with QuickTime Player 7 and later, all Final Cut Pro versions, iMovie, and Adobe Premiere Pro on macOS. Note that MOV files are not natively supported on Android or Windows without additional codecs, so if cross-platform playback is the goal, MP4 would be a more appropriate output format than MOV.