Convert SWF to WebM — Free Online Tool
Convert SWF Flash animations and video to WebM using VP9 video encoding and Opus audio — producing a modern, open-format web video that plays natively in HTML5 browsers without requiring the Flash plugin. This tool runs entirely in your browser via FFmpeg.wasm, so no files ever leave your device.
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 FLV1 (Sorenson Spark) video and MP3 audio streams embedded in Adobe's proprietary Flash container. During conversion, FFmpeg demuxes the SWF container, decodes the FLV1 video frames and MP3 audio, then re-encodes everything: video is transcoded to VP9 using libvpx-vp9 in constant-quality mode (CRF 33), and audio is transcoded to Opus at 128k bitrate using libopus. The result is a WebM file — a Matroska-based open container — that browsers like Chrome, Firefox, and Edge can play natively without any plugin. Because both video and audio must be fully decoded and re-encoded (not just remuxed), this is a full transcode operation that may take longer than simple container rewraps.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg binary. When run in this browser tool, it uses FFmpeg.wasm — a WebAssembly port that executes the same encoding logic client-side without sending your SWF file to any server. |
-i input.swf
|
Specifies the input SWF file. FFmpeg uses its SWF demuxer to parse the Flash container and extract the embedded video (typically FLV1/Sorenson Spark) and audio (typically MP3) streams for decoding. |
-c:v libvpx-vp9
|
Sets the video encoder to libvpx-vp9, which re-encodes the decoded FLV1 video frames into VP9 — the modern open-source video codec used in the WebM container and natively supported by Chrome, Firefox, and Edge. |
-c:a libopus
|
Sets the audio encoder to libopus, transcoding the MP3 audio from the SWF into Opus — a highly efficient, open audio codec that is the standard for WebM files and offers better quality than MP3 at the same bitrate. |
-crf 33
|
Sets the Constant Rate Factor for VP9 video quality. A value of 33 is a balanced default; lower values (e.g., 18) produce sharper video with larger file sizes, while higher values (e.g., 48) compress more aggressively with visible quality loss. |
-b:a 128k
|
Sets the Opus audio bitrate to 128 kilobits per second. For Opus, 128k delivers high-fidelity audio that is transparent for most content, and it represents a quality improvement over the MP3 audio typically found in SWF files at the same bitrate. |
-b:v 0
|
Sets the target video bitrate to zero, which is required to activate pure CRF (constant quality) mode in libvpx-vp9. Without this flag, the VP9 encoder would ignore the -crf setting and fall back to a default constrained bitrate mode instead. |
output.webm
|
Specifies the output filename. The .webm extension tells FFmpeg to use the WebM/Matroska muxer, packaging the VP9 video and Opus audio into the open WebM container ready for HTML5 playback. |
Common Use Cases
- Preserving Flash-era web animations before browsers permanently drop SWF support, converting them to WebM so they remain viewable without Adobe Flash Player
- Embedding legacy Flash video content into a modern HTML5 webpage using a native <video> tag with a WebM source
- Archiving SWF-based e-learning courses or training videos into a distributable WebM format that works on current operating systems and devices
- Converting Flash-based advertisements or motion graphics to WebM for use in modern programmatic ad platforms that no longer accept SWF
- Extracting and re-encoding video content from SWF files for upload to platforms like YouTube or Vimeo, using WebM as an intermediate step
- Getting the exact FFmpeg command to batch-convert a large library of SWF files on a local machine when individual files exceed 1GB
Frequently Asked Questions
No. SWF files can contain ActionScript code that drives interactivity, button logic, branching animations, and user input handling. FFmpeg only extracts the rendered video and audio streams — it cannot interpret or preserve ActionScript logic. The output WebM will be a linear video recording of the visual and audio content, with all interactivity stripped out. If your SWF is purely an animation or video clip with no user interaction, the visual result will be faithful.
SWF files often use vector graphics, which are resolution-independent and look sharp at any size. When FFmpeg renders the SWF, it rasterizes those vectors at the file's native resolution before encoding to VP9. If the original SWF was authored at a small pixel resolution (e.g., 320x240), the WebM will be that same small resolution — scaling it up in a browser will look blurry. Additionally, the default CRF value of 33 for VP9 is a moderate quality setting; lowering it (e.g., to 18-24) in the FFmpeg command will produce a sharper output at the cost of a larger file.
WebM with VP9 does technically support alpha channel transparency, but FFmpeg's SWF demuxer renders the Flash content with a solid background rather than extracting true per-pixel transparency from vector layers. In practice, transparent regions in the original SWF will most likely be rendered as a solid (usually black or white) background in the output WebM. If transparency is critical, you would need a dedicated SWF rendering tool to export frames with an alpha channel before re-encoding.
The CRF (Constant Rate Factor) value controls VP9 video quality. The default command uses -crf 33, where lower numbers mean higher quality and larger files. For noticeably better quality, try -crf 18 or -crf 24. The valid range for VP9 CRF is 0 (lossless) to 63 (lowest quality). Note that when using CRF mode with libvpx-vp9, the -b:v 0 flag must be kept in the command — removing it would switch the encoder out of pure CRF mode and could produce inconsistent results.
Yes. On Linux or macOS, you can run a simple shell loop: for f in *.swf; do ffmpeg -i "$f" -c:v libvpx-vp9 -c:a libopus -crf 33 -b:a 128k -b:v 0 "${f%.swf}.webm"; done. On Windows Command Prompt, use: for %f in (*.swf) do ffmpeg -i "%f" -c:v libvpx-vp9 -c:a libopus -crf 33 -b:a 128k -b:v 0 "%~nf.webm". This is especially useful for archiving large collections of SWF files that exceed the 1GB browser limit.
WebM is an excellent choice for web playback due to its open, royalty-free nature and native HTML5 support, but for archival purposes MP4 with H.264 offers broader device compatibility. VP9 in WebM provides better compression efficiency than H.264 at comparable quality, meaning smaller files for the same visual fidelity. However, if you need to play files on older smart TVs, legacy media players, or share with users who may not have VP9 hardware decoding, an MP4 copy is a safer secondary archive. For Flash content specifically, preserving both formats is a common archiving practice.
Technical Notes
FFmpeg's SWF demuxer handles the most common SWF video formats — files containing FLV1 (Sorenson Spark) video and libmp3lame-encoded MP3 audio — but it has limited support for more complex SWF structures. SWF files that rely purely on vector timeline animations without an embedded video track may produce unexpected output, as FFmpeg attempts to render what it can parse from the container. The VP9 encoder (libvpx-vp9) used here operates in two-pass-equivalent CRF mode when combined with -b:v 0, which is the recommended configuration for quality-driven encoding. Opus audio (libopus) at 128k delivers transparent quality for most speech and music content, and it significantly outperforms the MP3 source codec at equivalent bitrates. Metadata from the SWF container (such as title or authoring information stored in FileAttributes or Metadata tags) is generally not preserved in the WebM output, as FFmpeg does not map SWF metadata fields to WebM/Matroska tags. The WebM output will support subtitles, chapters, and multiple audio tracks as container features, but none of these will be populated from a standard SWF source since SWF does not carry them.