AI

Hugging Face Custom CDN: Why Open-Model Traffic Outgrew Commodity CDNs at 1 Exabyte/Month

On November 20, 2026, Hugging Face disclosed that it now ships nearly 1 exabyte of open models and datasets monthly via a custom CDN hitting 420 GB/s peaks. Here is why commodity web CDNs broke at AI checkpoint scale—and what platform teams should copy.

By 0xScorPionSon

8 min read

Hugging Face Custom CDN: Why Open-Model Traffic Outgrew Commodity CDNs at 1 Exabyte/Month

Hugging Face Custom CDN 1 Exabyte per month Xet CAS architecture

Standard web content delivery networks were engineered to cache small HTML, CSS, and image fragments for millions of human browsers—not to stream 100+ GB Safetensors checkpoints at line rate to GPU clusters on model launch day. On November 20, 2026, Hugging Face co-founders Julien Chaumond and Thomas Wolf disclosed that the Hub now serves nearly 1 exabyte (~1,000 PB) of open models and datasets per month through a custom-built CDN, hitting company-reported peaks of 420 GB/s and 80,000 concurrent requests per second (explainx.ai; Emergent).

Executive Summary

  • Traffic Scale: Hugging Face states it distributes nearly 1 exabyte/month (~31.7 PB/day average) across 500,000+ models and 100,000+ datasets, with release-day spikes reaching 420 GB/s and 80,000 req/s (explainx.ai; Emergent).
  • Why Commodity CDNs Failed: As documented in Hugging Face's Rearchitecting Uploads and Downloads post, AWS CloudFront's 50 GB per-object limit forced 131 GB models like Llama-3-70B into 20 GB shards, while traditional edge caches optimize for small web assets rather than multi-gigabyte whole-checkpoint pulls.
  • Xet + CAS Storage Backbone: The custom download path pairs with Hugging Face's Xet content-addressed storage (~64 KB content-defined chunks grouped into ~64 MB xorbs on cas-server.xethub.hf.co), which migrated 30+ PB off Git LFS (Xet on the Hub).
  • Verification Caveat: The 1 EB/month, 420 GB/s, and 80,000 req/s figures are company-stated (no independent third-party bandwidth audit was attached), though Hugging Face published a live aggregate traffic map at huggingface-cdn-live.static.hf.space.

Architecture & How It Works

Hugging Face's November 20, 2026 disclosure is the download-side culmination of a two-year storage overhaul that replaced file-level Git LFS with chunk-level Xet content-addressed storage (CAS) and bespoke edge caching.

Why Commercial Web CDNs Misfire on AI Checkpoints

Workload Dimension Traditional Web CDN Assumption Hugging Face AI Distribution Reality
Object Size Many small assets (KB to low MB) Few massive checkpoints (8 GB GGUF to 1 TB+ sharded models)
Client Topology Human readers spread globally Concentrated GPU clusters in select cloud regions
Cache Objective High edge hit ratio across millions of users Whole-object caching at line rate for synchronized cluster pulls
File-Size Ceiling AWS CloudFront 50 GB object limit Multi-hundred-GB weights requiring 20 GB sharding workarounds
flowchart LR
    A[Client: huggingface_hub / hf_xet] -->|1. Request File + Auth Token| B[Hugging Face Hub API]
    B -->|2. Reconstruction Metadata| C[Xet CAS: cas-server.xethub.hf.co]
    C -->|3. 64 KB CDC Chunks / 64 MB Xorbs| D[Custom AI CDN Edge Cache]
    D -->|4. Line-Rate HTTP / Range Reads up to 420 GB/s| E[GPU Inference & Training Clusters]

How Xet Chunking & Background Migration Work

In standard Git LFS, average Parquet and CSV files on the Hub range between 200–300 MB, average Safetensors files run around 1 GB, and quantized GGUF files frequently exceed 8 GB (From Files to Chunks). Because Git LFS tracks assets at the file level, modifying a single line of metadata in an 8 GB GGUF file or fine-tuning 5% of a 20 GB model forced a full-file re-upload, full-file re-download, and duplicate server-side storage across revisions.

