A single stylesheet on one of our sites declares 1,010 @font-face rules. Add the other three sheets and the page ships 1,021. Chrome registered all of them, then fetched 107. The 914 it skipped are the reason this page is survivable.
I run a network of 114 content sites — price outlooks, market explainers, filings breakdowns. This week I pointed a crawler at every homepage and counted fonts the way a browser counts them: parse the stylesheets, resolve every src, then ask how many bytes each file actually is.
The result was worse than I expected in the CSS and better than I expected at runtime. Both halves matter, because only one of them costs users anything.
How the count was done
Every homepage was fetched with Accept-Encoding: identity so the HTML arrives uncompressed and nothing about the markup changes. For each page I collected up to 10 <link rel=stylesheet> targets, parsed @font-face blocks out of them, resolved relative src URLs against the stylesheet URL, and HEADed each font file for Content-Length.
The parser is deliberately dumb — no CSS library, because I only need three properties and I want to see exactly what it misses:
FONTFACE_RE = re.compile(r"@font-face\s*\{(.*?)\}", re.S | re.I) FAM_RE = re.compile(r"font-family\s*:\s*([^;}\n]+)", re.I) FD_RE = re.compile(r"font-display\s*:\s*([a-zA-Z\-]+)", re.I) SRC_RE = re.compile(r"src\s*:\s*([^;}\n]+)", re.I) URL_RE = re.compile(r"url\(\s*['\"]?([^'\")]+)['\"]?\s*\)", re.I) def parse_faces(css, base): faces = [] for block in FONTFACE_RE.findall(css): src, fam, fd = SRC_RE.search(block), FAM_RE.search(block), FD_RE.search(block) urls = URL_RE.findall(src.group(1)) if src else URL_RE.findall(block) faces.append({ "family": fam.group(1).strip().strip("'\"") if fam else None, "display": fd.group(1).lower() if fd else None, "srcs": [urllib.parse.urljoin(base, u.strip()) for u in urls], "unicode_range": bool(re.search(r"unicode-range\s*:", block, re.I)), }) return faces Two things this method cannot see, and both matter: fonts injected by JavaScript at runtime, and fonts loaded from a CSS @import chain. Neither showed up in this network, but a crawler that only reads <link rel=stylesheet> will undercount on sites that do it.
46 of 114 pages ship no webfont at all
The cleanest templates never load a font. Their whole stylesheet is 6.4 KB of inline CSS and the body rule is font: 16px/1.72 system-ui, -apple-system, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif. No stylesheet link, no @font-face, no request.
Chrome confirms it: 0 font requests, 12.6 KB of HTML, 38 KB for the entire page including scripts. First contentful paint at 2,096 ms on this machine, which is not fast — but nothing about that number is a font problem.
The other 68 pages do ship fonts, and they ship them hard.
The declared surface is 193.8 MB
Across the 68 pages that declare fonts: 12,949 @font-face rules, 4,020 distinct font files, 193.8 MB of declared bytes. Median per page is 1.7 MB. Twenty-five pages declare more than 4 MB.
| Page | Rules | Files | Declared |
|---|---|---|---|
| spacexstockanalysis.com | 861 | 218 | 11.70 MB |
| marketpredictioncenter.com | 645 | 218 | 11.69 MB |
| spacexstockprediction.com | 1,021 | 211 | 11.49 MB |
| openaistocknews.com | 819 | 211 | 11.48 MB |
| cryptobullforecast.com | 356 | 117 | 7.39 MB |
Most of that mass is legitimate Chinese text support. Noto Sans SC and Noto Serif SC are split into unicode-range slices, one file per slice, and 211 files is what a full CJK family looks like when you self-host it. All 68 pages use unicode-range — every single one, which is a rare piece of unbroken good practice in this audit.
But the pages themselves are not CJK-heavy. They are English content pages — a 2026 Bitcoin price outlook, a Starlink revenue breakdown, a Fed dot-plot explainer — the same reading experience at 9,000 characters that a text article anywhere else has. Declaring 1,021 faces for 9,000 characters is not a font problem, it is a build pipeline that stopped being read.
Declared is not transferred
Here is where my first assumption died. A browser does not download 211 files because a stylesheet names them. It downloads a file when a rendered glyph needs it, and only for the unicode range that glyph falls in.
So I loaded the heavy pages in headless Chrome and counted requests at the socket with CDP, not with PerformanceResourceTiming. That distinction matters: cross-origin responses without Timing-Allow-Origin report transferSize: 0, which silently erases every Google Fonts byte from your numbers. Network.loadingFinished.encodedDataLength is measured before that policy applies.
cdp = ctx.new_cdp_session(page) cdp.send("Network.enable") reqs = {} cdp.on("Network.responseReceived", lambda e: reqs.__setitem__( e["requestId"], {"url": e["response"]["url"], "type": e.get("type")})) cdp.on("Network.loadingFinished", lambda e: reqs.setdefault( e["requestId"], {}).update({"bytes": e["encodedDataLength"]})) page.goto(f"https://{host}/", wait_until="load") page.wait_for_timeout(3000) fonts = [r for r in reqs.values() if r["url"].split("?")[0].endswith(".woff2")] print(len(fonts), sum(r.get("bytes", 0) for r in fonts)) On spacexstockprediction.com: 1,021 rules registered in document.fonts, 107 marked loaded, 914 still unloaded, 33 network requests, 2,073 KB. The 11.49 MB declaration collapsed by 82% before a single byte left the server.
The same page: 861 rules on spacexstockanalysis.com, 83 loaded, 28 requests, 1,876 KB. 356 rules on cryptobullforecast.com, 14 loaded, 11 requests, 985 KB.
Lazy font loading is doing more work than most performance budgets give it credit for. If you have ever looked at a @font-face-heavy stylesheet and assumed the worst, measure the requests first.
The bytes that do move are still the problem
2,073 KB is not nothing. That page renders 9,037 visible characters — about 235 bytes of font per visible character, 33 round trips, and fonts are 56% of a 3,667 KB page load.
The distribution is worse than the total. On coinforecastpro.com the page declares 16 faces but transfers exactly one file: remixicon.woff2, 171 KB. On spacexstockprediction.com the biggest single font is also remixicon.woff2 at 171 KB — a full icon font with roughly 3,000 glyph mappings, fetched to render 51 elements.
Three generations of Font Awesome, on 22 pages
Twenty-two of the 68 pages declare Font Awesome 4, Font Awesome 5 and Font Awesome 6 at the same time. Not "one of them" — all three, plus remixicon. The family list on one page reads like a changelog:
FontAwesome (4.x) 2 faces Font Awesome 5 Free 4 faces Font Awesome 5 Brands 2 faces Font Awesome 6 Free 10 faces Font Awesome 6 Brands 2 faces remixicon 1 face That is six icon families for one page. The 4.x entries are the tell: they come from a font-family: FontAwesome rule left in a template that was later upgraded twice, and nobody deleted the old @font-face because nothing visibly broke.
At runtime, the cost is smaller than the CSS suggests. On cryptobullforecast.com, 316 elements resolve to an icon family — 216 remixicon, 97 Font Awesome 6 Free, 3 Font Awesome 6 Brands. Zero resolve to 4.x or 5.x. On bullrunalpha.com, all 19 icon elements are remixicon; its 82 declared faces include all three FA generations and none of them is ever applied.
So the browser already refuses to download the dead generations. What you keep paying for is the stylesheet: 1.35 MB of CSS on that page, four sheets, of which css2.css alone is 1,094,450 characters and 1,010 rules.
I parsed those four sheets in the page and timed CSSStyleSheet.replaceSync: 36.2 ms for css2.css, 13.5 ms for remixicon.min.css, 6.7 ms for all.min.css, 1.7 ms for the app sheet — 58 ms of style parsing before layout can start, on a machine that is probably faster than the phone this page will be read on.
174 KB of icon font to render 16 glyphs
I wanted a number for what subsetting would actually save, so I did it. Collected the ri-* classes present in the rendered DOM, mapped each class to its code point out of remixicon.min.css (3,020 mappings in that file), and subset the shipped woff2 to those points plus basic Latin:
from fontTools import subset opts = subset.Options() opts.flavor = "woff2" opts.layout_features = ["*"] font = subset.load_font("remixicon.woff2", opts) sub = subset.Subsetter(options=opts) sub.populate(unicodes=set(used_codepoints) | set(range(0x20, 0x7F))) sub.subset(font) font.flavor = "woff2" font.save("remixicon.subset.woff2") 174,156 bytes in, 1,348 bytes out — 99.2% smaller. The page has 51 icon elements but only 16 distinct icons, and 16 glyphs is a 1.3 KB font.
Do not ship that as a one-off. A 16-glyph subset goes to tofu the moment someone adds a seventeenth icon, and the failure looks like a broken glyph in production, not a missing build step. The version that survives is a build step that reads the icon set from the source and regenerates on every deploy — or inline SVG, which needs no subsetting and no second request at all.
I blocked every font request and first paint did not move
My working theory was that 2 MB of fonts was delaying first paint. I tested it: same page, same viewport, one arm with all font requests aborted at the route layer, three runs each, cold context.
| Page | FCP with fonts | FCP without | Delta |
|---|---|---|---|
| spacexstockprediction.com | 3,968 ms | 3,472 ms | +496 |
| spacexstockanalysis.com | 3,112 ms | 3,396 ms | −284 |
| cryptobullforecast.com | 2,460 ms | 2,812 ms | −352 |
| coinforecastpro.com | 3,644 ms | 3,484 ms | +160 |
The signs are inconsistent. On a single machine with three runs per arm, that is noise, not an effect. Which is exactly what font-display: swap is supposed to produce: text paints in the fallback, the font arrives later, first contentful paint does not wait.
I expected the cost to reappear as layout shift, so I measured that too — layout-shift entries over a 5-second settle window, two runs per arm:
| Page | CLS with fonts | CLS without |
|---|---|---|
| spacexstockprediction.com | 0.4216 | 0.3950 |
| spacexstockanalysis.com | 0.4155 | 0.4155 |
| cryptobullforecast.com | 1.0017 | 1.0006 |
Blocking fonts barely moved CLS either. A CLS of 1.0 is a serious problem, but it is not a font problem — something in those pages is shifting content after paint, and fonts are a rounding error next to it. That is a separate investigation, and it is on the list.
What the numbers actually support
Font bloat on this network is a bytes and CSS-weight problem, not a paint-blocking problem:
- 46 of 114 pages avoid it entirely by using the system font stack.
- 68 pages declare 193.8 MB of font files; the browser fetches 13–18% of that for English text, and the waste never reaches the user because lazy loading refuses it.
- The waste that does reach the user is concentrated: 171 KB of icon font per page to render 16–216 glyphs, plus 2 MB of CJK slices on pages with 9,000 characters of English.
- The declared rules you cannot avoid paying for are the CSS: 1.35 MB and 58 ms of parse on the worst page.
- 37 of 68 pages have zero font preload. On a self-hosted setup that means discovery waits for the full stylesheet to parse — 353 KB of transfer before the first font request can even be issued.
- 788 faces have no
font-displayat all, on 41 pages. The default isauto, which behaves likeblockfor a short period; 220 more declareblockexplicitly. That is the one place where a font really can hide text.
The order I would fix it in
- Preload one font. The face that renders above-the-fold text. On a 1.35 MB stylesheet,
preloadis the difference between discovering the font at 400 ms and at 40 ms. 37 pages have none. - Delete the unused generations. FA 4 and 5 never apply. Removing them does not reduce transfer, because the browser never fetched them, but it removes ~40% of the
@font-facerules that every visitor's CSS parser walks. - Subset the icon font at build time. 174 KB to 1.3 KB for the glyphs actually in the markup, regenerated on deploy so nobody gets tofu.
- Cut CJK slices to the script actually used. 211 files is a full family; a page that renders 9,000 characters needs a handful of ranges, and
unicode-rangeis already there to make that possible. - Set
font-display: swapon every face explicitly. 788 faces inheritautotoday.
What this measurement does not prove
One machine, headless Chrome, one geographic location, cold cache, homepages only. FCP and CLS numbers at three and two runs per arm are directional, not precise — treat the CLI table as "no effect detected", not "effect proven absent". The 114 sites are one network on one Cloudflare account, so the 59.6% webfont adoption rate says nothing about the wider web. And a crawler reading <link rel=stylesheet> cannot see fonts injected by JavaScript or by @import, so 193.8 MB is a floor for these pages, not a ceiling.
The one number I trust completely is the request count: 1,021 rules declared, 107 fetched. If you take nothing else from this, take that gap — your stylesheet is not your font budget.