Converting HLS to MP4 involves downloading the segments referenced in an .m3u8 playlist and stitching them into a single MP4 container. The most common approach uses FFmpeg with stream copying (remux) to avoid re-encoding, preserving original quality while producing a universally compatible file. Browser-based WebAssembly alternatives like ffmpeg.wasm enable client-side conversion without installing software, though CORS and DRM restrictions apply.
HTTP Live Streaming (HLS) dominates web video delivery, but its segmented architecture makes offline storage and universal playback a challenge. If you have ever wanted to save an HLS stream as a single MP4 file for archival, editing, or playback on devices that lack HLS support, you are in the right place. By the end of this guide, you will understand the full HLS to MP4 conversion pipeline, know which tools to use for your specific scenario, and be able to troubleshoot the most common issues developers encounter.

What Is HLS and Why Convert It to MP4?

HLS, or HTTP Live Streaming, is an adaptive bitrate streaming protocol developed by Apple that breaks video content into small segment files delivered over standard HTTP. A master playlist file with the .m3u8 extension points to one or more media playlists, which in turn reference short video segments (typically .ts or .fMP4 files) lasting 2 to 10 seconds each. The player downloads the playlist, requests segments sequentially, and plays them back as a continuous stream.
This segmented approach is excellent for adaptive streaming over unpredictable networks, but it creates friction when you need a single downloadable file. MP4, by contrast, is a self-contained container format with near-universal playback support across browsers, mobile devices, media players, and editing software. Converting HLS to MP4 gives you one portable file that works everywhere, can be stored offline, and integrates with standard video processing pipelines.
The conversion process is not a traditional transcode in most cases. It is a remux operation that repackages the existing audio and video streams from their segmented HLS format into a contiguous MP4 container without altering the underlying codecs. This means no quality loss and minimal processing time.

HLS Playlist Structure

An HLS playlist hierarchy starts with a master playlist that lists available quality variants. Each variant is described by an EXT-X-STREAM-INF tag, which specifies bandwidth, resolution, and codec information, followed by the URL of the corresponding media playlist. The media playlist then enumerates individual segments using EXTINF tags that specify each segment's duration and location.
For encrypted streams, the EXT-X-KEY tag appears in the media playlist, pointing to a key file and specifying the encryption method (typically AES-128). Understanding this structure is essential because the conversion tool must parse the playlist, resolve every segment URL (which may be relative or absolute), and handle decryption if the stream is protected.

MP4 Container Overview

The MP4 container (ISO Base Media File Format) organizes media data into tracks, typically one for video and one for audio. Each track contains samples encoded in a specific codec, such as H.264 or H.265 for video and AAC for audio. The container also stores metadata, timing information, and optional subtitle tracks.
MP4's broad compatibility stems from its adoption as the default video format for HTML5 video, iOS, Android, and most desktop media players. When you convert HLS to MP4, the resulting file inherits the codec of the original segments, so compatibility depends on whether the target playback environment supports those codecs. For most HLS streams using H.264 video and AAC audio, the resulting MP4 will play virtually anywhere.

Choosing the Right Conversion Approach

Selecting the right HLS to MP4 conversion method depends on your environment, technical constraints, and whether you need a one-time download or a repeatable automated workflow. The two primary dimensions to consider are remux versus re-encode and local tools versus browser-based solutions.
Remuxing (stream copying) extracts the audio and video streams from HLS segments and places them into an MP4 container without decoding or re-encoding. This is fast, lossless, and the recommended approach whenever the source codecs are MP4-compatible. Re-encoding becomes necessary only when the source uses a codec that MP4 cannot contain (rare for modern HLS) or when you need to change resolution, bitrate, or codec for a specific target platform.
Local tools like FFmpeg offer maximum control, batch processing capabilities, and no file size limitations. Browser-based WebAssembly tools provide zero-installation convenience and cross-platform access, but they face CORS restrictions, memory limits, and cannot handle DRM-protected content. For server-side or automated workflows, FFmpeg running on a backend is the standard choice.

When to Use FFmpeg Remux

FFmpeg remux is the right choice when you need speed, quality preservation, and reliability. Because stream copying bypasses the decode and encode stages, a 30-minute HLS stream can be converted to MP4 in under a minute on a modern machine, depending primarily on network download speed rather than CPU power. Use FFmpeg remux when you are working with standard HLS streams using H.264 video and AAC audio, when you need to process multiple streams in batch, or when you are building a server-side conversion pipeline.

When a Browser-Based WebAssembly Tool Is Ideal

