Convert SWF to MOV — Free Online Tool
Convert SWF Flash files to MOV (QuickTime) format by re-encoding the FLV1 or MJPEG video and MP3 audio streams into H.264 video and AAC audio inside Apple's professional container. This is especially useful for preserving Flash animation content that can no longer be played in modern browsers since Adobe Flash's end-of-life in 2020.
to
FFmpeg Command
Copy this command to run the same conversion locally with FFmpeg on your desktop. Download FFmpeg
Drop your SWF 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
SWF files typically contain video encoded in FLV1 (Sorenson Spark) or MJPEG, with audio in MP3 format. Neither of these codecs is natively supported in a MOV container, so this conversion performs a full re-encode: the video stream is decoded from FLV1/MJPEG and re-encoded into H.264 using libx264 (with CRF 23 for balanced quality), and the audio is transcoded from MP3 to AAC at 128k bitrate. The resulting MOV file wraps both streams in Apple's QuickTime container, with the -movflags +faststart flag rearranging metadata to the front of the file for faster playback start — particularly useful if the MOV is later served over the web or imported into editing software like Final Cut Pro.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg binary. In the browser-based tool, this runs via FFmpeg.wasm (WebAssembly) entirely client-side with no server upload; when run locally on your desktop, this calls your installed FFmpeg binary directly. |
-i input.swf
|
Specifies the input SWF file. FFmpeg's SWF demuxer will attempt to identify and extract any embedded continuous video (FLV1 or MJPEG) and audio (MP3) streams from the Flash container. |
-c:v libx264
|
Re-encodes the video stream using the libx264 H.264 encoder. Since FLV1 (Sorenson Spark) video from SWF is not compatible with the MOV container directly, a full video transcode to H.264 is required here. |
-c:a aac
|
Transcodes the audio stream from MP3 (the typical SWF audio codec) to AAC, which is the standard audio codec for MOV files and offers better compression efficiency than MP3 at equivalent bitrates. |
-crf 23
|
Sets the Constant Rate Factor for H.264 encoding to 23, which is libx264's default and produces a good balance between visual quality and file size. Lower values (e.g., 18) produce higher quality at larger file sizes; higher values (e.g., 28) reduce file size with more compression. |
-b:a 128k
|
Sets the AAC audio bitrate to 128 kilobits per second, which matches the typical quality ceiling of MP3 audio found in SWF files and is sufficient for voice, music, and general-purpose audio in the converted MOV. |
-movflags +faststart
|
Moves the MOV file's metadata (moov atom) to the beginning of the file after encoding completes. This ensures the output MOV opens quickly in QuickTime Player, Final Cut Pro, and web players without needing to read the entire file first. |
output.mov
|
Specifies the output filename with the .mov extension, telling FFmpeg to write the re-encoded H.264 video and AAC audio into Apple's QuickTime container format. |
Common Use Cases
- Archiving Flash-based animations and motion graphics created before 2020 that are now unplayable in browsers, converting them to a format that remains accessible in modern video players and editors.
- Importing legacy SWF promotional videos or banner animations into Final Cut Pro or DaVinci Resolve for reuse in current video production workflows.
- Converting SWF e-learning content or screencasts into MOV so they can be edited, trimmed, and re-exported for modern Learning Management Systems.
- Extracting the video content from SWF-based interactive demos or product tours into a standard MOV file that can be embedded in presentations or uploaded to video platforms.
- Preserving SWF animations from legacy websites or CD-ROM multimedia projects as high-quality MOV files for long-term digital archiving on Apple-ecosystem workflows.
- Preparing Flash video content for import into iMovie or Compressor by converting the incompatible SWF container to QuickTime's native MOV format.
Frequently Asked Questions
No. SWF files can contain ActionScript-driven interactivity, vector animations, and programmatic content that are rendered dynamically. FFmpeg can only capture the rasterized video and audio output streams embedded or renderable within the SWF — it cannot convert interactivity, scripting logic, or pure vector timeline animations that have no pre-rendered video track. If your SWF contains a straightforward embedded video (FLV1/MJPEG), the conversion will work well; if it is primarily a vector-animated or interactive SWF, the output MOV may be incomplete or empty.
Some quality loss is inherent since both the FLV1 source and the H.264 output are lossy codecs, so you are decoding a compressed source and re-compressing it. However, H.264 at CRF 23 is significantly more efficient than FLV1 (Sorenson Spark), so in practice the output often looks comparable to or better than the source at a smaller file size. If you want to minimize generation loss, lower the CRF value (e.g., -crf 18) to increase quality at the cost of a larger file.
Some SWF files use event-based audio triggered by ActionScript rather than a continuous audio stream, which FFmpeg cannot extract because no audio stream is actually embedded in the file's container. Additionally, SWF files that use MP3 streaming audio should convert correctly, but if the audio was part of an interactive ActionScript event system, FFmpeg will see no decodable audio track. In that case, the resulting MOV will be silent by design.
Change the -crf value to control H.264 quality. CRF ranges from 0 (lossless) to 51 (worst quality); the default of 23 is a good balance. For higher quality at a larger file size, try -crf 18. For a smaller file where quality is less critical, try -crf 28. You can also raise the audio bitrate by changing -b:a 128k to -b:a 192k or -b:a 256k if the source SWF had high-quality audio.
Yes. On Linux or macOS, you can use a shell loop: for f in *.swf; do ffmpeg -i "$f" -c:v libx264 -c:a aac -crf 23 -b:a 128k -movflags +faststart "${f%.swf}.mov"; done. On Windows Command Prompt, use: for %f in (*.swf) do ffmpeg -i "%f" -c:v libx264 -c:a aac -crf 23 -b:a 128k -movflags +faststart "%~nf.mov". This processes each SWF in the current directory and outputs a matching MOV file.
Yes. MOV with H.264 video and AAC audio is one of the most natively supported formats in Final Cut Pro, iMovie, and Compressor. The -movflags +faststart flag is not required for editing but does ensure the file opens immediately without needing to fully buffer, which is helpful when scrubbing large files. If you need ProRes compatibility for high-end editing, you would need to change the video codec to -c:v prores_ks, but for most archival and editing purposes H.264 in MOV is fully sufficient.
Technical Notes
SWF is a composite format that may contain embedded FLV video streams using FLV1 (Sorenson Spark, a variant of H.263) or MJPEG, paired with MP3 audio. FFmpeg's SWF demuxer can extract these streams when they exist as continuous media tracks, but it cannot render programmatic or vector-only SWF content. The output MOV container uses Apple's QuickTime atom structure, which natively supports H.264 (via libx264) and AAC audio — both of which are significantly more efficient and widely compatible than the source codecs. One important limitation: SWF files do not support subtitles, chapters, or multiple audio tracks, so none of these are present in the source and the MOV output will likewise contain only a single video and single audio stream. The -movflags +faststart flag moves the moov atom to the beginning of the MOV file, which is a best practice for any MOV intended for web delivery or import into editing tools. Since SWF is inherently lossy and FLV1 is an older, less efficient codec, users should not expect the H.264 output to recover detail that was already lost in the source encoding.