{"id":29,"date":"2026-11-11T14:41:14","date_gmt":"2026-11-11T14:41:14","guid":{"rendered":"https:\/\/globalcorpora.com\/blog\/near-duplicate-video-detection-for-training-datasets\/"},"modified":"2026-11-11T14:41:14","modified_gmt":"2026-11-11T14:41:14","slug":"near-duplicate-video-detection-for-training-datasets","status":"publish","type":"post","link":"https:\/\/globalcorpora.com\/blog\/near-duplicate-video-detection-for-training-datasets\/","title":{"rendered":"Video Deduplication: Near-Duplicate Detection for Training Data"},"content":{"rendered":"<p>Web-scale video collections are full of copies: re-uploads, mirrored and cropped versions, compilations that stitch together other people's clips, and reaction videos with the original running in a corner. Exact duplicates are easy to remove. Near-duplicates decide how much of your training budget goes to the same footage seen ten times. This guide builds a layered video deduplication pipeline (exact hashes, perceptual frame hashes, audio fingerprints, embedding search with FAISS) and covers thresholds, clustering, which copy to keep, and cost at scale.<\/p>\n<h2>TL;DR<\/h2>\n<ul>\n<li><strong>Layer cheap before expensive:<\/strong> video ID and sha256 \u2192 perceptual hashes on sampled frames \u2192 audio fingerprints \u2192 embedding nearest-neighbor search \u2192 video-level verification.<\/li>\n<li><strong>Match at frame or segment level, decide at video or clip level.<\/strong> Compilations and reaction videos only share part of their content with the source.<\/li>\n<li><strong>Calibrate thresholds<\/strong> on labeled pairs before you delete anything.<\/li>\n<li><strong>Cluster with care:<\/strong> similarity edges can chain unrelated videos into one giant cluster.<\/li>\n<li><strong>Keep the best copy by explicit rules<\/strong> (license, original uploader, resolution) and record the cluster ID so takedowns propagate to every copy.<\/li>\n<li><strong>Search your evaluation sets too<\/strong>, with a looser threshold.<\/li>\n<\/ul>\n<h2>Why duplicates hurt<\/h2>\n<p>Duplicates do three kinds of damage:<\/p>\n<ul>\n<li><strong>Wasted compute and skewed weighting.<\/strong> A viral clip with 40 re-uploads is effectively upweighted 40x.<\/li>\n<li><strong>Memorization.<\/strong> In <a href=\"https:\/\/arxiv.org\/abs\/2301.13188\">Extracting Training Data from Diffusion Models<\/a>, Carlini et al. extracted near-copies of training images from Stable Diffusion and Imagen. They focused their search on duplicated training examples because, citing prior work, those are orders of magnitude more likely to be memorized. For text, <a href=\"https:\/\/arxiv.org\/abs\/2107.06499\">Lee et al.<\/a> report that deduplicated training data made models emit memorized text about ten times less often and reach the same or better accuracy in fewer steps.<\/li>\n<li><strong>Evaluation contamination.<\/strong> Lee et al. also found train-test overlap affecting over 4% of the validation sets of standard text datasets. Many video benchmarks come from YouTube too, so a re-upload of a benchmark clip silently inflates your scores.<\/li>\n<\/ul>\n<p>Removal also tends to be cheap in accuracy terms: <a href=\"https:\/\/arxiv.org\/abs\/2303.09540\">SemDeDup<\/a> reports removing 50% of a LAION subset via embedding-based semantic dedup with minimal performance loss. That is image-text data; measure on your own video set.<\/p>\n<h2>The duplicate taxonomy<\/h2>\n<p>Different copies need different detectors. No single method catches all of them.<\/p>\n<table>\n<thead>\n<tr>\n<th>Duplicate type<\/th>\n<th>What changes<\/th>\n<th>Catches it<\/th>\n<th>Misses it<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Same video listed twice<\/td>\n<td>Nothing<\/td>\n<td>Video ID<\/td>\n<td>\u2014<\/td>\n<\/tr>\n<tr>\n<td>Byte-identical file<\/td>\n<td>Nothing<\/td>\n<td>sha256<\/td>\n<td>\u2014<\/td>\n<\/tr>\n<tr>\n<td>Re-upload \/ re-encode<\/td>\n<td>Codec, bitrate, resolution, small trims<\/td>\n<td>pHash\/dHash on sampled frames, audio fingerprint<\/td>\n<td>sha256, video ID<\/td>\n<\/tr>\n<tr>\n<td>Mirrored copy<\/td>\n<td>Horizontal flip<\/td>\n<td>pHash of the flipped query, embeddings<\/td>\n<td>Plain pHash<\/td>\n<\/tr>\n<tr>\n<td>Cropped \/ letterboxed \/ watermarked<\/td>\n<td>Borders, overlays, aspect ratio<\/td>\n<td>Embeddings, crop-resistant hashing, copy-detection descriptors<\/td>\n<td>Plain pHash on large crops<\/td>\n<\/tr>\n<tr>\n<td>Compilation<\/td>\n<td>Segments of many sources concatenated<\/td>\n<td>Frame-level matching with per-segment coverage<\/td>\n<td>Whole-video embeddings<\/td>\n<\/tr>\n<tr>\n<td>Reaction video<\/td>\n<td>Source shrunk into a picture-in-picture, new audio on top<\/td>\n<td>Copy-detection descriptors, sometimes audio fingerprint<\/td>\n<td>pHash, whole-frame embeddings<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Layer 1: exact deduplication<\/h2>\n<p>Start with the free wins. Dedup source lists on the platform video ID before you download anything. Overlapping playlists, search queries and public datasets like Panda-70M and HD-VILA often reference the same YouTube IDs (see <a href=\"https:\/\/globalcorpora.com\/blog\/download-youtube-video-datasets-panda-70m-hd-vila-internvid\/\">downloading Panda-70M, HD-VILA and InternVid<\/a>). Every ID you drop here saves bandwidth, storage and all downstream compute.<\/p>\n<p>After download, sha256 each file and keep the digest in your manifest. It catches byte-identical copies and doubles as an integrity check, but misses the same video in two formats, let alone a re-encode.<\/p>\n<h2>Layer 2: perceptual hashes on sampled frames<\/h2>\n<p>A perceptual hash maps visually similar images to similar bit strings, so the Hamming distance between hashes approximates visual difference. The Python <a href=\"https:\/\/github.com\/JohannesBuchner\/imagehash\">imagehash<\/a> library implements average, perceptual (<code>phash<\/code>, DCT-based), difference (<code>dhash<\/code>), wavelet and crop-resistant hashing. With the default <code>hash_size=8<\/code>, <code>phash<\/code> and <code>dhash<\/code> produce 64-bit hashes, and subtracting two hashes returns the Hamming distance.<\/p>\n<p>Sample frames at a fixed rate rather than extracting codec keyframes. Different encodes of the same video place I-frames at different positions. Fixed-rate sampling keeps the frame timelines of two copies roughly aligned.<\/p>\n<pre><code>mkdir -p frames\/VIDEO_ID\nffmpeg -hide_banner -loglevel error -i VIDEO_ID.mp4 \\\n  -vf \"fps=1,scale=256:-2\" -q:v 3 frames\/VIDEO_ID\/%06d.jpg<\/code><\/pre>\n<p>Then hash every frame, index the hashes in a FAISS binary index (Hamming distance, <a href=\"https:\/\/github.com\/facebookresearch\/faiss\/wiki\/Binary-Indexes\">IndexBinaryFlat<\/a>), and query with both the original and the mirrored frame:<\/p>\n<pre><code>from collections import Counter, defaultdict\nfrom pathlib import Path\n\nimport faiss\nimport imagehash\nimport numpy as np\nfrom PIL import Image, ImageOps\n\nMAX_HAMMING = 8      # starting point for 64-bit pHash; calibrate on labeled pairs\nMIN_STD = 10.0       # skip near-uniform frames (black, white, solid title cards)\n\ndef bits(h):\n    return np.packbits(h.hash.flatten())          # 64 bits -&gt; 8 uint8\n\ncodes, mirrored, owners = [], [], []\nfor p in sorted(Path(\"frames\").glob(\"*\/*.jpg\")):\n    img = Image.open(p).convert(\"L\")\n    if np.asarray(img).std() &lt; MIN_STD:\n        continue\n    codes.append(bits(imagehash.phash(img)))\n    mirrored.append(bits(imagehash.phash(ImageOps.mirror(img))))\n    owners.append(p.parent.name)                  # folder name = video ID\n\ncodes = np.stack(codes)\nindex = faiss.IndexBinaryFlat(64)\nindex.add(codes)\n\nframes_per_video = Counter(owners)\nhits = defaultdict(set)                           # (a, b) -&gt; frames of a matched in b\nfor queries in (codes, np.stack(mirrored)):\n    D, I = index.search(queries, 10)\n    for qi in range(len(queries)):\n        a = owners[qi]\n        for dist, j in zip(D[qi], I[qi]):\n            if j &gt;= 0 and dist &lt;= MAX_HAMMING and owners[j] != a:\n                hits[(a, owners[j])].add(qi)\n\ncoverage = {pair: len(s) \/ frames_per_video[pair[0]] for pair, s in hits.items()}\nfor (a, b), c in sorted(coverage.items(), key=lambda kv: -kv[1])[:20]:\n    print(f\"{a} -&gt; {b}: {c:.0%} of {a}'s frames matched\")<\/code><\/pre>\n<p>Three details matter more than the hash choice:<\/p>\n<ul>\n<li><strong>Filter low-information frames.<\/strong> Black frames, fades and solid title cards hash almost identically across unrelated videos and generate false matches.<\/li>\n<li><strong>Coverage is asymmetric.<\/strong> If 90% of A's frames match B but only 5% of B's match A, A is likely a clip lifted from B, or B is a compilation containing A. Keep both directions.<\/li>\n<li><strong>pHash breaks under heavy crops and picture-in-picture.<\/strong> <code>crop_resistant_hash<\/code> helps with crops but is much slower. For reaction videos, use embeddings or a copy-detection model.<\/li>\n<\/ul>\n<p>Exhaustive binary search is popcount over 8 bytes per frame, so it is fast. At hundreds of millions of frames, switch to <code>IndexBinaryIVF<\/code> or <code>IndexBinaryHash<\/code>, documented on the same wiki page.<\/p>\n<h2>Layer 3: audio fingerprints<\/h2>\n<p>Re-uploads often keep the original audio even when the picture is cropped, flipped or overlaid. <a href=\"https:\/\/acoustid.org\/chromaprint\">Chromaprint<\/a>, the fingerprinting library behind AcoustID, ships a command-line tool, <code>fpcalc<\/code>. It decodes audio through FFmpeg, so it reads the audio track of a video file directly. According to its <a href=\"https:\/\/github.com\/acoustid\/chromaprint\/blob\/master\/src\/cmd\/fpcalc.cpp\">source<\/a>, <code>-length<\/code> defaults to 120 seconds, and a value of 0 removes the limit. <code>-raw<\/code> outputs the uncompressed fingerprint as 32-bit integers, and <code>-json<\/code> makes it machine-readable. The current release on the project page is 1.6.2.<\/p>\n<pre><code>fpcalc -raw -json -length 0 VIDEO_ID.mp4<\/code><\/pre>\n<p>To compare two fingerprints, slide one against the other and measure the fraction of differing bits at the best offset:<\/p>\n<pre><code>import json\nimport subprocess\n\nimport numpy as np\n\ndef raw_fp(path):\n    out = subprocess.run([\"fpcalc\", \"-raw\", \"-json\", \"-length\", \"0\", path],\n                         capture_output=True, text=True, check=True).stdout\n    return np.array(json.loads(out)[\"fingerprint\"], dtype=np.uint32)\n\ndef bit_error_rate(a, b, max_offset=300, min_overlap=100):\n    best = 1.0\n    for off in range(-max_offset, max_offset + 1):\n        x, y = a[max(off, 0):], b[max(-off, 0):]\n        n = min(len(x), len(y))\n        if n &lt; min_overlap:\n            continue\n        diff = np.unpackbits((x[:n] ^ y[:n]).view(np.uint8)).sum()\n        best = min(best, diff \/ (32 * n))\n    return best   # 0.0 = identical; independent random bits would sit near 0.5<\/code><\/pre>\n<p>Offsets are in fingerprint items, not seconds. This brute-force alignment verifies candidate pairs; it is not a search method. To find candidates at scale, put the 32-bit items in an inverted index and only align pairs that share many items. Chromaprint was built to identify music, so treat matches on speech-only or ambient audio with more suspicion, and skip near-silent tracks: silence matches silence.<\/p>\n<h2>Layer 4: embedding-based near-duplicate search<\/h2>\n<p>Embeddings catch what hashes miss: crops, letterboxing, color grading and overlays. The standard recipe is to embed sampled frames with a CLIP-family encoder, normalize, and search neighbors by cosine similarity. Carlini et al. found near-duplicates among 160 million training images the same way, comparing CLIP embeddings instead of pixels.<\/p>\n<p><a href=\"https:\/\/github.com\/mlfoundations\/open_clip\">OpenCLIP<\/a> loads both CLIP and <a href=\"https:\/\/arxiv.org\/abs\/2303.15343\">SigLIP<\/a> checkpoints (for example <code>ViT-SO400M-14-SigLIP-384<\/code>). FAISS turns inner product into cosine similarity once vectors are L2-normalized, as described in its <a href=\"https:\/\/github.com\/facebookresearch\/faiss\/wiki\/MetricType-and-distances\">metric notes<\/a>:<\/p>\n<pre><code>import faiss\nimport numpy as np\nimport open_clip\nimport torch\nfrom PIL import Image\n\ndevice = \"cuda\" if torch.cuda.is_available() else \"cpu\"\nmodel, _, preprocess = open_clip.create_model_and_transforms(\n    \"ViT-B-32\", pretrained=\"laion2b_s34b_b79k\")\nmodel = model.to(device).eval()\n\n@torch.no_grad()\ndef embed(paths, batch=256):\n    out = []\n    for i in range(0, len(paths), batch):\n        x = torch.stack([preprocess(Image.open(p).convert(\"RGB\"))\n                         for p in paths[i:i + batch]]).to(device)\n        out.append(model.encode_image(x).float().cpu().numpy())\n    return np.ascontiguousarray(np.concatenate(out), dtype=\"float32\")\n\nX = embed(frame_paths)              # frame_paths: list of sampled frame files\nfaiss.normalize_L2(X)\n\nindex = faiss.index_factory(X.shape[1], \"IVF4096,Flat\", faiss.METRIC_INNER_PRODUCT)\nindex.train(X)                      # use \"Flat\" instead for small sets\nindex.add(X)\nindex.nprobe = 16\nS, I = index.search(X, 20)          # S = cosine similarity, I = neighbor ids<\/code><\/pre>\n<p>Practical notes:<\/p>\n<ul>\n<li><strong>Search twice.<\/strong> Run a coarse pass on one pooled (mean) embedding per clip to find candidates, then verify at frame level, as in the pHash coverage logic above.<\/li>\n<li><strong>Semantic similarity is not duplication.<\/strong> Two news segments from the same studio, or two playthroughs of the same game level, embed very close together. Require temporal consistency (many frames matching at a stable time offset) before calling something a copy.<\/li>\n<li><strong>For reaction videos and heavy edits, use a copy-detection descriptor.<\/strong> Meta's <a href=\"https:\/\/arxiv.org\/abs\/2202.10261\">SSCD<\/a> is trained for image copy detection rather than semantics. The <a href=\"https:\/\/arxiv.org\/abs\/2306.09489\">2023 Video Similarity Challenge<\/a> paper provides a benchmark and baselines for detecting and temporally localizing copied segments between videos.<\/li>\n<\/ul>\n<h2>Thresholds: calibrate, then audit<\/h2>\n<p>Every threshold here (Hamming distance, bit error rate, cosine similarity, frame coverage) trades precision against recall. The values in the code above are starting points. To set them:<\/p>\n<ol>\n<li>Sample candidate pairs in bands around each threshold, for example cosine 0.85\u20130.90, 0.90\u20130.95 and 0.95+.<\/li>\n<li>Have a person label each pair: same footage, same footage with heavy edits, or different.<\/li>\n<li>Pick the threshold where precision is acceptable for deletion. Report it with a confidence interval, not a point estimate. Our post on <a href=\"https:\/\/globalcorpora.com\/blog\/measuring-curated-dataset-accuracy-audits-wilson-intervals\/\">dataset audits with Wilson intervals<\/a> covers the sample sizes.<\/li>\n<\/ol>\n<p>Use two thresholds: a strict one for deleting within your training set, and a looser one for flagging overlap with evaluation sets, where a miss costs more than a false alarm.<\/p>\n<h2>From pairs to clusters<\/h2>\n<p>Turn verified pairs (for example, coverage of 0.8 or more) into duplicate groups with union-find, also called disjoint-set, over the edges. Then watch for <strong>chaining<\/strong>. If A matches B and B matches C, all three land in one cluster even when A and C share nothing. Compilations act as bridges that can link dozens of unrelated sources. If one cluster has thousands of members, inspect it. Common fixes are to keep compilations from creating edges (handle them at segment level instead), to require mutual coverage, or to cluster first and dedup within clusters, which is the approach SemDeDup takes with k-means.<\/p>\n<h2>Choosing which copy to keep<\/h2>\n<p>Within each cluster, rank members with explicit, deterministic rules and keep the top one:<\/p>\n<ol>\n<li><strong>License and provenance:<\/strong> prefer copies with a clear license (see <a href=\"https:\/\/globalcorpora.com\/blog\/creative-commons-youtube-videos-for-ai-training\/\">Creative Commons videos for AI training<\/a>) and the original uploader's channel over re-uploaders.<\/li>\n<li><strong>Earliest upload date<\/strong> as a proxy for the original.<\/li>\n<li><strong>Highest resolution and bitrate<\/strong>, no letterboxing.<\/li>\n<li><strong>Fewest overlays:<\/strong> lower OCR text area, no burned-in watermark.<\/li>\n<li><strong>Tie-break on video ID<\/strong> so reruns produce the same answer.<\/li>\n<\/ol>\n<p>For compilations, drop the duplicated segments and keep any unique ones, which requires the temporal localization from the frame-level step. Store <code>dup_cluster_id<\/code>, <code>dup_role<\/code> (kept or dropped) and the matched segments as columns, alongside the other curation scores described in <a href=\"https:\/\/globalcorpora.com\/blog\/video-data-curation-filters-for-generative-models\/\">video data curation filters<\/a>. Never delete the evidence. Thresholds will change.<\/p>\n<h2>What it costs at scale<\/h2>\n<p>The arithmetic is dominated by how many vectors you store. Take an example corpus of 1,000,000 videos averaging 8 minutes, sampled at 1 frame per second:<\/p>\n<ul>\n<li>Frames: 1,000,000 \u00d7 480 s \u00d7 1 fps = <strong>480 million<\/strong>.<\/li>\n<li>64-bit pHash: 480M \u00d7 8 bytes = <strong>3.84 GB<\/strong>. Fits in RAM on one machine.<\/li>\n<li>512-d float32 embeddings (ViT-B-32): 480M \u00d7 512 \u00d7 4 bytes = <strong>~983 GB<\/strong>, which is the <code>4*d<\/code> bytes per vector listed for flat indexes in the <a href=\"https:\/\/github.com\/facebookresearch\/faiss\/wiki\/Faiss-indexes\">FAISS index overview<\/a>.<\/li>\n<li>One embedding per 5 seconds instead: 96M vectors \u00d7 2,048 bytes = <strong>~197 GB<\/strong> flat. With <code>IndexIVFPQ<\/code> at 64 bytes of code plus 8 bytes of ID, that becomes 96M \u00d7 72 bytes = <strong>~6.9 GB<\/strong>, at some loss of accuracy. Rerank the candidates with exact vectors.<\/li>\n<li>All-pairs comparison of 96M vectors: 96M\u00b2 \/ 2 \u2248 <strong>4.6 quadrillion<\/strong> pairs, which is why approximate nearest-neighbor search is required.<\/li>\n<\/ul>\n<p>Encoder throughput depends on model, resolution, batch size and decoding, so benchmark it on your hardware. Video decoding is often the bottleneck, so reuse the frames you already extract for shot detection and quality filters. And dedup IDs before download: every duplicate you skip is bandwidth you don't pay for (see <a href=\"https:\/\/globalcorpora.com\/blog\/bandwidth-for-large-scale-video-downloads\/\">bandwidth for large-scale video downloads<\/a>).<\/p>\n<h2>Compliance<\/h2>\n<p>YouTube's Terms of Service restrict automated access and downloading. Copyright and licensing apply to every copy, and a re-upload's license may not reflect the original creator's. Faces and voices can be personal data under GDPR. Use your duplicate clusters to honor takedown and opt-out requests across every copy and derived clip, not just the one ID named in the request. Get legal review for your jurisdiction and use case.<\/p>\n<h2>If you'd rather not run this yourself<\/h2>\n<p>Corpora's fully managed option collects YouTube video, audio, subtitles and metadata and delivers them deduplicated, with sha256 checksums and manifests, to S3, GCS, Azure Blob or private object storage, with a free sample batch to run your own acceptance tests. For the questions to ask any data vendor about dedup and contamination, see the <a href=\"https:\/\/globalcorpora.com\/blog\/buying-video-training-data-checklist\/\">video training data buying checklist<\/a>, or <a href=\"https:\/\/globalcorpora.com\/#contact\">contact us<\/a>.<\/p>\n<h2>FAQ<\/h2>\n<h3>What is the difference between exact and near-duplicate video deduplication?<\/h3>\n<p>Exact deduplication matches identical identifiers or bytes (video ID, sha256). Near-duplicate detection matches content that looks or sounds the same after re-encoding, cropping, flipping or editing. It uses perceptual hashes, audio fingerprints or embeddings.<\/p>\n<h3>Is pHash or dHash better for video frames?<\/h3>\n<p>Both tolerate re-encoding and resizing, and both break under heavy crops and picture-in-picture. In imagehash, <code>phash<\/code> thresholds low-frequency DCT coefficients of a downscaled grayscale frame, while <code>dhash<\/code> compares adjacent pixels, which is simpler and cheaper. Benchmark both on labeled pairs from your own data.<\/p>\n<h3>What cosine similarity threshold should I use for CLIP-based deduplication?<\/h3>\n<p>There is no universal value. It depends on the encoder, the frame sampling and whether you compare frames or pooled clips. Label pairs in similarity bands, pick the band where precision is acceptable, and require temporal consistency across several frames before treating a pair as a copy.<\/p>\n<h3>How do I check my training set for benchmark contamination?<\/h3>\n<p>Index your training frames, then query with frames from every evaluation video using a looser threshold than you use for training dedup. Also check exact IDs, since many benchmarks are built from YouTube. Record matches as a column so you can exclude them and report the overlap.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Video deduplication for training sets: video IDs and sha256, pHash frames, Chromaprint audio, CLIP\/SigLIP embeddings with FAISS, thresholds and costs.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[73,72,70,71,48,69],"class_list":["post-29","post","type-post","status-publish","format-standard","hentry","category-datasets","tag-data-contamination","tag-faiss","tag-near-duplicate-detection","tag-perceptual-hashing","tag-training-data-quality","tag-video-deduplication"],"_links":{"self":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/29","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=29"}],"version-history":[{"count":0,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/29\/revisions"}],"wp:attachment":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/media?parent=29"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/categories?post=29"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/tags?post=29"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}