Browser-based conversion using ffmpeg.wasm is ideal for one-off conversions where installing software is impractical or undesirable. If you are on a locked-down corporate machine, a Chromebook, or a mobile device, a web-based HLS to MP4 converter lets you paste an .m3u8 URL and download the result without any local installation. This approach is also useful for building user-facing tools where you want to offer conversion as a feature without managing server infrastructure. The trade-offs are slower performance (WebAssembly runs slower than native FFmpeg), browser memory limits (typically 2GB to 4GB depending on the browser), and CORS restrictions that may prevent fetching segments from cross-origin servers.

Step-by-Step: Converting HLS to MP4 with FFmpeg

FFmpeg is the industry standard for media processing, and it handles HLS to MP4 conversion natively. The process involves locating the .m3u8 playlist URL, invoking FFmpeg with the appropriate options, and letting the tool handle segment downloading, stitching, and container packaging.

Step 1: Obtain the .m3u8 Playlist URL

Open the web page containing the video you want to convert and use your browser's developer tools (Network tab) to find the .m3u8 request. Filter by "m3u8" to locate the playlist file. If there are multiple results, the master playlist is typically the one requested first, and it will contain references to media playlists for different quality levels. Copy the full URL of the master playlist or the specific media playlist for your desired quality.

Step 2: Run the FFmpeg Conversion

FFmpeg can read HLS playlists directly as input. The key options for a remux conversion are straightforward. You pass the .m3u8 URL as the input, specify the copy codec option to avoid re-encoding, and name the output file with an .mp4 extension. FFmpeg automatically parses the playlist, downloads each segment in sequence, and writes the concatenated streams into the MP4 container.
For audio streams that use ADTS framing (common with .ts segments containing AAC audio), you need to apply the aac_adtstoasc bitstream filter. This filter converts the ADTS header format to the ASC format that MP4 expects. Without it, FFmpeg may produce warnings or an MP4 file with audio that fails to play in some players. The bitstream filter is applied to the audio stream specifically, alongside the copy codec option.

Step 3: Handle Encrypted Streams

If the HLS playlist contains EXT-X-KEY tags, the stream is encrypted with AES-128. FFmpeg can decrypt the stream automatically if the key file is accessible via the URL specified in the playlist. In most cases, FFmpeg resolves and fetches the key without additional configuration. However, if the key requires authentication headers or is served from a CDN that blocks direct access, you may need to download the key file manually and provide it through a custom decryption pipeline.

Step 4: Verify the Output

After conversion completes, verify the MP4 file by playing it in a standard media player. Check that both video and audio play correctly, that the duration matches the expected length, and that there are no gaps or corruption artifacts. Use FFmpeg's built-in probing tool to inspect the container structure and confirm the codecs, resolution, and duration are correct.
For more details on FFmpeg's HLS handling, the official FFmpeg documentation provides comprehensive reference material on supported options and protocols.

Converting HLS to MP4 Directly in the Browser

Browser-based HLS to MP4 conversion leverages WebAssembly to run a compiled version of FFmpeg entirely in the browser. The ffmpeg.wasm project ports FFmpeg to WebAssembly, enabling client-side media processing without a backend server. This approach is increasingly popular for building web-based video tools and offering conversion features in web applications.
The workflow for browser-based conversion follows a clear sequence. First, the user pastes the .m3u8 URL into a web interface. The application fetches the playlist, parses it to identify segment URLs, and downloads each segment. The segments are then loaded into the WebAssembly FFmpeg instance's virtual file system. FFmpeg processes the segments with the same remux logic used in the command-line version, applying stream copy and any necessary bitstream filters. The resulting MP4 file is offered as a download to the user.
Several limitations constrain this approach. CORS policies on the streaming server may prevent the browser from fetching segments cross-origin. If the HLS server does not include appropriate Access-Control-Allow-Origin headers, the browser will block the segment requests. DRM-protected streams cannot be processed because the browser cannot access the decryption keys. Memory limitations in WebAssembly mean very long streams (over approximately 2 hours at high bitrate) may exceed available browser memory and cause the conversion to fail.
Despite these constraints, browser-based conversion is valuable for short-form content, educational videos, and scenarios where server-side processing is not available. The MDN WebAssembly overview provides background on how WebAssembly enables this kind of in-browser computation.

Common Pitfalls and How to Avoid Them

Converting HLS to MP4 is generally straightforward, but several issues can derail the process. Understanding these pitfalls in advance saves significant debugging time.

Missing Segments and Network Errors