Under Xet (hf_xet), files are split via content-defined chunking (CDC) into ~64 KB chunks and aggregated into immutable ~64 MB xorbs before transfer (Xet on the Hub). Identical tokenizer configs, base model layers, or unchanged Parquet row groups are physically stored once on cas-server.xethub.hf.co and deduplicated across repositories. When a non-Xet client pushes an LFS file, Hugging Face's background migration orchestrator batches up to 1,000 files or 500 MB per job via distributed queues to keep 500,000+ repositories synchronized without repository locks.

For developers and CI pipelines, pinning exact commit revisions in huggingface_hub prevents redundant pulls while leveraging Xet reconstruction:

from huggingface_hub import snapshot_download

local_dir = snapshot_download(
    repo_id="moonshotai/Kimi-K3.1-Pro",
    revision="main",  # Pin a 40-char commit SHA in CI to avoid drifting re-pulls
    allow_patterns=["*.safetensors", "*.json"],
)

Benchmarks, Cost & Latency Analysis

Traffic & Storage Telemetry

Because Hugging Face has not published an external audit of its 1 EB/month claim, engineers should separate November 20, 2026 company disclosures from earlier measured engineering benchmarks:

Metric Reported Value Source & Confidence
Monthly Distribution Volume ~1 Exabyte/month (~31.7 PB/day) Julien Chaumond, Nov 20, 2026 (company-stated; explainx.ai)
Peak Throughput & Concurrency 420 GB/s / 80,000 req/s Thomas Wolf, Nov 20, 2026 (company-stated; explainx.ai)
Hub Repository Scale 500,000+ models; 100,000+ datasets; 30+ PB migrated Emergent; From Files to Chunks
24h Upload Baseline (Oct 2024) 130.8 TB across 8.2M requests (88 countries) Rearchitecting Uploads & Downloads
Xet Deduplication Speedup 2–3x faster transfers; 5 GB SQLite + 1 MB diff in 0.1 s vs. 13 min From Chunks to Blocks; Xet on the Hub

Bandwidth Math & Release-Day Mega-Floods

Spreading 1 exabyte evenly across a 30-day month works out to roughly 31.7 PB/day, or an average sustained throughput of ~367 GB/s—yet real ML distribution is heavily skewed toward release-day spikes. When a frontier open-weight model lands on Hacker News or GitHub trending, thousands of automated CI runners, inference providers, and multi-node GPU clusters trigger synchronized full-checkpoint pulls and byte-range reads simultaneously, driving the 420 GB/s and 80,000 req/s peaks Wolf highlighted (explainx.ai). Hugging Face also exposed aggregate regional pull telemetry on its public live map (huggingface-cdn-live.static.hf.space) so SREs can observe cross-border model traffic patterns.

Egress Economics: Why Custom CDNs Are a Moat

At 1 exabyte/month, egress bandwidth—not disk storage—dominates unit economics. Commodity cloud egress and per-request CDN billing punish workloads where a single GPU cluster pulls 400 GB to 1 TB of weights simultaneously. Hugging Face subsidizes public model distribution as strategic platform spend (monetizing Team/Enterprise storage seats and governance features), whereas startups or sovereign AI hubs attempting to mirror frontier weights on flat SaaS pricing face severe margin compression unless they bill per terabyte transferred or peer directly near major GPU clouds (explainx.ai).

Production Deployment & Trade-Offs

Self-Hosted Mirror & Platform Checklist

For infrastructure teams running internal model registries or air-gapped GPU clusters, Hugging Face's architecture highlights five concrete design requirements (explainx.ai):

Operational Area Recommended Engineering Practice
Capacity Planning Model peak checkpoint size (GB) multiplied by expected concurrent cluster pulls, not average daily traffic.
Cache Eviction Policy Use whole-object caches sized for 20 GB shards rather than fragment-only LRU policies tuned for web pages.
Release Playbook Stagger shard uploads and pre-warm us-east, eu-west, and ap-southeast mirrors before public announcements.
Supply-Chain Integrity Enforce immutable commit SHAs, signed manifests, and mirrored SHA-256 checksums for fast rollback.
Cost Attribution Track and price internal/external consumption per full terabyte pulled rather than per API request or seat.

