{"id":1217,"date":"2026-07-17T09:46:17","date_gmt":"2026-07-17T02:46:17","guid":{"rendered":"https:\/\/liveapi.com\/blog\/fragmented-mp4\/"},"modified":"2026-07-17T09:46:46","modified_gmt":"2026-07-17T02:46:46","slug":"fragmented-mp4","status":"publish","type":"post","link":"https:\/\/liveapi.com\/blog\/fragmented-mp4\/","title":{"rendered":"What Is Fragmented MP4 (fMP4)? How It Works and When to Use It"},"content":{"rendered":"<span class=\"rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\">9<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span><p>Try to stream a regular MP4 file and you hit a wall fast: the player has to download the whole thing, or at least seek to the end, before a single frame plays. That works for a download. It falls apart for adaptive streaming, live video, and anything that needs to start in under a second.<\/p>\n<p>Fragmented MP4 fixes that. It takes the same familiar MP4 container and reorganizes it into small, independently playable chunks. Those chunks are what HLS, MPEG-DASH, and CMAF ship over the wire today.<\/p>\n<p>If you&#8217;re building video features, fMP4 is the packaging format sitting underneath most of them. Here&#8217;s what it is, how the structure works, how it differs from a standard MP4, and how to generate it yourself.<\/p>\n<h2>What Is Fragmented MP4?<\/h2>\n<p>Fragmented MP4 (fMP4) is an MP4 container whose media is split into a sequence of independently decodable fragments, each made of a <code>moof<\/code> (movie fragment) box paired with an <code>mdat<\/code> (media data) box.<\/p>\n<p>A standard MP4 stores all its timing and index metadata in one big <code>moov<\/code> box, describing the entire file at once. A fragmented MP4 breaks that metadata into pieces and spreads it across the file, so each fragment carries the metadata for just its own slice of audio and video.<\/p>\n<p>That single change is what makes the format streamable. A player can request one fragment, decode it, and play it without ever seeing the rest of the file. New fragments can also be written in real time, which is why fMP4 works for live streaming as well as on-demand.<\/p>\n<p>The format is defined in the ISO Base Media File Format (ISO\/IEEE 14496-12), the same specification that governs standard MP4. Fragmented MP4 isn&#8217;t a different file type. It&#8217;s a specific way of arranging the boxes inside an MP4.<\/p>\n<h2>Fragmented MP4 vs Standard MP4<\/h2>\n<p>The clearest way to understand fMP4 is to compare it against the progressive MP4 you already know. Both use the <code>.mp4<\/code> extension and the same box vocabulary, but they organize data very differently.<\/p>\n<table>\n<thead>\n<tr>\n<th>Attribute<\/th>\n<th>Standard (Progressive) MP4<\/th>\n<th>Fragmented MP4 (fMP4)<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Metadata layout<\/td>\n<td>Single <code>moov<\/code> box for the whole file<\/td>\n<td><code>moov<\/code> init segment + per-fragment <code>moof<\/code> boxes<\/td>\n<\/tr>\n<tr>\n<td>Playback start<\/td>\n<td>Needs full index (often at file end)<\/td>\n<td>Starts after one small fragment<\/td>\n<\/tr>\n<tr>\n<td>Streaming model<\/td>\n<td>Download \/ progressive download<\/td>\n<td>Adaptive streaming (HLS, DASH, CMAF)<\/td>\n<\/tr>\n<tr>\n<td>Live support<\/td>\n<td>No<\/td>\n<td>Yes (fragments generated on the fly)<\/td>\n<\/tr>\n<tr>\n<td>Bitrate switching<\/td>\n<td>Not practical<\/td>\n<td>Native, at fragment boundaries<\/td>\n<\/tr>\n<tr>\n<td>Seeking<\/td>\n<td>Requires full <code>moov<\/code><\/td>\n<td>Uses fragment index or segment list<\/td>\n<\/tr>\n<tr>\n<td>Best for<\/td>\n<td>Local files, simple downloads<\/td>\n<td>Streaming, low latency, live<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>There&#8217;s also a middle option you&#8217;ll see referenced in tools and forums: <strong>hybrid MP4<\/strong>. When people compare hybrid MP4 vs fragmented MP4, hybrid usually means a &#8220;fast-start&#8221; progressive file: the <code>moov<\/code> box is moved to the front so progressive download can begin sooner, but the file still isn&#8217;t fragmented. Hybrid MP4 helps a plain download start faster; only true fragmentation enables adaptive bitrate switching and live delivery.<\/p>\n<p>If you&#8217;re weighing container choices more broadly, our guide to the <a href=\"https:\/\/liveapi.com\/blog\/best-video-format\/\" target=\"_blank\">best video format<\/a> covers where MP4 fits against alternatives, and the <a href=\"https:\/\/liveapi.com\/blog\/h264-vs-mp4\/\" target=\"_blank\">H.264 vs MP4<\/a> breakdown clears up the common codec-versus-container confusion.<\/p>\n<h2>How Does Fragmented MP4 Work?<\/h2>\n<p>MP4 files are built from nested containers called boxes (older specs call them atoms). Fragmented MP4 uses the same boxes as a standard MP4, then adds a few more and rearranges the order. Understanding the layout makes everything else click.<\/p>\n<h3>The initialization segment<\/h3>\n<p>Every fMP4 stream opens with an <strong>initialization segment<\/strong>. It contains:<\/p>\n<ul>\n<li><strong><code>ftyp<\/code><\/strong>: the file type box, declaring which specifications the file conforms to.<\/li>\n<li><strong><code>moov<\/code><\/strong>: the movie box, but here it holds only global setup: track definitions, codec configuration, and timescales. It carries <em>no<\/em> sample data and <em>no<\/em> per-sample timing.<\/li>\n<\/ul>\n<p>The init segment is the &#8220;how to decode this&#8221; header. A player downloads it once, then reuses it for every media segment that follows.<\/p>\n<h3>The media segments<\/h3>\n<p>After the init segment come the media segments. Each one is a self-contained fragment built from two boxes:<\/p>\n<ul>\n<li><strong><code>moof<\/code><\/strong>: the movie fragment box. It holds the metadata for this fragment only: sample counts, durations, sizes, and byte offsets into the media data that follows.<\/li>\n<li><strong><code>mdat<\/code><\/strong>: the media data box. It carries the actual compressed audio and video samples for this fragment.<\/li>\n<\/ul>\n<p>Because the <code>moof<\/code> describes exactly the samples in its paired <code>mdat<\/code>, the player can decode that fragment on its own, with no need to look back at earlier fragments or ahead to later ones. Fragments typically break on keyframes, which is why your <a href=\"https:\/\/liveapi.com\/blog\/keyframe-interval\/\" target=\"_blank\">keyframe interval<\/a> setting directly controls how cleanly a stream can be segmented and switched.<\/p>\n<h3>Extra boxes for DASH and CMAF<\/h3>\n<p>Depending on the delivery protocol, you&#8217;ll also see:<\/p>\n<ul>\n<li><strong><code>styp<\/code><\/strong>: the segment type box, marking the start of each media segment in DASH.<\/li>\n<li><strong><code>sidx<\/code><\/strong>: the segment index box, a lightweight index that lets players seek to a byte range without a full <code>moov<\/code>.<\/li>\n<\/ul>\n<p>Put together, a fragmented MP4 looks like this: <code>ftyp<\/code> + <code>moov<\/code> (init), then repeating <code>styp<\/code> + <code>sidx<\/code> + <code>moof<\/code> + <code>mdat<\/code> (each media segment). This structure is what powers adaptive streaming and keeps <a href=\"https:\/\/liveapi.com\/blog\/what-is-video-latency\/\" target=\"_blank\">video latency<\/a> low, since a player only ever waits on one small fragment.<\/p>\n<h2>Two Ways to Deliver Fragmented MP4<\/h2>\n<p>Once a file is fragmented, there are two ways to serve those fragments to a player.<\/p>\n<ol>\n<li><strong>One <code>.mp4<\/code> file with byte-range requests.<\/strong> All fragments live in a single file. The player uses HTTP <code>Range<\/code> headers (guided by the <code>sidx<\/code> index) to pull only the fragment it needs. This keeps your storage tidy, with one file per rendition.<\/li>\n<\/ol>\n<ol>\n<li><strong>Many <code>.m4s<\/code> files, one per fragment.<\/strong> The stream is split into a separate initialization file (often <code>init.mp4<\/code>) and a series of <code>.m4s<\/code> media segment files. The player requests each segment with a normal GET. This is the classic layout for HLS and DASH, where a playlist or manifest lists every segment URL.<\/li>\n<\/ol>\n<p>Both approaches deliver identical media. The choice usually comes down to your packager and CDN setup. Segment-per-file is easiest to cache and debug; single-file byte-range means fewer objects to manage.<\/p>\n<h2>Fragmented MP4 and Adaptive Streaming: HLS, DASH, and CMAF<\/h2>\n<p>fMP4 matters because it&#8217;s the container that modern streaming protocols agreed to share.<\/p>\n<p><strong>MPEG-DASH<\/strong> has used fragmented MP4 segments from the start. A DASH manifest points at an init segment plus a list of media segments, each a <code>moof<\/code>\/<code>mdat<\/code> fragment. See our <a href=\"https:\/\/liveapi.com\/blog\/mpeg-dash\/\" target=\"_blank\">MPEG-DASH guide<\/a> for how the manifest and segments fit together.<\/p>\n<p><strong>HLS<\/strong> originally required MPEG-TS segments. In 2016 <a href=\"https:\/\/developer.apple.com\/documentation\/http-live-streaming\/hls-authoring-specification-for-apple-devices\" target=\"_blank\" rel=\"nofollow\">Apple added fMP4 support<\/a> to HLS, letting the protocol use the same fragmented MP4 segments as DASH. That change is what made a single set of files playable by both ecosystems. If HLS is new to you, start with <a href=\"https:\/\/liveapi.com\/blog\/what-is-hls-streaming\/\" target=\"_blank\">what HLS streaming is<\/a>.<\/p>\n<p><strong>CMAF<\/strong> (Common Media Application Format) is the standard that formalized this shared approach. CMAF defines a fragmented MP4 segment format so one set of encoded files can serve both HLS and DASH. You package once instead of twice. Our <a href=\"https:\/\/liveapi.com\/blog\/what-is-cmaf\/\" target=\"_blank\">CMAF explainer<\/a> and the <a href=\"https:\/\/liveapi.com\/blog\/cmaf-vs-hls\/\" target=\"_blank\">CMAF vs HLS<\/a> comparison go deeper, and <a href=\"https:\/\/liveapi.com\/blog\/hls-vs-dash\/\" target=\"_blank\">HLS vs DASH<\/a> covers where the two protocols still differ.<\/p>\n<p>In all three cases, fragmentation is the enabler. Without independently decodable fragments, <a href=\"https:\/\/liveapi.com\/blog\/adaptive-bitrate-streaming\/\" target=\"_blank\">adaptive bitrate streaming<\/a> (switching quality mid-stream as bandwidth changes) wouldn&#8217;t work.<\/p>\n<h2>Advantages of Fragmented MP4<\/h2>\n<p>fMP4 became the default streaming container for concrete reasons.<\/p>\n<h3>Fast playback start<\/h3>\n<p>A player only needs the init segment plus the first fragment to begin. There&#8217;s no waiting for a multi-gigabyte file to download or for a full index at the end. Startup drops from seconds to a fraction of a second.<\/p>\n<h3>Adaptive bitrate switching<\/h3>\n<p>Because each fragment stands alone, a player can pull the next fragment from a higher- or lower-quality rendition based on current bandwidth. Viewers get smooth playback instead of buffering when their connection dips.<\/p>\n<h3>Live streaming support<\/h3>\n<p>Fragments can be created and published while a broadcast is still running. A live encoder writes new <code>moof<\/code>\/<code>mdat<\/code> pairs continuously, and players fetch them as they appear \u2014 the foundation of any <a href=\"https:\/\/liveapi.com\/blog\/live-event-streaming\/\" target=\"_blank\">live event streaming<\/a> workflow.<\/p>\n<h3>Write-once packaging with CMAF<\/h3>\n<p>Using CMAF fMP4 segments, you encode and store one set of files that serves both HLS and DASH. That halves storage and origin complexity compared with maintaining separate TS and MP4 renditions.<\/p>\n<h3>Crash resilience for recording<\/h3>\n<p>Because metadata is written per fragment instead of only at the end, a fragmented MP4 recording survives an unexpected crash. This is exactly why OBS offers a &#8220;fragmented MP4&#8221; recording option. If the app dies mid-record, you keep everything up to the last fragment instead of a corrupt, headerless file.<\/p>\n<h3>Efficient seeking<\/h3>\n<p>The <code>sidx<\/code> index or segment playlist lets a player jump to any point by fetching only the relevant fragment, without downloading the full file first.<\/p>\n<h2>Disadvantages of Fragmented MP4<\/h2>\n<p>fMP4 isn&#8217;t the right choice for every job.<\/p>\n<h3>Slightly larger files<\/h3>\n<p>Repeating <code>moof<\/code> metadata across every fragment adds overhead. A fragmented file is a bit larger than the same content as a single progressive MP4, usually a small percentage but real.<\/p>\n<h3>Compatibility quirks<\/h3>\n<p>Some older players, editors, and tools expect a single <code>moov<\/code> box and choke on fragments. If you need a plain file for a legacy download workflow, you may have to convert fragmented MP4 to MP4 first (FFmpeg can remux it back).<\/p>\n<h3>More moving parts<\/h3>\n<p>A fragmented stream means an init segment plus many media segments and a manifest. That&#8217;s more objects to package, host, and cache than one self-contained file, though a managed platform hides most of this.<\/p>\n<h3>Not needed for simple downloads<\/h3>\n<p>If your use case is &#8220;let users download a video file,&#8221; standard or fast-start MP4 is simpler and marginally smaller. Fragmentation only pays off when you&#8217;re streaming adaptively or going live.<\/p>\n<p>Most of these trade-offs disappear once packaging is handled for you. That&#8217;s the line where building it yourself gives way to using infrastructure that already outputs streaming-ready fMP4. That&#8217;s where the practical steps come in.<\/p>\n<h2>How to Create Fragmented MP4 with FFmpeg<\/h2>\n<p>The most common way to fragment an MP4 by hand is FFmpeg&#8217;s <code>-movflags<\/code>. To remux an existing file into fragmented MP4 without re-encoding:<\/p>\n<pre><code>ffmpeg -i input.mp4 -c copy \\\n  -movflags frag_keyframe+empty_moov+default_base_moof \\\n  output_fragmented.mp4<\/code><\/pre>\n<p>What those flags do:<\/p>\n<ul>\n<li><strong><code>frag_keyframe<\/code><\/strong>: start a new fragment at each keyframe, so fragments are independently decodable.<\/li>\n<li><strong><code>empty_moov<\/code><\/strong>: write an init-style <code>moov<\/code> with no sample data at the front, instead of a full index at the end.<\/li>\n<li><strong><code>default_base_moof<\/code><\/strong>: use each fragment&#8217;s own position as its base offset, which improves player compatibility.<\/li>\n<\/ul>\n<p>To package directly into fMP4-based HLS with separate <code>.m4s<\/code> segments and an <code>init.mp4<\/code>:<\/p>\n<pre><code>ffmpeg -i input.mp4 -c copy \\\n  -hls_segment_type fmp4 \\\n  -hls_time 4 \\\n  -hls_playlist_type vod \\\n  output.m3u8<\/code><\/pre>\n<p>Here <code>-hls_segment_type fmp4<\/code> tells the HLS muxer to emit fragmented MP4 segments (the CMAF-friendly path) instead of MPEG-TS. The <a href=\"https:\/\/ffmpeg.org\/ffmpeg-formats.html\" target=\"_blank\" rel=\"nofollow\">FFmpeg movflags documentation<\/a> lists every fragmentation option if you need finer control.<\/p>\n<p>For recording rather than transcoding, OBS Studio exposes the same idea as a checkbox. Enabling &#8220;Automatically remux to mp4&#8221; or selecting fragmented MP4 output protects your recording against corruption. If you&#8217;re moving live streams into on-demand catalogs, our <a href=\"https:\/\/liveapi.com\/blog\/rtmp-to-hls\/\" target=\"_blank\">RTMP to HLS<\/a> walkthrough shows the packaging step in context, and <a href=\"https:\/\/liveapi.com\/blog\/ffmpeg-join-videos\/\" target=\"_blank\">FFmpeg for joining videos<\/a> covers related remuxing tasks.<\/p>\n<h2>Fragmented MP4 in Your Streaming Stack<\/h2>\n<p>FFmpeg is great for one-off jobs and learning the format. Running fragmentation, transcoding, and packaging in production, across every device, at scale, with a CDN in front, is a different level of effort.<\/p>\n<p>That&#8217;s the gap LiveAPI fills. Its <a href=\"https:\/\/liveapi.com\/blog\/video-transcoding-api\/\" target=\"_blank\">video encoding API<\/a> handles <a href=\"https:\/\/liveapi.com\/blog\/what-is-video-transcoding\/\" target=\"_blank\">transcoding<\/a> and packaging for you: you upload or stream a source, and LiveAPI produces adaptive bitrate HLS output built on fragmented MP4 segments, playable in seconds thanks to instant encoding. You never touch <code>movflags<\/code> or manage segment files.<\/p>\n<p>Delivery runs across multiple CDNs (Akamai, Cloudflare, Fastly) with an embeddable HTML5 player, so the fMP4 segments reach viewers worldwide without you standing up origins or edge caching. For teams building on top of this, the <a href=\"https:\/\/liveapi.com\/blog\/video-hosting-api\/\" target=\"_blank\">Video Hosting API<\/a> and the <a href=\"https:\/\/liveapi.com\/blog\/video-api-developer-guide\/\" target=\"_blank\">video API developer guide<\/a> show how the pieces connect. If you&#8217;re supporting devices that need a downloadable file too, our note on <a href=\"https:\/\/liveapi.com\/blog\/convert-m3u8-to-mp4\/\" target=\"_blank\">converting M3U8 to MP4<\/a> covers the reverse path.<\/p>\n<p>The point: fragmented MP4 is the format your streams travel in, but you rarely need to generate it by hand once packaging is part of your infrastructure.<\/p>\n<h2>Is Fragmented MP4 Right for Your Project?<\/h2>\n<p>Use this quick checklist. If you answer yes to any of these, fMP4 is your container:<\/p>\n<ul>\n<li>You&#8217;re delivering <strong>adaptive bitrate streaming<\/strong> over HLS or DASH.<\/li>\n<li>You need <strong>live streaming<\/strong> where fragments are written in real time.<\/li>\n<li>You want <strong>CMAF<\/strong> packaging that serves HLS and DASH from one set of files.<\/li>\n<li>You need <strong>sub-second startup<\/strong> and smooth quality switching.<\/li>\n<li>You&#8217;re recording video and want <strong>crash-resistant<\/strong> files.<\/li>\n<\/ul>\n<p>Stick with standard or fast-start MP4 when:<\/p>\n<ul>\n<li>You only offer files for <strong>download or offline playback<\/strong>.<\/li>\n<li>You must support <strong>legacy tools<\/strong> that expect a single <code>moov<\/code> box.<\/li>\n<li>File size is critical and you don&#8217;t need streaming at all.<\/li>\n<\/ul>\n<h2>Fragmented MP4 FAQ<\/h2>\n<h3>What is fragmented MP4 in simple terms?<\/h3>\n<p>It&#8217;s an MP4 file split into small, independently playable chunks (fragments) instead of one continuous block with a single index. Each fragment has its own metadata, so a player can start playing after downloading just the first piece \u2014 which is what makes it streamable.<\/p>\n<h3>What&#8217;s the difference between fragmented MP4 and MP4?<\/h3>\n<p>A standard MP4 keeps all metadata in one <code>moov<\/code> box and needs the full index before smooth playback. A fragmented MP4 spreads metadata across per-fragment <code>moof<\/code> boxes, so playback starts after one small segment and the file supports adaptive and live streaming.<\/p>\n<h3>What is fragmented MP4 in OBS?<\/h3>\n<p>OBS offers a fragmented MP4 recording option so your file stays usable if OBS crashes mid-recording. Because each fragment&#8217;s metadata is written as it goes (not only when recording stops), you keep everything up to the last fragment instead of a corrupted file.<\/p>\n<h3>Does HLS use fragmented MP4?<\/h3>\n<p>Yes, since 2016. HLS originally used MPEG-TS segments, but Apple added fMP4 support so HLS can share the same fragmented MP4 (CMAF) segments as MPEG-DASH. You can still use TS segments, but fMP4 is now the common path.<\/p>\n<h3>What is the difference between hybrid MP4 and fragmented MP4?<\/h3>\n<p>Hybrid MP4 usually means a fast-start progressive file where the <code>moov<\/code> box is moved to the front so progressive download starts sooner, but the file isn&#8217;t fragmented. Fragmented MP4 goes further, splitting the media into independent fragments that enable adaptive bitrate switching and live streaming.<\/p>\n<h3>How do I convert fragmented MP4 to a regular MP4?<\/h3>\n<p>Remux it with FFmpeg. Running <code>ffmpeg -i fragmented.mp4 -c copy output.mp4<\/code> rewrites the fragments into a single <code>moov<\/code>-indexed file without re-encoding, producing a standard MP4 that legacy tools can open.<\/p>\n<h3>Is fMP4 the same as CMAF?<\/h3>\n<p>Not exactly. CMAF is a standard that <em>specifies<\/em> a fragmented MP4 segment format so one set of files works for both HLS and DASH. All CMAF segments are fragmented MP4, but not every fMP4 file follows the CMAF constraints.<\/p>\n<h3>Why is a fragmented MP4 slightly larger?<\/h3>\n<p>Each fragment repeats a <code>moof<\/code> metadata box describing its own samples, so the same content carries more metadata overall than a single-index progressive MP4. The overhead is usually a small percentage and is the trade-off for streamability.<\/p>\n<h2>Bringing It Together<\/h2>\n<p>Fragmented MP4 takes the ordinary MP4 container and reorganizes it into independent <code>moof<\/code>\/<code>mdat<\/code> fragments plus a one-time init segment. That structure is what lets HLS, MPEG-DASH, and CMAF start fast, switch bitrates on the fly, and deliver live video. A standard MP4 can&#8217;t do any of that.<\/p>\n<p>You can fragment files yourself with FFmpeg when you&#8217;re experimenting. For production streaming across every device and region, packaging is better handled by infrastructure built for it. <a href=\"https:\/\/liveapi.com\/\" target=\"_blank\">Get started with LiveAPI<\/a> and ship adaptive, fMP4-based streaming without managing segments, movflags, or CDNs yourself.<\/p>\n","protected":false},"excerpt":{"rendered":"<p><span class=\"rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\">9<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span> Try to stream a regular MP4 file and you hit a wall fast: the player has to download the whole thing, or at least seek to the end, before a single frame plays. That works for a download. It falls apart for adaptive streaming, live video, and anything that needs to start in under a [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":1218,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_yoast_wpseo_title":"What Is Fragmented MP4 (fMP4)? How It Works %%sep%% %%sitename%%","_yoast_wpseo_metadesc":"Learn what fragmented MP4 (fMP4) is, how the moof\/mdat structure works, how it differs from standard MP4, and how to create it with FFmpeg for streaming.","inline_featured_image":false,"footnotes":""},"categories":[16],"tags":[],"class_list":["post-1217","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-video-format"],"jetpack_featured_media_url":"https:\/\/liveapi.com\/blog\/wp-content\/uploads\/2026\/07\/fragmented-mp4.jpg","yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v15.6.2 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<meta name=\"description\" content=\"Learn what fragmented MP4 (fMP4) is, how the moof\/mdat structure works, how it differs from standard MP4, and how to create it with FFmpeg for streaming.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/liveapi.com\/blog\/fragmented-mp4\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"What Is Fragmented MP4 (fMP4)? How It Works - LiveAPI Blog\" \/>\n<meta property=\"og:description\" content=\"Learn what fragmented MP4 (fMP4) is, how the moof\/mdat structure works, how it differs from standard MP4, and how to create it with FFmpeg for streaming.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/liveapi.com\/blog\/fragmented-mp4\/\" \/>\n<meta property=\"og:site_name\" content=\"LiveAPI Blog\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-17T02:46:17+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-07-17T02:46:46+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\">\n\t<meta name=\"twitter:data1\" content=\"13 minutes\">\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebSite\",\"@id\":\"https:\/\/liveapi.com\/blog\/#website\",\"url\":\"https:\/\/liveapi.com\/blog\/\",\"name\":\"LiveAPI Blog\",\"description\":\"Live Video Streaming API Blog\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":\"https:\/\/liveapi.com\/blog\/?s={search_term_string}\",\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/liveapi.com\/blog\/fragmented-mp4\/#primaryimage\",\"inLanguage\":\"en-US\",\"url\":\"https:\/\/liveapi.com\/blog\/wp-content\/uploads\/2026\/07\/fragmented-mp4.jpg\",\"width\":1880,\"height\":1255,\"caption\":\"Photo by panumas nikhomkhai on Pexels\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/liveapi.com\/blog\/fragmented-mp4\/#webpage\",\"url\":\"https:\/\/liveapi.com\/blog\/fragmented-mp4\/\",\"name\":\"What Is Fragmented MP4 (fMP4)? How It Works - LiveAPI Blog\",\"isPartOf\":{\"@id\":\"https:\/\/liveapi.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/liveapi.com\/blog\/fragmented-mp4\/#primaryimage\"},\"datePublished\":\"2026-07-17T02:46:17+00:00\",\"dateModified\":\"2026-07-17T02:46:46+00:00\",\"author\":{\"@id\":\"https:\/\/liveapi.com\/blog\/#\/schema\/person\/98f2ee8b3a0bd93351c0d9e8ce490e4a\"},\"description\":\"Learn what fragmented MP4 (fMP4) is, how the moof\/mdat structure works, how it differs from standard MP4, and how to create it with FFmpeg for streaming.\",\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/liveapi.com\/blog\/fragmented-mp4\/\"]}]},{\"@type\":\"Person\",\"@id\":\"https:\/\/liveapi.com\/blog\/#\/schema\/person\/98f2ee8b3a0bd93351c0d9e8ce490e4a\",\"name\":\"govz\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/liveapi.com\/blog\/#personlogo\",\"inLanguage\":\"en-US\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/ab5cbe0543c0a44dc944c720159323bd001fc39a8ba5b1f137cd22e7578e84c9?s=96&d=mm&r=g\",\"caption\":\"govz\"},\"sameAs\":[\"https:\/\/liveapi.com\/blog\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","_links":{"self":[{"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/posts\/1217","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/comments?post=1217"}],"version-history":[{"count":1,"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/posts\/1217\/revisions"}],"predecessor-version":[{"id":1219,"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/posts\/1217\/revisions\/1219"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/media\/1218"}],"wp:attachment":[{"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/media?parent=1217"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/categories?post=1217"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/liveapi.com\/blog\/wp-json\/wp\/v2\/tags?post=1217"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}