HLS playlists reference segments by URL, and if any segment is unavailable (404 error, server timeout, or CDN issue), the conversion will fail or produce a corrupted file. FFmpeg will typically report the error and stop processing. To mitigate this, ensure a stable network connection before starting conversion. For streams with intermittent availability, FFmpeg supports retry options that can re-request failed segments before giving up. If segments are genuinely missing from the server, no conversion tool can recover that data.

Audio Sync Issues and the aac_adtstoasc Filter

One of the most common issues when converting HLS .ts segments to MP4 is audio playback failure or desynchronization. Transport stream segments typically wrap AAC audio in ADTS frames, while the MP4 container expects Audio Specific Config (ASC) framing. If you skip the aac_adtstoasc bitstream filter during remux, the resulting MP4 may have audio that plays at the wrong speed, fails to play entirely, or produces static. Always include this filter when converting from .ts-based HLS to MP4. For fMP4-based HLS (where segments use the .m4s extension), this filter is usually unnecessary because the audio is already in ASC format.

Live Playlists Versus VOD

VOD (Video on Demand) playlists have a fixed list of segments and an EXT-X-ENDLIST tag signaling the stream is complete. Live playlists, by contrast, are continuously updated with new segments as the broadcast progresses. Converting a live HLS stream to MP4 requires either waiting for the stream to end (so the playlist includes EXT-X-ENDLIST) or manually stopping the conversion after a desired duration. FFmpeg handles live streams by continuously reading the playlist until it encounters the end marker or until you terminate the process. For scheduled recording of live streams, specify a duration parameter to stop conversion automatically after a set time.

Codec Mismatches

If the HLS stream uses a codec that the MP4 container does not support (extremely rare with modern HLS but possible with experimental codecs), remux will fail. In this case, you must re-encode the stream to a compatible codec like H.264 for video and AAC for audio. Re-encoding is significantly slower than remuxing and introduces generation loss, so only use it when remux is not an option.

Advanced Scenarios

Beyond simple single-file conversion, several advanced HLS to MP4 workflows address more complex requirements.

Batch Converting Multiple HLS URLs

For processing multiple streams, FFmpeg can be invoked in sequence or in parallel from a script. A batch approach reads a list of .m3u8 URLs from a file or database, iterates through each URL, and runs the conversion for each. Parallel execution can speed up batch processing, but be mindful of bandwidth and CPU constraints. Each FFmpeg instance consumes network bandwidth for segment downloads, so running too many concurrent conversions may saturate your connection and cause individual conversions to fail due to segment download timeouts.

Trimming Specific Time Rations

FFmpeg supports seeking options that let you convert only a portion of an HLS stream. You can specify a start time and duration, and FFmpeg will download only the segments needed for that time range. This is useful for extracting clips from long HLS streams without downloading the entire playlist. Note that seeking precision depends on segment boundaries, so the actual start point may be slightly before the requested time to ensure a clean keyframe.

Merging Multiple Quality Variants

While you typically convert a single quality variant to MP4, some workflows require combining segments from different quality levels. This is uncommon but can occur when a live stream switches quality mid-broadcast and you want a single MP4 that includes all segments. FFmpeg can concatenate streams from different sources, but the codecs and resolutions must match for seamless playback. If they differ, re-encoding is necessary to normalize the output.

Programmatic Conversion with JavaScript Libraries

For developers building web applications that need HLS to MP4 conversion as a feature, JavaScript libraries provide a programmatic interface. Libraries like @invintusmedia/tomp4 and similar packages wrap the ffmpeg.wasm core into a simpler API, handling playlist parsing, segment downloading, and FFmpeg invocation behind a few function calls. This lets you integrate conversion into a web app without deep FFmpeg knowledge. Evaluate these libraries based on their maintenance activity, bundle size impact, and whether they support the specific HLS features your streams use (encryption, fMP4 segments, live playlists).

Legal and Ethical Considerations

Converting HLS to MP4 raises important legal and ethical questions that every developer should consider before downloading streams.
Copyright law protects most video content delivered via HLS, including movies, TV shows, live sports broadcasts, and educational content. Downloading and storing copyrighted content without permission from the rights holder may violate copyright law in most jurisdictions. Fair use exceptions exist for personal use, education, and research, but the specifics vary by country and context.
DRM (Digital Rights Management) protected streams use encryption keys that are licensed to specific playback environments. Bypassing DRM to convert HLS to MP4 is illegal under laws like the DMCA in the United States and similar legislation in other countries. If a stream uses DRM, conversion is not technically feasible without breaking the law.
Legitimate use cases for HLS to MP4 conversion include: creating offline copies of your own content, archiving educational lectures you have legitimate access to, processing streams for accessibility (adding subtitles, audio descriptions), and building video processing pipelines for content you own or have explicit permission to process. Always review the terms of service of the streaming platform before downloading content.

