{"id":30,"date":"2026-11-11T14:41:39","date_gmt":"2026-11-11T14:41:39","guid":{"rendered":"https:\/\/globalcorpora.com\/blog\/split-videos-into-clips-pyscenedetect-training-data\/"},"modified":"2026-11-11T14:41:39","modified_gmt":"2026-11-11T14:41:39","slug":"split-videos-into-clips-pyscenedetect-training-data","status":"publish","type":"post","link":"https:\/\/globalcorpora.com\/blog\/split-videos-into-clips-pyscenedetect-training-data\/","title":{"rendered":"Split Video into Clips with PySceneDetect for Training Data"},"content":{"rendered":"<p>Long videos are not training examples. Before you caption, filter or train, you have to split video into clips that each show one continuous shot and fit the window your model samples. This guide covers PySceneDetect's detectors (CLI and Python), TransNetV2 as a learned alternative, how Panda-70M split and re-stitched clips, frame-accurate cutting with ffmpeg, and what to record per clip.<\/p>\n<h2>TL;DR<\/h2>\n<ul>\n<li><strong>Detect, then cut.<\/strong> Run shot detection once, store boundaries as timestamps, and treat file cutting as a separate, repeatable step.<\/li>\n<li><strong>Start with <code>AdaptiveDetector<\/code><\/strong>, add <code>ThresholdDetector<\/code> for fades, and tune thresholds from a stats file.<\/li>\n<li><strong>Raw shot boundaries over-split.<\/strong> Panda-70M stitched similar neighbors back together and roughly doubled average clip length.<\/li>\n<li><strong>Re-encode for frame-accurate cuts.<\/strong> Stream copy (<code>-c copy<\/code>) can only cut at keyframes.<\/li>\n<li><strong>Derive min\/max length from your model's sampling window<\/strong>, drop short clips, split long shots, trim edges, and record why every boundary exists.<\/li>\n<\/ul>\n<h2>Why splitting comes first<\/h2>\n<p>Almost every downstream signal assumes a clip shows one continuous shot. A motion score on a clip containing a hard cut measures the cut; a caption describing two unrelated scenes teaches the model to blend them. The Stable Video Diffusion paper (<a href=\"https:\/\/arxiv.org\/abs\/2311.15127\">arXiv 2311.15127<\/a>) ran PySceneDetect in a cascaded manner at three frame rates to keep cuts and fades out of generated videos, and reports roughly 4x more clips after cut detection, meaning many source clips contained cuts that metadata didn't reveal.<\/p>\n<p>Splitting also defines your unit of data: every later filter, caption and dedup decision is keyed by clip ID. The broader pipeline is in <a href=\"https:\/\/globalcorpora.com\/blog\/build-youtube-video-dataset-for-multimodal-training\/\">building a YouTube video dataset for multimodal training<\/a>, and the filters that run after splitting are in <a href=\"https:\/\/globalcorpora.com\/blog\/video-data-curation-filters-for-generative-models\/\">video data curation filters for generative models<\/a>. This article goes deep on the splitting step.<\/p>\n<h2>PySceneDetect: the detectors that matter<\/h2>\n<p><a href=\"https:\/\/github.com\/Breakthrough\/PySceneDetect\">PySceneDetect<\/a> (BSD-3-Clause, v0.7.3 at the time of writing) is the tool both SVD and Panda-70M used. Install with <code>pip install scenedetect --upgrade<\/code> and put <code>ffmpeg<\/code> (or <code>mkvmerge<\/code>) on your PATH for splitting. Version 0.7 reworked timestamps to support variable-frame-rate video and moved some imports; if you have v0.6 code, read the <a href=\"https:\/\/www.scenedetect.com\/docs\/latest\/api\/migration_guide.html\">migration guide<\/a>. The docs recommend pinning <code>scenedetect~=0.7<\/code>.<\/p>\n<p>The three detectors you'll use most (defaults from the <a href=\"https:\/\/www.scenedetect.com\/docs\/latest\/api\/detectors.html\">detector reference<\/a>):<\/p>\n<table>\n<thead>\n<tr>\n<th>Detector (CLI command)<\/th>\n<th>What it measures<\/th>\n<th>Default threshold<\/th>\n<th>Use it for<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>ContentDetector<\/code> (<code>detect-content<\/code>)<\/td>\n<td>Weighted frame-to-frame change in hue, saturation and luma (edges optional), 0\u2013255<\/td>\n<td><code>27.0<\/code><\/td>\n<td>Hard cuts, steady cameras<\/td>\n<\/tr>\n<tr>\n<td><code>AdaptiveDetector<\/code> (<code>detect-adaptive<\/code>)<\/td>\n<td>Same score, compared to a rolling average of neighboring frames<\/td>\n<td><code>3.0<\/code> ratio, <code>min_content_val=15.0<\/code><\/td>\n<td>Hard cuts with fast camera motion; the CLI default<\/td>\n<\/tr>\n<tr>\n<td><code>ThresholdDetector<\/code> (<code>detect-threshold<\/code>)<\/td>\n<td>Average pixel intensity crossing a fixed level<\/td>\n<td><code>12.0<\/code><\/td>\n<td>Fades to and from black<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>One trap: <code>min_scene_len<\/code> defaults to <strong>15 frames in Python<\/strong> but <strong>0.6 s on the CLI<\/strong>, and <code>ThresholdDetector<\/code>'s <code>add_final_scene<\/code> and <code>min_out_length<\/code> also differ. If you prototype on the CLI and productionize in Python, set them explicitly. None of these detectors is designed for cross-dissolves or wipes, where change is spread over many frames; that gap is why learned detectors and Panda-70M's extra heuristics exist.<\/p>\n<h3>The CLI: fastest way to look at your data<\/h3>\n<p>Global options go before commands. This detects cuts, drops (rather than merges) scenes shorter than 2 seconds, writes a CSV scene list and splits with ffmpeg:<\/p>\n<pre><code>scenedetect -i input.mp4 -o clips\/ -m 2s --drop-short-scenes \\\n  detect-adaptive list-scenes split-video<\/code><\/pre>\n<p>To tune a threshold, write per-frame metrics first. <code>-s<\/code> saves a stats CSV with columns such as <code>content_val<\/code>; <code>list-scenes -n<\/code> prints scenes without writing a file:<\/p>\n<pre><code>scenedetect -i input.mp4 -s input.stats.csv detect-content list-scenes -n<\/code><\/pre>\n<p>Plot <code>content_val<\/code> for a few videos per source category. True cuts are isolated spikes; a threshold inside the noise floor of handheld footage over-splits, one above low-contrast cuts misses them. Thresholds that work for studio interviews rarely work for drone footage, so keep them per category.<\/p>\n<p><code>split-video<\/code> re-encodes by default with <code>-map 0:v:0 -map 0:a? -map 0:s? -c:v libx264 -preset veryfast -crf 22 -c:a aac<\/code>. Options include <code>-hq<\/code> (CRF 17, preset slow), <code>-crf<\/code>, <code>-p<\/code>, <code>-a<\/code> for custom ffmpeg arguments, <code>-f<\/code> for filenames, and <code>-c\/--copy<\/code>, which the <a href=\"https:\/\/www.scenedetect.com\/docs\/latest\/cli\/config_file.html\">config reference<\/a> calls \"significantly faster, but can result in inaccurate splits due to keyframe positioning\".<\/p>\n<h3>The Python API: what you'll run at scale<\/h3>\n<p>In a pipeline you want boundaries as data. <code>detect(path, AdaptiveDetector())<\/code> returns <code>(start, end)<\/code> <code>FrameTimecode<\/code> pairs. To run a cut detector and a fade detector in one decoding pass, register both on a <code>SceneManager<\/code>:<\/p>\n<pre><code>from scenedetect import open_video, SceneManager, AdaptiveDetector, ThresholdDetector\n\nvideo = open_video(\"input.mp4\")\nsm = SceneManager()\nsm.add_detector(AdaptiveDetector(min_scene_len=\"0.6s\"))\nsm.add_detector(ThresholdDetector(threshold=12.0, min_scene_len=\"0.6s\"))\nsm.detect_scenes(video, show_progress=True)\n\nfor start, end in sm.get_scene_list(start_in_scene=True):\n    print(start.get_timecode(), end.get_timecode(), end.seconds - start.seconds)<\/code><\/pre>\n<p><code>start_in_scene=True<\/code> makes a video with no cuts return one scene instead of an empty list. In v0.7, <code>frame_num<\/code>, <code>seconds<\/code> and <code>frame_rate<\/code> are properties, and <code>video.frame_rate<\/code> is an exact <code>Fraction<\/code> such as <code>30000\/1001<\/code>. Decoding is usually the bottleneck; frames are downscaled automatically, and the docs advise against <code>frame_skip<\/code> except for very high-frame-rate video.<\/p>\n<h2>TransNetV2: a learned shot boundary detector<\/h2>\n<p><a href=\"https:\/\/github.com\/soCzech\/TransNetV2\">TransNetV2<\/a> (<a href=\"https:\/\/arxiv.org\/abs\/2008.04838\">arXiv 2008.04838<\/a>) is a neural network built for shot transition detection, including gradual transitions. In the authors' re-evaluation it scores F1 77.9 on ClipShots, 96.2 on BBC Planet Earth and 93.9 on RAI. Those are their benchmarks; validate on a labeled sample of your own sources before switching.<\/p>\n<p>The reference inference code pins <code>tensorflow==2.1<\/code>, old enough that you'll likely want the provided Docker image or the inference-only PyTorch port in <code>inference-pytorch\/<\/code>, which converts the TF weights. Weights are stored with git-lfs. Usage:<\/p>\n<pre><code>from transnetv2 import TransNetV2\n\nmodel = TransNetV2()\nframes, single_frame_pred, all_frame_pred = model.predict_video(\"input.mp4\")\nscenes = model.predictions_to_scenes(single_frame_pred)  # threshold defaults to 0.5\n# scenes: array of [start_frame, end_frame], zero-indexed, both inclusive<\/code><\/pre>\n<p>The model sees frames resized to 48x27 via ffmpeg, so decoding dominates and a GPU helps. Output is frame indices, so convert with the source frame rate and take care with variable-frame-rate files. Its advantage over thresholded detectors is a per-frame transition probability: store the peak near each boundary as a confidence score and you can re-threshold later without re-running the model. A common compromise is PySceneDetect on everything and TransNetV2 on the subset that later filters flag as suspicious.<\/p>\n<h2>How Panda-70M split and stitched<\/h2>\n<p><a href=\"https:\/\/arxiv.org\/abs\/2402.19479\">Panda-70M<\/a> split 3.8M long videos from HD-VILA-100M into 70.8M clips averaging 8.5 seconds. Its <a href=\"https:\/\/github.com\/snap-research\/Panda-70M\/tree\/main\/splitting\">splitting code<\/a> is public and encodes several practical lessons:<\/p>\n<ol>\n<li><strong>Shot detection:<\/strong> <code>ContentDetector<\/code> with <code>threshold=25<\/code>, <code>min_scene_len=15<\/code> frames and <code>start_in_scene=True<\/code>.<\/li>\n<li><strong>Forced cuts:<\/strong> to handle undetected fades and unedited footage, it \"recursively cut[s] the first 5 seconds as a new clip if the video clip is longer than 7 seconds\".<\/li>\n<li><strong>Stitching:<\/strong> ImageBind embeddings of frames near each piece's start and end; adjacent pieces with close embeddings are merged. Pieces whose own start and end differ sharply (likely a transition inside) and near-static events are dropped.<\/li>\n<li><strong>Length and trimming:<\/strong> the README says Panda-70M itself was built with a 2.5 s minimum, a 60 s maximum and 10% trimmed from both ends; the repo's default line uses different values.<\/li>\n<li><strong>Cutting:<\/strong> ffmpeg with <code>-ss<\/code> before <code>-i<\/code> and <code>-t<\/code>, re-encoded rather than stream-copied.<\/li>\n<\/ol>\n<p>On 1K long videos, the paper reports plain PySceneDetect splitting gave a 4.1 s average clip with max running LPIPS (the largest perceptual jump inside a clip) of 0.247, while its splitting gave 7.9 s at 0.256: nearly double the length for a small loss in consistency. To download Panda-70M itself, see <a href=\"https:\/\/globalcorpora.com\/blog\/download-youtube-video-datasets-panda-70m-hd-vila-internvid\/\">downloading Panda-70M, HD-VILA and InternVid<\/a>.<\/p>\n<h2>Cutting with ffmpeg: keyframes, stream copy and re-encoding<\/h2>\n<p>Compressed video stores full pictures only at keyframes; other frames are deltas. The <a href=\"https:\/\/trac.ffmpeg.org\/wiki\/Seeking\">FFmpeg seeking wiki<\/a> spells out the consequences:<\/p>\n<ul>\n<li><strong>Re-encoding is frame-accurate.<\/strong> Since FFmpeg 2.1, <code>-ss<\/code> before <code>-i<\/code> is both fast and frame-accurate when transcoding.<\/li>\n<li><strong>Stream copy is not.<\/strong> With <code>-c copy<\/code> ffmpeg may only split on keyframes. The wiki's example: requested 157 s, next keyframe at 159 s, so the output starts with about 2 s of audio and no video. In training data that means lead-ins from the previous shot or frozen frames.<\/li>\n<li><strong>Keyframes can be far apart.<\/strong> libx264's default GOP of 250 is one keyframe every 10 s at 25 fps. Web uploads vary, so measure.<\/li>\n<\/ul>\n<p>To see where keyframes are, list video packets; keyframes have <code>K<\/code> in the flags field:<\/p>\n<pre><code>ffprobe -v error -select_streams v:0 \\\n  -show_entries packet=pts_time,flags -of csv=p=0 input.mp4<\/code><\/pre>\n<p>Rule of thumb: re-encode the clips you train on, at a low CRF so compression artifacts don't become something the model learns. Stream copy is acceptable only if your data loader decodes and trims to stored boundaries anyway.<\/p>\n<h2>Clip length targets and short-clip filtering<\/h2>\n<p>Pick lengths from your model, not the detector. If it samples <em>N<\/em> frames at <em>F<\/em> fps, a clip shorter than <em>N<\/em>\/<em>F<\/em> seconds can't fill a window without looping or padding: 64 frames at 8 fps needs 64 \/ 8 = 8 s. Published reference points:<\/p>\n<table>\n<thead>\n<tr>\n<th>Dataset<\/th>\n<th>Average clip length<\/th>\n<th>Source<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Panda-70M<\/td>\n<td>8.5 s<\/td>\n<td><a href=\"https:\/\/arxiv.org\/abs\/2402.19479\">Panda-70M paper<\/a>, Table 1<\/td>\n<\/tr>\n<tr>\n<td>SVD's LVD (before filtering)<\/td>\n<td>11.58 s<\/td>\n<td><a href=\"https:\/\/arxiv.org\/abs\/2311.15127\">SVD paper<\/a>, Table 1<\/td>\n<\/tr>\n<tr>\n<td>HD-VILA-100M (subtitle-aligned)<\/td>\n<td>13.4 s<\/td>\n<td>Panda-70M paper, Table 1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<ul>\n<li><strong>Drop too-short clips.<\/strong> Don't merge them into neighbors without a stitching signal; merging across a cut reintroduces the problem.<\/li>\n<li><strong>Split too-long shots<\/strong> into windows at your maximum, and mark those boundaries as forced, not detected.<\/li>\n<li><strong>Trim the edges.<\/strong> Boundaries can be a frame off and fades bleed into neighbors; dropping a few frames per side is cheap insurance.<\/li>\n<\/ul>\n<h2>A complete pipeline: detect, plan, cut, record<\/h2>\n<p>This script detects boundaries, applies the length rules, cuts frame-accurately and writes one JSONL row per clip. The numbers are starting points, not recommendations for your data.<\/p>\n<pre><code>import hashlib, json, subprocess\nfrom importlib.metadata import version\nfrom pathlib import Path\nfrom scenedetect import open_video, SceneManager, AdaptiveDetector, ThresholdDetector\n\nSRC = Path(\"raw\/abc123XYZ_-.mp4\")\nOUT = Path(\"clips\"); OUT.mkdir(exist_ok=True)\nMIN_LEN, MAX_LEN, EDGE_TRIM = 2.0, 20.0, 0.1   # seconds\n\nvideo = open_video(str(SRC))\nsm = SceneManager()\nsm.add_detector(AdaptiveDetector(min_scene_len=\"0.6s\"))\nsm.add_detector(ThresholdDetector(threshold=12.0, min_scene_len=\"0.6s\"))\nsm.detect_scenes(video)\nscenes = sm.get_scene_list(start_in_scene=True)\n\ndef plan(shot_start, shot_end):\n    s, e = shot_start + EDGE_TRIM, shot_end - EDGE_TRIM\n    reason = \"forced_max_len\" if (e - s) &gt; MAX_LEN else \"shot\"\n    t = s\n    while e - t &gt;= MIN_LEN:\n        seg_end = min(t + MAX_LEN, e)\n        yield t, seg_end, reason\n        t = seg_end\n\nrows = []\nfor shot_idx, (start, end) in enumerate(scenes):\n    for s, e, reason in plan(start.seconds, end.seconds):\n        clip_id = f\"{SRC.stem}_{len(rows):05d}\"\n        out = OUT \/ f\"{clip_id}.mp4\"\n        subprocess.run([\n            \"ffmpeg\", \"-hide_banner\", \"-loglevel\", \"error\", \"-y\",\n            \"-ss\", f\"{s:.3f}\", \"-i\", str(SRC), \"-t\", f\"{e - s:.3f}\",\n            \"-map\", \"0:v:0\", \"-map\", \"0:a?\",\n            \"-c:v\", \"libx264\", \"-preset\", \"veryfast\", \"-crf\", \"18\",\n            \"-c:a\", \"aac\", str(out)], check=True)\n        dur = subprocess.run(\n            [\"ffprobe\", \"-v\", \"error\", \"-show_entries\", \"format=duration\",\n             \"-of\", \"csv=p=0\", str(out)],\n            capture_output=True, text=True, check=True).stdout.strip()\n        rows.append({\n            \"clip_id\": clip_id, \"source_video_id\": SRC.stem, \"shot_index\": shot_idx,\n            \"start_s\": round(s, 3), \"end_s\": round(e, 3),\n            \"shot_start_frame\": start.frame_num, \"shot_end_frame\": end.frame_num,\n            \"source_fps\": str(video.frame_rate), \"boundary_reason\": reason,\n            \"detector\": \"adaptive(3.0)+threshold(12.0)\",\n            \"scenedetect_version\": version(\"scenedetect\"),\n            \"encode\": \"libx264 veryfast crf18, aac\",\n            \"probed_duration_s\": float(dur),\n            \"sha256\": hashlib.sha256(out.read_bytes()).hexdigest(),\n        })\n\nwith open(OUT \/ f\"{SRC.stem}.clips.jsonl\", \"w\", encoding=\"utf-8\") as f:\n    for r in rows:\n        f.write(json.dumps(r) + \"\\n\")<\/code><\/pre>\n<p>Two production checks: compare <code>probed_duration_s<\/code> to <code>end_s - start_s<\/code> (a large gap means a decode problem), and inspect the first and last frames of a random sample. <a href=\"https:\/\/globalcorpora.com\/blog\/measuring-curated-dataset-accuracy-audits-wilson-intervals\/\">Measuring dataset accuracy with audits and Wilson intervals<\/a> shows how to size that sample and report a boundary error rate.<\/p>\n<h2>Metadata to record per clip<\/h2>\n<p>Splitting owns provenance; later stages add scores to the same row, as in the <a href=\"https:\/\/globalcorpora.com\/blog\/video-data-curation-filters-for-generative-models\/\">curation filters guide<\/a>. At minimum:<\/p>\n<ul>\n<li><strong>Provenance:<\/strong> clip ID, source video ID, source checksum, collection date, license at collection time.<\/li>\n<li><strong>Boundaries:<\/strong> start\/end in seconds and source frames, exact source frame rate, whether the source is variable frame rate.<\/li>\n<li><strong>Boundary reason:<\/strong> detected cut, fade, forced split or stitched, plus a confidence if your detector provides one.<\/li>\n<li><strong>Reproducibility:<\/strong> detector, thresholds, library version, encode settings, pipeline version.<\/li>\n<li><strong>Output facts:<\/strong> probed duration, resolution, audio present, sha256.<\/li>\n<\/ul>\n<p>Keep boundaries even for clips you drop. Changing a threshold should be a query over stored rows, not a re-run of detection over millions of videos.<\/p>\n<h2>Compliance<\/h2>\n<p>Splitting turns each source into many derived files, so provenance matters for compliance too. YouTube's Terms of Service restrict automated access and downloading; copyright and licensing apply to every clip (filtering for <a href=\"https:\/\/globalcorpora.com\/blog\/creative-commons-youtube-videos-for-ai-training\/\">Creative Commons videos<\/a> is one option); faces and voices can be personal data under GDPR and similar laws; and takedown or opt-out requests must reach every derived clip, which requires each clip to carry its source ID. Get legal review for your jurisdiction and use case.<\/p>\n<h2>If you'd rather not run this yourself<\/h2>\n<p>Corpora collects YouTube video, audio, subtitles and structured metadata and delivers deduplicated datasets as JSONL\/Parquet with sha256 checksums and manifests to S3, GCS, Azure Blob or private object storage, with a free sample batch to check quality first. See <a href=\"https:\/\/globalcorpora.com\/#pricing\">pricing<\/a> or <a href=\"https:\/\/globalcorpora.com\/#contact\">get in touch<\/a>.<\/p>\n<h2>FAQ<\/h2>\n<h3>How do I split a video into clips automatically by scene?<\/h3>\n<p>Install PySceneDetect and ffmpeg, then run <code>scenedetect -i input.mp4 detect-adaptive split-video<\/code>. For training data, add <code>-m 2s --drop-short-scenes<\/code> and keep the <code>list-scenes<\/code> CSV as metadata.<\/p>\n<h3>Which PySceneDetect detector should I use?<\/h3>\n<p><code>AdaptiveDetector<\/code> is the CLI default and copes with camera motion better than <code>ContentDetector<\/code>. Add <code>ThresholdDetector<\/code> if sources fade to black, and tune thresholds per source category with <code>-s stats.csv<\/code>.<\/p>\n<h3>Why do my ffmpeg clips start early or show black frames?<\/h3>\n<p>You are probably stream-copying (<code>-c copy<\/code>), which cuts at keyframes. Re-encode, with <code>-ss<\/code> before <code>-i<\/code>, for frame-accurate cuts.<\/p>\n<h3>Is TransNetV2 better than PySceneDetect?<\/h3>\n<p>It is a learned model that targets gradual transitions as well as hard cuts and outputs per-frame probabilities, but it needs a GPU at scale and its reference code pins an old TensorFlow. Compare both on a labeled sample of your own videos.<\/p>\n<h3>How long should training clips be?<\/h3>\n<p>At least your model's sampling window (frames divided by sampling fps), with a maximum so long shots don't dominate. Panda-70M averages 8.5 s, built with a 2.5 s minimum and 60 s maximum.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Split video into clips for training data: PySceneDetect detectors, TransNetV2, Panda-70M stitching, frame-accurate ffmpeg cuts, length rules, clip metadata.<\/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":[36,18,74,75,76,6],"class_list":["post-30","post","type-post","status-publish","format-standard","hentry","category-guides","tag-ffmpeg","tag-panda-70m","tag-pyscenedetect","tag-shot-detection","tag-transnetv2","tag-video-datasets"],"_links":{"self":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/30","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=30"}],"version-history":[{"count":0,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/30\/revisions"}],"wp:attachment":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/media?parent=30"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/categories?post=30"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/tags?post=30"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}