{"id":33,"date":"2026-11-12T17:00:52","date_gmt":"2026-11-12T17:00:52","guid":{"rendered":"https:\/\/globalcorpora.com\/blog\/common-crawl-llm-pretraining-data-pipeline\/"},"modified":"2026-11-12T17:00:52","modified_gmt":"2026-11-12T17:00:52","slug":"common-crawl-llm-pretraining-data-pipeline","status":"publish","type":"post","link":"https:\/\/globalcorpora.com\/blog\/common-crawl-llm-pretraining-data-pipeline\/","title":{"rendered":"Common Crawl to LLM Pretraining Data: WARC-to-Text Pipeline"},"content":{"rendered":"<p>Common Crawl is the default starting point for open LLM pretraining corpora, but the raw archive is mostly navigation menus, spam, duplicates and pages in languages you don't want. This guide walks through the pipeline that recent open datasets such as FineWeb use to turn Common Crawl into training text: which file format to read, how to extract text, language ID, heuristic and model-based quality filters, deduplication and PII. It uses Hugging Face's datatrove library as the reference implementation and cites published numbers, not guesses.<\/p>\n<h2>TL;DR<\/h2>\n<ul>\n<li><strong>Read WARC, not WET, if quality matters.<\/strong> FineWeb's ablations showed that text extracted from WARC with trafilatura trained better models than Common Crawl's WET text, which keeps too much boilerplate.<\/li>\n<li><strong>Order the cheap steps first:<\/strong> URL blocklist, then text extraction, language ID, heuristic filters (Gopher, C4, FineWeb rules), MinHash dedup, PII scrubbing, and an optional model-based quality classifier.<\/li>\n<li><strong>Language ID:<\/strong> FineWeb used fastText <code>lid.176<\/code> with English score \u2265 0.65. FineWeb2 switched to GlotLID for 1,000+ languages.<\/li>\n<li><strong>Dedup per snapshot, not globally.<\/strong> FineWeb found that global MinHash across 96 snapshots hurt quality. Per-snapshot dedup matched RefinedWeb.<\/li>\n<li><strong>Start from <a href=\"https:\/\/github.com\/huggingface\/datatrove\/blob\/main\/examples\/fineweb.py\">datatrove's fineweb.py<\/a><\/strong>, then change the parts you disagree with.<\/li>\n<\/ul>\n<h2>WARC vs WAT vs WET: what Common Crawl actually ships<\/h2>\n<p>Each monthly Common Crawl snapshot (named like <code>CC-MAIN-2026-43<\/code>) comes in three main formats, described on the <a href=\"https:\/\/commoncrawl.org\/get-started\">Get Started page<\/a>:<\/p>\n<table>\n<thead>\n<tr>\n<th>Format<\/th>\n<th>Contents<\/th>\n<th>CC-MAIN-2026-43 size (compressed)<\/th>\n<th>Use it for<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>WARC<\/td>\n<td>Raw HTTP request\/response records, including full HTML and headers<\/td>\n<td>86.19 TiB, 100,000 files<\/td>\n<td>Your own text extraction (recommended)<\/td>\n<\/tr>\n<tr>\n<td>WAT<\/td>\n<td>JSON metadata computed from WARC: headers, title, meta tags, outlinks<\/td>\n<td>14.06 TiB, 100,000 files<\/td>\n<td>Link graphs, URL discovery, image-text candidates<\/td>\n<\/tr>\n<tr>\n<td>WET<\/td>\n<td>Plain text extracted by Common Crawl, one <code>conversion<\/code> record per page<\/td>\n<td>5.85 TiB, 100,000 files<\/td>\n<td>Quick prototypes, cheap language stats<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Sizes are from the <a href=\"https:\/\/data.commoncrawl.org\/crawl-data\/CC-MAIN-2026-43\/index.html\">CC-MAIN-2026-43 index page<\/a>, which reports 2.16 billion pages for that crawl. WARC is about 15x larger than WET, and that ratio is the main cost of re-extracting.<\/p>\n<h3>Why pipelines re-extract from WARC<\/h3>\n<p>The <a href=\"https:\/\/arxiv.org\/abs\/2406.17557\">FineWeb paper<\/a> (Penedo et al., 2024) is direct about it: WET files \"retained too much boilerplate and menu text.\" The authors trained 1.71B-parameter ablation models on 28B tokens of trafilatura-extracted WARC text and of WET text, applying only fastText English filtering. The WARC version \"clearly results in a more performant model.\" Common Crawl's own WET sample of a Wikipedia page starts with \"Jump to content \/ Main menu \/ Navigation...\", which shows the problem.<\/p>\n<p>Two extractors dominate:<\/p>\n<ul>\n<li><strong><a href=\"https:\/\/trafilatura.readthedocs.io\/en\/latest\/usage-python.html\">trafilatura<\/a><\/strong> was used by RefinedWeb and FineWeb. <code>extract(html, favor_precision=True)<\/code> prunes more boilerplate. It is accurate but CPU-heavy.<\/li>\n<li><strong><a href=\"https:\/\/resiliparse.chatnoir.eu\/en\/stable\/man\/extract\/html2text.html\">Resiliparse HTML2Text<\/a><\/strong> is a fast, rule-based extractor. <code>extract_plain_text(html, main_content=True)<\/code> drops navigation, sidebars and footers. It pairs with FastWARC, a Rust WARC parser that the Resiliparse docs benchmark at 1.5x to 5x faster than WARCIO on typical setups.<\/li>\n<\/ul>\n<p>If extraction CPU is your bottleneck, compare both on a few thousand pages from your target domains before committing a full snapshot to either.<\/p>\n<h2>Accessing the data: S3, HTTPS and the indexes<\/h2>\n<p>The data sits in <code>s3:\/\/commoncrawl\/<\/code> in us-east-1, and anyone can download it over HTTPS from <code>https:\/\/data.commoncrawl.org\/<\/code>, no AWS account needed. Common Crawl says to run AWS compute in us-east-1 to avoid inter-region charges. Its Get Started page currently shows <code>aws s3<\/code> with <code>--no-sign-request<\/code>, but an older section on the same page says S3 API access requires authenticated users. If anonymous S3 calls fail, use HTTPS or signed requests.<\/p>\n<pre><code>CRAWL=CC-MAIN-2026-43\n# list WARC paths (100,000 lines for this crawl)\ncurl -s https:\/\/data.commoncrawl.org\/crawl-data\/$CRAWL\/warc.paths.gz | gunzip &gt; warc.paths\nhead -n 2 warc.paths\n\n# download one file over HTTPS\ncurl -O \"https:\/\/data.commoncrawl.org\/$(head -n 1 warc.paths)\"\n\n# or, from EC2 in us-east-1\naws s3 cp \"s3:\/\/commoncrawl\/$(head -n 1 warc.paths)\" .<\/code><\/pre>\n<p>A full WARC set is big. At a sustained 10 Gbps: 86.19 TiB \u00d7 8.796e12 bits\/TiB \u00f7 1e10 bit\/s \u2248 75,800 s, or about 21 hours, before any processing. Our <a href=\"https:\/\/globalcorpora.com\/blog\/bandwidth-for-large-scale-video-downloads\/\">bandwidth sizing guide<\/a> covers the same math for other workloads. Download failures happen, so wrap fetches in retries with backoff (see <a href=\"https:\/\/globalcorpora.com\/blog\/web-scraping-rate-limiting-retries-backoff\/\">rate limiting, retries and backoff<\/a>). Check the <a href=\"https:\/\/status.commoncrawl.org\">infra status page<\/a> before blaming your own code.<\/p>\n<h3>Use the index when you don't need everything<\/h3>\n<p>Common Crawl publishes two indexes. The <a href=\"https:\/\/commoncrawl.org\/cdxj-index\">CDXJ index<\/a> (served at <code>index.commoncrawl.org<\/code>) is built for per-URL lookups. The <a href=\"https:\/\/commoncrawl.org\/url-index\">URL Index<\/a>, previously called the columnar index, is Parquet under <code>s3:\/\/commoncrawl\/cc-index\/table\/cc-main\/warc\/<\/code>. You can query it with Athena, Spark or DuckDB. Each row includes <code>warc_filename<\/code>, <code>warc_record_offset<\/code>, <code>warc_record_length<\/code>, <code>content_languages<\/code> (from CLD2) and <code>content_truncated<\/code>, so you can select pages by domain or language and fetch only those records:<\/p>\n<pre><code>SELECT url, warc_filename, warc_record_offset, warc_record_length\nFROM ccindex.ccindex\nWHERE crawl = 'CC-MAIN-2026-43'\n  AND subset = 'warc'\n  AND url_host_registered_domain = 'example.org'\n  AND content_languages LIKE 'eng%'\nLIMIT 100;<\/code><\/pre>\n<pre><code># fetch a single record with an HTTP range request\ncurl -s -r$OFFSET-$(($OFFSET+$LENGTH-1)) \\\n  \"https:\/\/data.commoncrawl.org\/$FILENAME\" &gt; record.warc.gz<\/code><\/pre>\n<p>Range requests work well for targeted subsets such as a domain list or a language. To process a whole snapshot, stream entire WARC files, because millions of tiny requests cost more than sequential reads. Also note the <a href=\"https:\/\/commoncrawl.org\/blog\/common-crawl-foundation-opt-out-registry\">truncation erratum<\/a>: captures were cut at 1 MiB before CC-MAIN-2025-13 and at 5 MiB from then on. Drop or flag truncated records, because their HTML is often incomplete.<\/p>\n<h2>Step 1: extraction you can run on one machine<\/h2>\n<p>This minimal extractor uses FastWARC and Resiliparse, written against the Resiliparse 2.0 docs. It reads only <code>response<\/code> records, keeps HTML, and writes JSONL with the URL and date. Keep those two fields, because you will need them later for URL filters, takedowns and per-domain stats.<\/p>\n<pre><code># pip install fastwarc resiliparse\nimport json, sys\nfrom fastwarc.warc import ArchiveIterator, WarcRecordType, WarcHeader\nfrom resiliparse.parse.encoding import detect_encoding, bytes_to_str\nfrom resiliparse.extract.html2text import extract_plain_text\n\ndef extract(warc_path, out_path):\n    with open(warc_path, \"rb\") as f, open(out_path, \"w\", encoding=\"utf-8\") as out:\n        for rec in ArchiveIterator(f, record_types=WarcRecordType.response):\n            if rec.http_content_type != \"text\/html\":\n                continue\n            body = rec.reader.read()\n            html = bytes_to_str(body, detect_encoding(body))\n            text = extract_plain_text(html, main_content=True)\n            if len(text.split()) &lt; 50:\n                continue\n            out.write(json.dumps({\n                \"url\": rec.headers.get(WarcHeader.WARC_TARGET_URI),\n                \"date\": rec.headers.get(WarcHeader.WARC_DATE),\n                \"text\": text,\n            }, ensure_ascii=False) + \"\\n\")\n\nif __name__ == \"__main__\":\n    extract(sys.argv[1], sys.argv[2])<\/code><\/pre>\n<p>To use trafilatura instead, replace the extraction line with <code>trafilatura.extract(html, favor_precision=True)<\/code> and handle a <code>None<\/code> return.<\/p>\n<h2>Step 2: the full filtering pipeline with datatrove<\/h2>\n<p><a href=\"https:\/\/github.com\/huggingface\/datatrove\">datatrove<\/a> is the library Hugging Face built to produce FineWeb. Its <a href=\"https:\/\/github.com\/huggingface\/datatrove\/blob\/main\/examples\/fineweb.py\">fineweb.py<\/a> example runs the exact production pipeline on Slurm. The version below follows the same order on a single machine, reading WARC files you have already downloaded:<\/p>\n<pre><code># pip install \"datatrove[io,processing]\"\nfrom datatrove.executor import LocalPipelineExecutor\nfrom datatrove.pipeline.readers import WarcReader\nfrom datatrove.pipeline.extractors import Trafilatura\nfrom datatrove.pipeline.filters import (\n    URLFilter, LanguageFilter, GopherRepetitionFilter,\n    GopherQualityFilter, C4QualityFilter, FineWebQualityFilter,\n)\nfrom datatrove.pipeline.writers.jsonl import JsonlWriter\n\nCRAWL = \"CC-MAIN-2026-43\"\n\nLocalPipelineExecutor(\n    pipeline=[\n        WarcReader(\"data\/warc\/\", glob_pattern=\"*.warc.gz\",\n                   default_metadata={\"dump\": CRAWL}),\n        URLFilter(exclusion_writer=JsonlWriter(\"out\/removed\/url\")),\n        Trafilatura(favour_precision=True),\n        LanguageFilter(languages=[\"en\"], language_threshold=0.65),\n        GopherRepetitionFilter(),\n        GopherQualityFilter(),\n        C4QualityFilter(filter_no_terminal_punct=False),\n        FineWebQualityFilter(),\n        JsonlWriter(\"out\/filtered\"),\n    ],\n    tasks=8, workers=8, logging_dir=\"logs\/cc_filter\",\n).run()<\/code><\/pre>\n<p>Every filter accepts an <code>exclusion_writer<\/code>. Use it while tuning: reading what each rule removed is the fastest way to catch a filter that hurts your domain. datatrove records finished tasks under <code>logging_dir\/completions<\/code>, so rerunning the same executor resumes only failed tasks. Don't change <code>tasks<\/code> between runs.<\/p>\n<h3>URL filtering<\/h3>\n<p>FineWeb's base filtering started with an adult-content URL blocklist (FineWeb2 links the <a href=\"https:\/\/dsi.ut-capitole.fr\/blacklists\/\">UT1 blacklists<\/a>), applied before extraction because that step costs almost nothing. Add your own lists here too: domains from opt-out requests, known spam farms, and anything your legal team has excluded.<\/p>\n<h3>Language identification: lid.176 or GlotLID?<\/h3>\n<p>FineWeb used the fastText <a href=\"https:\/\/fasttext.cc\/docs\/en\/language-identification.html\">lid.176<\/a> model (176 languages, 126 MB <code>.bin<\/code>, licensed CC BY-SA 3.0) and kept documents whose top English score was \u2265 0.65. In datatrove this is <code>LanguageFilter(backend=\"ft176\")<\/code>, the default. According to the <a href=\"https:\/\/arxiv.org\/abs\/2506.20920\">FineWeb2 paper<\/a>, about 40% of extracted documents passed that English threshold.<\/p>\n<p>For multilingual work, FineWeb2 switched to <a href=\"https:\/\/github.com\/cisnlp\/GlotLID\">GlotLID<\/a>, which the paper describes as covering 1,880 languages, separating scripts (e.g. <code>arb_Arab<\/code> vs <code>arb_Latn<\/code>) and including \"noise\" labels. In ablations, GlotLID beat FT176 on higher-resource languages and trailed slightly on lower-resource ones. Instead of a single threshold, FineWeb2 sets per-language cutoffs at max(0.3, min(0.9, median \u2212 \u03c3)) of each language's confidence distribution. datatrove exposes this as <code>backend=\"glotlid\"<\/code>.<\/p>\n<h3>Heuristic quality filters<\/h3>\n<table>\n<thead>\n<tr>\n<th>Filter set<\/th>\n<th>Representative rules<\/th>\n<th>Notes from FineWeb<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Gopher quality (<a href=\"https:\/\/arxiv.org\/abs\/2112.11446\">MassiveText<\/a>)<\/td>\n<td>50\u2013100,000 words; mean word length 3\u201310; \u2264 10% hash\/ellipsis symbols per word; \u2264 90% bullet lines; \u2265 80% words with a letter; \u2265 2 stop words<\/td>\n<td>Used with original thresholds in base filtering<\/td>\n<\/tr>\n<tr>\n<td>Gopher repetition<\/td>\n<td>Duplicate line\/paragraph fractions and repeated n-gram ratios<\/td>\n<td>Base filtering<\/td>\n<\/tr>\n<tr>\n<td>C4 (<a href=\"https:\/\/arxiv.org\/abs\/1910.10683\">Raffel et al.<\/a>)<\/td>\n<td>Drop lines mentioning javascript or cookie\/terms policies; drop docs with \"lorem ipsum\" or <code>{<\/code>; terminal-punctuation line filter<\/td>\n<td>Terminal-punctuation filter removed ~30% of tokens, so FineWeb disabled it<\/td>\n<\/tr>\n<tr>\n<td>FineWeb custom<\/td>\n<td>Line-ending punctuation ratio \u2264 0.12; chars in duplicated lines \u2265 0.1; lines under 30 chars \u2265 0.67<\/td>\n<td>Together removed ~22% of tokens and raised the aggregate score by about 1%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>One detail to check: the paper states the duplicated-line threshold as 0.1, but the current datatrove <code>FineWebQualityFilter<\/code> source defaults <code>char_duplicates_ratio<\/code> to 0.01. Set it explicitly to the value you intend. All of these rules were tuned on English. FineWeb2 re-derived thresholds per language from Wikipedia and Common Crawl statistics, so don't reuse English cutoffs for Thai or Chinese.<\/p>\n<h2>Step 3: deduplication<\/h2>\n<p>FineWeb's MinHash setup used word 5-grams and 112 hash functions in 14 buckets of 8, targeting documents that are at least 75% similar, then clustered duplicates transitively and kept one document per cluster. The surprising result: deduplicating all 96 snapshots globally left 4T tokens and barely improved over no dedup, because it disproportionately kept low-quality pages in older crawls. Deduplicating each snapshot independently left 20T tokens and matched RefinedWeb. The datatrove example runs this as four stages (signatures, buckets, clustering, filter). Only the clustering stage runs as a single task. We cover parameter choices and the false-positive math in <a href=\"https:\/\/globalcorpora.com\/blog\/minhash-deduplication-llm-training-data\/\">MinHash deduplication for LLM training data<\/a>.<\/p>\n<p>FineWeb2 takes this further with rehydration: it records each kept document's cluster size and uses it to upsample, which improved results even in languages where dedup alone helped little.<\/p>\n<h2>Step 4: PII<\/h2>\n<p>For its public release, FineWeb anonymized email addresses and public IP addresses. datatrove's <code>PIIFormatter<\/code> does this with regexes, replacing matches with placeholder emails and IPs and leaving private IP ranges alone. That is a minimal baseline. It does not touch names, phone numbers, street addresses or government IDs. If your use case or jurisdiction requires more, add a dedicated detector and audit a sample by hand. Run PII after dedup so you only scrub what you keep.<\/p>\n<h2>Step 5 (optional): model-based quality filtering<\/h2>\n<p>FineWeb-Edu is the best-documented recipe here. Llama-3-70B-Instruct scored 460,000 FineWeb pages for educational value on a 0\u20135 additive scale. A linear regression head on frozen <code>Snowflake-arctic-embed-m<\/code> was then trained on 410,000 of those annotations. Keeping documents with an integer score \u2265 3 produced a 1.3T-token subset, with an F1 of 82% for that binary cut on held-out data. The paper reports MMLU going from 33% to 37% and ARC from 46% to 57% in its 350B-token ablations. Classifying all 15T tokens of FineWeb took 6,000 H100 GPU hours.<\/p>\n<p>The released <a href=\"https:\/\/huggingface.co\/HuggingFaceFW\/fineweb-edu-classifier\">fineweb-edu-classifier<\/a> (Apache-2.0) is ready to use. Its model card warns that it targets grade-school level educational content and may not transfer to other domains. The paper also shows it shifts topic mix away from business, entertainment and travel. If you need a different notion of \"quality\", repeat the recipe with your own rubric: LLM labels on a few hundred thousand samples, then a cheap classifier on embeddings.<\/p>\n<h2>Licensing, privacy and opt-outs<\/h2>\n<p>Common Crawl's <a href=\"https:\/\/commoncrawl.org\/terms-of-use\">Terms of Use<\/a> say crawled content may be subject to the original sites' own terms, require you to respect third-party copyright, and include an indemnification clause that explicitly covers using crawled content to train AI systems. Common Crawl points publishers to robots.txt for controlling its CCBot crawler and publishes an <a href=\"https:\/\/commoncrawl.org\/blog\/common-crawl-foundation-opt-out-registry\">Opt-Out Ledger<\/a> of legal removal requests it has received. Apply that ledger, and your own takedown list, to past snapshots too, because older crawls predate those requests. Web text contains personal data, so GDPR and similar laws can apply to your corpus even after regex scrubbing. Keep URL and crawl provenance for every document so you can honor deletion requests. Get legal review for your jurisdiction and intended use before training on or redistributing the result.<\/p>\n<h2>When Common Crawl isn't enough<\/h2>\n<p>Coverage gaps are common: some domains are crawled shallowly, pages that render their content with JavaScript can come out nearly empty from raw HTML, and image-text pairs need their own pipeline (see <a href=\"https:\/\/globalcorpora.com\/blog\/build-image-text-dataset-img2dataset-clip-filtering\/\">building an image-text dataset with img2dataset and CLIP filtering<\/a>). Teams then run a targeted crawler, often headless (<a href=\"https:\/\/globalcorpora.com\/blog\/playwright-headless-browser-web-scraping-at-scale\/\">Playwright at scale<\/a>), writing WARC so the same datatrove pipeline applies. If you run that crawler yourself, Corpora sells <a href=\"https:\/\/globalcorpora.com\/#pricing\">dedicated unmetered proxy capacity<\/a> (1\u201340 Gbps, HTTP(S) and SOCKS5) for your own stack, plus a separate <a href=\"https:\/\/proxy.globalcorpora.com\/\">residential proxy<\/a> product. The same robots.txt, terms-of-service and rate-limit obligations apply either way.<\/p>\n<h2>FAQ<\/h2>\n<h3>Should I use Common Crawl WET files or re-extract text from WARC?<\/h3>\n<p>For a production pretraining corpus, re-extract from WARC. FineWeb's ablation showed trafilatura-on-WARC beating WET at equal token budgets. WET is about 15x smaller, so it's still useful for quick language or domain statistics.<\/p>\n<h3>Which language identification model did FineWeb use?<\/h3>\n<p>fastText <code>lid.176<\/code>, keeping documents with an English score of at least 0.65. FineWeb2, the multilingual follow-up, uses GlotLID with per-language thresholds.<\/p>\n<h3>How large is one Common Crawl snapshot?<\/h3>\n<p>For CC-MAIN-2026-43: 2.16 billion pages, with 86.19 TiB of WARC, 14.06 TiB of WAT and 5.85 TiB of WET (compressed), each split into 100,000 files. Other snapshots differ, so check each crawl's index page.<\/p>\n<h3>Do I need an AWS account to download Common Crawl?<\/h3>\n<p>No. Everything is available over HTTPS at <code>https:\/\/data.commoncrawl.org\/<\/code>. AWS mainly helps if you process inside us-east-1, next to the data.<\/p>\n<h3>Can I just use FineWeb instead of processing Common Crawl myself?<\/h3>\n<p>Often, yes. FineWeb (15T tokens, 96 snapshots) and FineWeb-Edu are released under ODC-By. Process Common Crawl yourself when you need newer snapshots, other languages, different filters, or full control over provenance and opt-outs.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Turn Common Crawl into LLM pretraining text: WARC vs WET, trafilatura extraction, lid.176\/GlotLID, FineWeb filters, MinHash dedup and PII scrubbing.<\/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":[83,46,86,49,85,84],"class_list":["post-33","post","type-post","status-publish","format-standard","hentry","category-datasets","tag-common-crawl","tag-data-filtering","tag-datatrove","tag-deduplication","tag-fineweb","tag-llm-pretraining-data"],"_links":{"self":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/33","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=33"}],"version-history":[{"count":0,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/33\/revisions"}],"wp:attachment":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/media?parent=33"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/categories?post=33"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/tags?post=33"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}