Enterprise Proxy & Air-Gapped Mirror Gotchas

  1. JFrog Artifactory Xet Limitation: In Hugging Face's enterprise Artifactory guide, engineering warned that Artifactory's Xet integration mimics the /reconstructions and xorbs/ API surface while storing isolated per-file blobs underneath—eliminating global deduplication and roughly doubling storage footprint. Furthermore, hf_xet still fetches chunk data directly from cas-server.xethub.hf.co in standard Xet flows, which can hit Hub 429 rate limits if an enterprise remote shares one token; disabling Xet fallback lets Artifactory cache flat LFS files at half the storage cost unless you deploy a Hugging Face-native gateway.
  2. Thundering Herd Protection on Cluster Restarts: Without a local pull-through mirror, autoscaling 100 inference replicas after a spot-instance preemption can saturate a VPC NAT gateway or corporate WAN link. Pin immutable revisions and stage weights on regional NVMe or object storage (S3/GCS) inside the same availability zone as your GPUs.
  3. Immutable Revisions & Security Scanning: Fast global distribution amplifies supply-chain mistakes. Always pin exact commit SHAs (never floating main), verify SHA-256 manifests, and keep Hugging Face's automated Pickle/malware scanning checks intact rather than bypassing verification for speed.

When Commodity CDNs Still Fit

Do not over-engineer a custom CDN for small LoRA adapters (< 1–2 GB), tokenizer configs, or standard web assets. Commodity CDNs like CloudFront remain simpler and cheaper until your distribution profile shifts to synchronized multi-hundred-gigabyte checkpoint pulls into concentrated GPU regions.

Frequently Asked Questions

How much traffic does Hugging Face's custom CDN handle?

According to November 20, 2026 statements by co-founders Julien Chaumond and Thomas Wolf, Hugging Face serves nearly 1 exabyte (~1,000 PB) per month (~31.7 PB/day), with peaks of 420 GB/s and 80,000 requests per second (explainx.ai). These figures are company-stated without a published third-party audit.

Why did Hugging Face replace AWS CloudFront for model downloads?

In its Rearchitecting Uploads and Downloads engineering post, Hugging Face noted that CloudFront's 50 GB file-size limit and web-oriented caching assumptions conflicted with massive AI checkpoints (such as 131 GB Llama-3-70B models) and synchronized GPU cluster downloads.

Do developers need a new CLI flag to use the Hugging Face custom CDN?

No. The custom CDN and Xet CAS routing operate transparently behind huggingface_hub and hf_xet downloads without requiring manual CLI flag changes.

How does Xet storage relate to Hugging Face's custom CDN?

Xet replaces file-level Git LFS with content-defined chunking (~64 KB chunks packed into ~64 MB xorbs) on cas-server.xethub.hf.co, eliminating redundant transfers when only part of a model or Parquet dataset changes, while the custom CDN optimizes the high-throughput download path to GPU clusters.

Why can enterprise proxies like JFrog Artifactory miss Xet's deduplication benefits?

Per Hugging Face's Artifactory guide, Artifactory's Xet implementation stores isolated per-file blobs rather than globally deduplicated chunks, forfeiting cross-model chunk reuse and roughly doubling storage usage unless you fall back to flat LFS caching or deploy a Hugging Face-native gateway.

Sources

More on AI

AI

Kimi K3.1 Pro Prime: 2.8T MoE Benchmarks, Pricing & Latency Trade-Offs

Kimi K3.1 Pro Prime launched on November 19-20, 2026 to fix the latency bottleneck of Moonshot AI's 2.8T-parameter (104B active) open-weight flagship. We compare its vendor evals, Artificial Analysis Intelligence Index score (46), and 2x Prime API pricing trade-offs.

9 min read

Tell us what is not working

A thirty-minute call, no deck and no obligation. You will leave with a straight answer about whether this is worth building - including if that answer is no.

Start a project

Direct line

hello@codebumble.net
Dhaka, Bangladesh  :   local timeCalls in English or Bangla