{"id":43,"date":"2026-11-19T03:39:25","date_gmt":"2026-11-19T03:39:25","guid":{"rendered":"https:\/\/globalcorpora.com\/blog\/fast-video-decoding-data-loaders-training\/"},"modified":"2026-11-19T03:39:25","modified_gmt":"2026-11-19T03:39:25","slug":"fast-video-decoding-data-loaders-training","status":"publish","type":"post","link":"https:\/\/globalcorpora.com\/blog\/fast-video-decoding-data-loaders-training\/","title":{"rendered":"Video Data Loader: Fast Video Decoding for Model Training"},"content":{"rendered":"<p>Your GPUs sit at 40% utilization, and the profiler blames the video data loader rather than the model. Video training is usually limited by decoding: the work grows with every frame the codec has to reconstruct, not just the frames you keep. This guide covers why that happens, how keyframes and GOP length set the cost of a seek, what PyAV, decord, TorchCodec and NVIDIA DALI offer as of November 2026, and how to estimate the CPU or GPU decode capacity you need before you buy it.<\/p>\n<h2>TL;DR<\/h2>\n<ul>\n<li><strong>Cost is decoded frames, not sampled frames.<\/strong> A seek lands on the previous keyframe, so with long GOPs you pay for many frames you throw away.<\/li>\n<li><strong>Re-encode training clips with a short, fixed GOP<\/strong> (<code>-g<\/code>, <code>-keyint_min<\/code>, <code>-sc_threshold 0<\/code>) at the resolution and frame rate you train on. It is usually the cheapest speedup available.<\/li>\n<li><strong>TorchCodec is the PyTorch default now.<\/strong> torchvision removed its video decoding API (<code>read_video<\/code>, <code>VideoReader<\/code>) in 0.26. decord's last PyPI release was 0.6.0 in June 2021.<\/li>\n<li><strong>GPU decoding (NVDEC via TorchCodec or DALI) helps when CPUs run out<\/strong>, mainly at high resolution. Check codec support and CPU fallback.<\/li>\n<li><strong>Keep encoded bytes in WebDataset shards<\/strong>, shuffle before decoding, and decode inside the workers.<\/li>\n<\/ul>\n<h2>Why decoding is the bottleneck<\/h2>\n<p>Codecs like H.264, HEVC, VP9 and AV1 store a complete picture only at keyframes. Every other frame is predicted from its neighbours. To get frame <em>k<\/em>, the decoder starts at the previous keyframe and reconstructs every frame up to <em>k<\/em>. The <a href=\"https:\/\/pyav.basswood-io.com\/docs\/stable\/api\/container.html\">PyAV container docs<\/a> say it plainly: seeking goes to the nearest keyframe, \"because to properly decode video frames you need to start from the previous keyframe\".<\/p>\n<p>Three costs add up per training sample:<\/p>\n<ul>\n<li><strong>Entropy decoding and reconstruction<\/strong> of every frame between the keyframe and the target. This scales with resolution and bitrate.<\/li>\n<li><strong>Color conversion and resize<\/strong> from YUV 4:2:0 to RGB at the source resolution, before you downscale to 224 or 256 px.<\/li>\n<li><strong>Memory traffic.<\/strong> A raw 1080p RGB frame is 1920 \u00d7 1080 \u00d7 3 = 6,220,800 bytes. A 224 \u00d7 224 one is 150,528 bytes.<\/li>\n<\/ul>\n<p>Images are different: one JPEG decode yields one sample. A 16-frame video clip can need hundreds of frame decodes if sampling ignores where the keyframes are.<\/p>\n<h2>Seeking cost: keyframes and GOP length<\/h2>\n<p>Let <code>G<\/code> be the GOP length in frames (keyframe interval), <code>N<\/code> the frames you sample, and <code>L<\/code> the clip length in frames. If a target frame lands uniformly within a GOP:<\/p>\n<pre><code>decoded per random seek   ~ (G + 1) \/ 2\nseek per sampled frame    D_seek ~ N x (G + 1) \/ 2     (targets in different GOPs)\ndecode straight through   D_seq  ~ index of last sampled frame  (&lt;= L)\ncost per sample           D = min(D_seek, D_seq)\n\nexample A: G = 250, N = 8, L = 300 -&gt; D_seek ~ 1,004, D_seq ~ 300 -&gt; decode through\nexample B: G = 16,  N = 8, L = 300 -&gt; D_seek ~ 68                  -&gt; seek<\/code><\/pre>\n<p>The example values are illustrative. Measure your own files: <code>ffprobe -v error -select_streams v:0 -show_entries packet=pts_time,flags -of csv=p=0 clip.mp4<\/code> lists packets, and keyframes carry a <code>K<\/code> flag. Web video is typically encoded for streaming, so keyframes are often seconds apart. Our <a href=\"https:\/\/globalcorpora.com\/blog\/split-videos-into-clips-pyscenedetect-training-data\/\">guide to splitting videos into clips with PySceneDetect<\/a> covers the cutting side of the same problem.<\/p>\n<p>Two more effects to know about:<\/p>\n<ul>\n<li><strong>Exact vs approximate indexing.<\/strong> TorchCodec's default <code>seek_mode=\"exact\"<\/code> scans the file when the decoder is created, to build a frame index. <code>\"approximate\"<\/code> skips the scan and uses header metadata. Its docs say approximate is faster for long videos when you decode only a few frames. DALI's <code>fn.decoders.video<\/code> has the same trade-off via <code>build_index<\/code>.<\/li>\n<li><strong>Variable frame rate.<\/strong> DALI's <code>fn.readers.video<\/code> supports only constant frame rate input. Normalizing frame rate during re-encoding avoids index-vs-timestamp surprises in every library.<\/li>\n<\/ul>\n<h2>The decoder options in late 2026<\/h2>\n<table>\n<thead>\n<tr>\n<th>Library<\/th>\n<th>Status (Nov 2026)<\/th>\n<th>Device<\/th>\n<th>Notes<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><a href=\"https:\/\/github.com\/meta-pytorch\/torchcodec\">TorchCodec<\/a><\/td>\n<td>Active; 0.17.0 on PyPI (Sept 2026)<\/td>\n<td>CPU, CUDA (NVDEC)<\/td>\n<td>Returns PyTorch tensors; accepts paths, bytes, tensors, file-like objects; built-in clip samplers<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/pyav.basswood-io.com\/docs\/stable\/cookbook\/basics.html\">PyAV<\/a><\/td>\n<td>Active; 19.0.2 (Oct 2026)<\/td>\n<td>CPU<\/td>\n<td>Thin FFmpeg bindings; full control, more code<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/docs.nvidia.com\/deeplearning\/dali\/user-guide\/docs\/operations\/nvidia.dali.fn.readers.video.html\">NVIDIA DALI<\/a><\/td>\n<td>Active; 2.4.0 (Oct 2026)<\/td>\n<td>GPU reader; CPU or mixed decoder<\/td>\n<td>Whole pipeline on GPU; WebDataset reader built in<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/dmlc\/decord\">decord<\/a><\/td>\n<td>Last PyPI release 0.6.0 (June 2021); last push July 2024; not archived<\/td>\n<td>CPU wheels; GPU needs a source build<\/td>\n<td>Convenient <code>get_batch<\/code> API; pin carefully or migrate<\/td>\n<\/tr>\n<tr>\n<td>torchvision.io video<\/td>\n<td>Removed in torchvision 0.26<\/td>\n<td>n\/a<\/td>\n<td>Release notes point users to TorchCodec<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>On torchvision: the <a href=\"https:\/\/github.com\/pytorch\/vision\/releases\/tag\/v0.26.0\">0.26 release notes<\/a> say the long-deprecated video decoding and encoding utilities are removed. That covers <code>torchvision.io.video.*<\/code>, <code>read_video<\/code>, <code>write_video<\/code> and the <code>VideoReader<\/code> class. torchvision 0.29 went further and deprecated its image decoders in favor of TorchCodec. If old training code imports <code>torchvision.io.read_video<\/code>, it fails on current releases, and TorchCodec has a migration guide.<\/p>\n<p>On decord: its README says only CPU builds ship on PyPI and that GPU decoding needs a source build with <code>-DUSE_CUDA=ON<\/code>. The 0.6.0 wheels are a manylinux2010 Linux build, a Windows build, and macOS builds for Python 3.6\u20133.8 only. It still works in many existing codebases, but treat it as unmaintained for new pipelines.<\/p>\n<h3>TorchCodec<\/h3>\n<p><code>VideoDecoder<\/code> takes <code>device<\/code>, <code>seek_mode<\/code>, <code>num_ffmpeg_threads<\/code> (default 1, recommended when many decoders run in parallel), <code>dimension_order<\/code> and decoder-side <code>transforms<\/code>. The batch methods (<code>get_frames_at<\/code>, <code>get_frames_played_at<\/code>, <code>get_frames_in_range<\/code>) are faster than repeated single-frame calls, according to its <a href=\"https:\/\/meta-pytorch.org\/torchcodec\/stable\/generated_examples\/decoding\/performance_tips.html\">performance tips<\/a>.<\/p>\n<pre><code>import torch\nfrom torchcodec.decoders import VideoDecoder\nfrom torchcodec.transforms import Resize\n\ndef uniform_n_frames(src, n=16):\n    \"\"\"src: path, bytes or tensor. Returns uint8 [n, C, 224, 224].\"\"\"\n    dec = VideoDecoder(src, seek_mode=\"approximate\",\n                       transforms=[Resize(size=(224, 224))])\n    total = dec.metadata.num_frames            # from headers in approximate mode\n    idx = torch.linspace(0, total - 1, n).round().long().tolist()\n    return dec.get_frames_at(indices=idx).data\n\ndef fixed_fps(src, fps=4.0, max_frames=32):\n    dec = VideoDecoder(src, seek_mode=\"approximate\")\n    dur = dec.metadata.duration_seconds\n    ts = [i \/ fps for i in range(min(max_frames, int(dur * fps)))]\n    return dec.get_frames_played_at(seconds=ts).data<\/code><\/pre>\n<p>For GPU decoding, pass <code>device=\"cuda\"<\/code>. Frames are then decoded by NVDEC and stay in GPU memory. Per TorchCodec's docs, decoding can silently fall back to CPU when NVDEC doesn't support the codec or format, so log <code>dec.cpu_fallback<\/code> once a frame has been decoded. The same page recommends CUDA decoding for high-resolution video or when the CPU is saturated. It advises against it for small-resolution video, for an already busy GPU, or when you need bit-exact parity with CPU decoding.<\/p>\n<h3>PyAV<\/h3>\n<p>PyAV gives you packets and frames and nothing else, which suits custom sampling logic. Enable frame threading with <code>stream.thread_type = \"AUTO\"<\/code>. The PyAV cookbook notes the default is slice threading, and frame threading adds decode latency.<\/p>\n<pre><code>import av\n\ndef frames_at_times(path, times_s):\n    out = []\n    with av.open(path) as c:\n        s = c.streams.video[0]\n        s.thread_type = \"AUTO\"\n        for t in sorted(times_s):\n            c.seek(int(t \/ s.time_base), stream=s)    # lands on keyframe &lt;= t\n            for f in c.decode(s):                     # decode forward to t\n                if f.time is not None and f.time &gt;= t:\n                    out.append(f.to_ndarray(format=\"rgb24\"))\n                    break\n    return out<\/code><\/pre>\n<p>Each loop iteration pays the <code>(G + 1) \/ 2<\/code> cost from above. When the targets are dense, decode straight through and keep every <em>k<\/em>-th frame.<\/p>\n<h3>NVIDIA DALI<\/h3>\n<p><code>fn.readers.video<\/code> reads files and decodes on the GPU, returning batches shaped <code>(N, F, H, W, C)<\/code>. <code>sequence_length<\/code> sets frames per sequence, <code>stride<\/code> the distance between frames, and <code>step<\/code> the interval between sequence starts (defaults to <code>sequence_length<\/code>).<\/p>\n<pre><code>from nvidia.dali import pipeline_def, fn\nfrom nvidia.dali.plugin.pytorch import DALIGenericIterator\n\n@pipeline_def(batch_size=8, num_threads=4, device_id=0)\ndef video_pipe(files):\n    return fn.readers.video(device=\"gpu\", filenames=files, sequence_length=16,\n                            stride=2, step=32, random_shuffle=True,\n                            initial_fill=256, name=\"reader\")\n\npipe = video_pipe(files=[\"\/data\/clips\/a.mp4\", \"\/data\/clips\/b.mp4\"])\npipe.build()\nloader = DALIGenericIterator(pipe, [\"frames\"], reader_name=\"reader\")<\/code><\/pre>\n<p>To decode from in-memory bytes (for example, from shards), use <code>fn.decoders.video<\/code>. Older DALI releases exposed it as <code>fn.experimental.decoders.video<\/code>. That name no longer appears in the current operator reference, though some examples on the operator's own page still use it. The decoder accepts <code>frames<\/code>, or <code>start_frame<\/code> with <code>sequence_length<\/code> or <code>end_frame<\/code> and <code>stride<\/code>, plus a <code>pad_mode<\/code>. Its docs say the mixed backend handles H.264, HEVC, AV1 and MPEG-4, and the CPU backend handles VP8, VP9 and MJPEG.<\/p>\n<h2>Pre-extract, decode on the fly, or re-encode?<\/h2>\n<table>\n<thead>\n<tr>\n<th>Strategy<\/th>\n<th>Decode cost at train time<\/th>\n<th>Storage<\/th>\n<th>Flexibility<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Pre-extracted frames (JPEG\/PNG or raw arrays)<\/td>\n<td>Image decode only<\/td>\n<td>Highest; raw 16 \u00d7 224 \u00d7 224 \u00d7 3 = 2,408,448 B per clip<\/td>\n<td>Sampling and resolution frozen at extraction<\/td>\n<\/tr>\n<tr>\n<td>On-the-fly from source files<\/td>\n<td>Highest; long GOPs inflate it<\/td>\n<td>Lowest<\/td>\n<td>Any sampling, any resolution<\/td>\n<\/tr>\n<tr>\n<td>Re-encoded clips, short GOP, training resolution<\/td>\n<td>Low; seeks are cheap<\/td>\n<td>Low (still compressed video)<\/td>\n<td>Resample per epoch; re-encode to change resolution<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Raw-frame storage scales linearly: 1,000,000 clips \u00d7 2,408,448 B is about 2.4 TB before compression. Pre-extraction makes sense for small, fixed-sampling datasets or evaluation sets. For large training sets, re-encoding is usually the middle ground:<\/p>\n<pre><code>ffmpeg -i in.mp4 -an -vf \"fps=8,scale=-2:256\" \\\n  -c:v libx264 -preset medium -crf 20 -pix_fmt yuv420p \\\n  -g 16 -keyint_min 16 -sc_threshold 0 \\\n  -movflags +faststart out.mp4<\/code><\/pre>\n<p>That produces a constant 8 fps, 256 px tall (width rounded to an even number), with a keyframe every 16 frames (2 s). The <a href=\"https:\/\/ffmpeg.org\/ffmpeg-codecs.html\">FFmpeg codec docs<\/a> define <code>-g<\/code> as the GOP size and <code>keyint_min<\/code> as the minimum IDR interval. <code>sc_threshold<\/code> maps to x264's scene-cut detection, and setting it to 0 stops extra keyframes at scene cuts. <code>-force_key_frames expr:gte(t,n_forced*2)<\/code> is a time-based alternative. Drop <code>-an<\/code> if you train on audio too. Smaller <code>G<\/code> makes seeks cheaper and files bigger. Pick it so that <code>(G + 1) \/ 2<\/code> is small next to your frame stride.<\/p>\n<h2>Sampling strategies<\/h2>\n<ul>\n<li><strong>Uniform N frames<\/strong> over the clip. Cost per sample is fixed and coverage is good for classification and captioning. With short GOPs, use per-frame seeks. With long GOPs, decode straight through.<\/li>\n<li><strong>Fixed fps<\/strong> (e.g. 2\u20138 fps). The temporal scale stays the same across clips, which matters for motion and for generative models. Normalize fps at re-encode time and the index math stays simple.<\/li>\n<li><strong>Random contiguous clip<\/strong> with dilation: TorchCodec's <code>clips_at_random_indices(decoder, num_clips=..., num_frames_per_clip=..., num_indices_between_frames=...)<\/code>, or DALI's <code>stride<\/code>\/<code>step<\/code>. A contiguous window costs one seek plus <code>span<\/code> frames.<\/li>\n<\/ul>\n<p>Whichever you choose, record the sampling parameters in your run config. They change what the model sees.<\/p>\n<h2>CPU and GPU throughput math<\/h2>\n<p>Size decode capacity with formulas and your own measured rates. Don't use someone else's benchmark.<\/p>\n<pre><code>demand (decoded frames\/s)\n  F = GPUs x samples_per_s_per_GPU x D          # D from the seek formula\n\nCPU decode\n  r_core = decoded frames\/s per core at your resolution and codec (measure)\n  cores  = F \/ r_core x 1.3                     # headroom for resize, collate, I\/O\n\nGPU decode (NVDEC)\n  r_gpu  = decoded frames\/s per GPU (measure; varies by GPU, codec, resolution)\n  GPU decode is enough if  F_per_GPU &lt;= r_gpu\n  PCIe saved per frame     = H x W x 3 bytes    # 6,220,800 B at 1080p RGB\n\nexample (assumed): 8 GPUs x 20 samples\/s x D = 68  -&gt; F = 10,880 frames\/s\n                   same with D = 300               -&gt; F = 48,000 frames\/s<\/code><\/pre>\n<p>Measure <code>r_core<\/code> on one of your clips with <code>ffmpeg -benchmark -threads 1 -i clip.mp4 -f null -<\/code> and divide frames by the reported time. The example shows why GOP length matters: the same training job needs about 4.4\u00d7 the decode capacity (300\/68) with long GOPs. Count DataLoader workers as well. Each worker that decodes on CPU needs a core, and <code>num_ffmpeg_threads=1<\/code> keeps parallel decoders from oversubscribing the cores.<\/p>\n<h2>Integrating with WebDataset shards<\/h2>\n<p>Store encoded clips as <code>.mp4<\/code> members in tar shards with a <code>.json<\/code> sidecar. Our <a href=\"https:\/\/globalcorpora.com\/blog\/storing-video-datasets-webdataset-parquet-shards\/\">WebDataset and Parquet storage guide<\/a> covers shard sizing and manifests. Shuffle the encoded bytes, then decode in the worker. TorchCodec accepts <code>bytes<\/code> directly, so there is no temp file:<\/p>\n<pre><code>import json\nimport webdataset as wds\nfrom torchcodec.decoders import VideoDecoder\nfrom torchcodec.samplers import clips_at_random_indices\nfrom torchcodec.transforms import Resize\n\nSHARDS = \"pipe:aws s3 cp --quiet s3:\/\/BUCKET\/clips\/clips-{000000..004095}.tar -\"\n\ndef decode(sample):\n    dec = VideoDecoder(sample[\"mp4\"], seek_mode=\"approximate\",\n                       transforms=[Resize(size=(224, 224))])\n    clip = clips_at_random_indices(dec, num_clips=1, num_frames_per_clip=16,\n                                   num_indices_between_frames=2)\n    return clip.data[0], json.loads(sample[\"json\"])[\"caption\"]\n\ndataset = (wds.WebDataset(SHARDS, resampled=True, nodesplitter=wds.split_by_node)\n           .shuffle(64)            # buffer holds encoded clips, not frames\n           .map(decode)\n           .with_epoch(10_000))\nloader = wds.WebLoader(dataset, batch_size=8, num_workers=8)<\/code><\/pre>\n<p>Filter out clips shorter than the sampled span (here 31 frames) when you build the shards, so the sampler never pads. For NVDEC decoding, keep DataLoader workers on CPU work: have them yield bytes and decode with <code>device=\"cuda\"<\/code> in the main process. Alternatively, use DALI's <code>fn.readers.webdataset(paths=..., ext=[\"mp4\"])<\/code> feeding <code>fn.decoders.video(..., device=\"mixed\")<\/code>. That reader takes local tar paths and optional index files from DALI's <code>wds2idx.py<\/code>. Without the index files it infers the index, which its docs warn \"will add considerable startup time for big datasets\".<\/p>\n<h2>Compliance<\/h2>\n<p>If your clips come from YouTube, note that YouTube's Terms of Service restrict automated access and downloading. Copyright and licensing still apply to re-encoded or frame-extracted derivatives, and many teams filter for Creative Commons content (see our <a href=\"https:\/\/globalcorpora.com\/blog\/creative-commons-youtube-videos-for-ai-training\/\">Creative Commons guide<\/a>). Faces and voices are personal data under regimes like GDPR. Keep clip-level IDs through re-encoding so you can honor takedown and opt-out requests, and get legal review for your jurisdiction and use case.<\/p>\n<h2>If you'd rather not run the collection side<\/h2>\n<p>Decoding is your training stack's job. Getting the source video is a separate one. Corpora's managed option collects, deduplicates and delivers YouTube video, audio, subtitles and metadata (JSONL\/Parquet, sha256 checksums, manifests) to S3, GCS, Azure Blob or private object storage, with a free sample batch. <a href=\"https:\/\/globalcorpora.com\/#contact\">Get in touch<\/a> if that helps.<\/p>\n<h2>FAQ<\/h2>\n<h3>What is the fastest video data loader for PyTorch?<\/h3>\n<p>There's no universal answer. It depends on codec, resolution, GOP length and how many CPU cores you have per GPU. TorchCodec (CPU or NVDEC) and DALI are the maintained options. Re-encoding to a short GOP at training resolution usually matters more than which library you pick.<\/p>\n<h3>Is torchvision.io.read_video deprecated?<\/h3>\n<p>It's gone. torchvision 0.26 removed <code>read_video<\/code>, <code>write_video<\/code>, <code>VideoReader<\/code> and <code>torchvision.io.video.*<\/code>, and points users to TorchCodec.<\/p>\n<h3>Is decord still maintained?<\/h3>\n<p>Its last PyPI release is 0.6.0 from June 2021, and the repository's last push was in July 2024. It isn't archived, but for new pipelines TorchCodec or PyAV is the safer choice.<\/p>\n<h3>Why is random frame access so slow in video?<\/h3>\n<p>Each seek restarts decoding at the previous keyframe, so you decode about <code>(G + 1) \/ 2<\/code> frames per random target. Shorten the GOP with <code>-g<\/code>, <code>-keyint_min<\/code> and <code>-sc_threshold 0<\/code>, or sample contiguous windows.<\/p>\n<h3>Should I decode video on the GPU?<\/h3>\n<p>Decode on the GPU when CPU decode is the measured bottleneck, especially at high resolution, and when NVDEC supports your codec. Check for silent CPU fallback, and keep GPU decoding out of forked DataLoader workers.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Speed up your video data loader: keyframe and GOP seek cost, TorchCodec vs PyAV vs DALI vs decord, short-GOP re-encoding, and CPU\/GPU decode math.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[122,121,120,119,26],"class_list":["post-43","post","type-post","status-publish","format-standard","hentry","category-guides","tag-data-loaders","tag-nvidia-dali","tag-torchcodec","tag-video-decoding","tag-webdataset"],"_links":{"self":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/43","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/comments?post=43"}],"version-history":[{"count":0,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/43\/revisions"}],"wp:attachment":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/media?parent=43"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/categories?post=43"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/tags?post=43"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}