Quick Reference Cheat Sheet

Here is a condensed reference for the key concepts, tools, and file types covered in this guide:
  • HLS playlist files: .m3u8 (master and media playlists)
  • HLS segment files: .ts (MPEG-TS) or .m4s (fMP4)
  • MP4 container: .mp4 (universal playback format)
  • Primary conversion tool: FFmpeg (command-line, server-side)
  • Browser-based tool: ffmpeg.wasm (WebAssembly port)
  • Key FFmpeg option for remux: stream copy (no re-encoding, preserves quality)
  • Critical audio filter: aac_adtstoasc (converts ADTS to ASC for .ts to MP4)
  • Encryption tag in HLS: EXT-X-KEY (AES-128 key reference)
  • VOD completion marker: EXT-X-ENDLIST (signals playlist is complete)
  • CORS requirement: Server must allow cross-origin requests for browser-based conversion
  • DRM restriction: Encrypted streams with DRM cannot be legally converted
For a broader comparison of streaming protocols and formats, Streaming Media's technology coverage offers in-depth analysis of HLS, DASH, and emerging delivery methods.

Definitions Glossary

HLS (HTTP Live Streaming): An adaptive bitrate streaming protocol that delivers video as a playlist of small segment files over HTTP, developed by Apple. VideoSDK uses HLS as one of its output formats for live streaming, alongside its lower-latency Interactive Live Streaming mode.
M3U8 Playlist: A text file that serves as the index for an HLS stream, listing available quality variants (master playlist) or individual segment URLs (media playlist). The .m3u8 extension indicates UTF-8 encoded playlist content.
Remux (Stream Copy): The process of transferring audio and video streams from one container format to another without decoding or re-encoding, preserving original quality and minimizing processing time.
ADTS (Audio Data Transport Stream): A framing format for AAC audio commonly used in MPEG-TS segments. Converting ADTS-framed audio to MP4 requires the aac_adtstoasc bitstream filter to reformat headers.
fMP4 (Fragmented MP4): A variant of the MP4 container format used for streaming, where media data is divided into fragments that can be delivered incrementally. HLS streams using fMP4 segments (.m4s files) do not require the aac_adtstoasc filter for MP4 conversion.
EXT-X-KEY: An HLS playlist tag that specifies the encryption method and key location for encrypted segments, typically using AES-128 encryption.

Key Takeaways

  • Converting HLS to MP4 is primarily a remux operation that repackages segmented streams into a single container without quality loss, making it fast and efficient for standard H.264/AAC content.
  • FFmpeg is the most reliable tool for HLS to MP4 conversion, supporting encrypted streams, live playlists, batch processing, and time-range trimming through a single command-line interface.
  • Browser-based WebAssembly converters like ffmpeg.wasm offer zero-installation convenience but face CORS restrictions, memory limits, and cannot handle DRM-protected content.
  • The aac_adtstoasc bitstream filter is essential when converting .ts-based HLS segments to MP4, as it converts ADTS audio framing to the ASC format that MP4 requires.
  • Always verify you have legal permission to download and convert streamed content, as copyright law and DRM protections apply to most HLS-delivered video.

Conclusion

Converting HLS to MP4 bridges the gap between adaptive streaming delivery and portable, offline-ready video files. Whether you use FFmpeg for a server-side pipeline or a WebAssembly-based tool for in-browser convenience, the core process remains the same: parse the .m3u8 playlist, download segments, and remux them into a single MP4 container. The most common stumbling blocks, audio framing issues and encrypted streams, have well-understood solutions that this guide covers in detail.
If you are building a video application that needs real-time streaming with the option to record and export, consider how VideoSDK's recording capabilities can streamline this workflow. VideoSDK handles the complexity of segment management, recording, and format conversion as part of its video calling SDK, so you can focus on your application logic rather than media processing internals. You can also explore VideoSDK's code samples for practical integration examples.
What are you building with HLS or MP4 conversion? Drop a comment below, and I would love to hear what kind of video processing workflow you are working on. You can also join the VideoSDK Discord community to connect with other developers building real-time video applications.

Free $20 Balance for AI Voice Agents & Video Calls

Sign up here

FAQ