Server HTML vs rendered page on JavaScript framework sites, measured twice
This is the material behind the article. I took popular sites built with JavaScript frameworks and compared the HTML their server sends, which is what a crawler without JavaScript reads, with the page Chromium shows after the scripts have run. Then I did it again a month later on the same homepages, to see whether the result was a fluke.
What I looked at
I drew 1,200 domains at random from the Tranco list of the 100,000 most popular sites and fetched each homepage once over HTTPS. 714 returned an HTML page, and 116 of those carried a fingerprint of Next.js, Nuxt, React, Vue, Angular, SvelteKit or Gatsby in their HTML. I took the first 100 in random order and loaded each one in headless Chromium with Playwright, waiting for the network to go quiet. Sites where the browser got a bot check or an almost empty page were dropped, which left 87 in the first run.
A month later I fetched the same 100 homepages again and rendered them with the same script. 97 answered with HTML and 98 rendered, and after the same exclusions 91 were left. One thing changed in the method: the first run used a desktop Chrome user agent, and the repeat used one that names the research crawler (CometWebResearch/1.0).
The same parser read both versions and recorded the title, meta description, canonical, the first H1, the number of unique internal links and the amount of text in the body. A site counts as losing important content when its server HTML is missing a title, H1, description or canonical that the rendered page has, or holds less than half of the rendered text or internal links. H1s of cookie dialogs are ignored. The pack doesn't name the sites: each one has a neutral id such as site-0042, the same in both runs, and the Tranco rank is shown as a band of 10,000.
Results
| What I counted | Run 1 (October) | Run 2 (November) |
|---|---|---|
| Taken / rendered / compared | 100 / 93 / 87 | 100 / 98 / 91 |
| Lose important content without JavaScript (any rule below) | 31 of 87 (36%) | 32 of 91 (35%) |
| Empty shell: under 10% of the rendered text in the server HTML | 16 of 87 (18%) | 16 of 91 (18%) |
| Under half of the rendered text in the server HTML | 29 of 87 (33%) | 30 of 91 (33%) |
| Under half of the internal links in the server HTML | 20 of 87 (23%) | 20 of 91 (22%) |
| H1 only after JavaScript | 10 of 87 (11%) | 11 of 91 (12%) |
| Canonical only after JavaScript | 6 of 87 (7%) | 7 of 91 (8%) |
| Meta description only after JavaScript | 5 of 87 (6%) | 4 of 91 (4%) |
| Title only after JavaScript | 2 of 87 (2%) | 2 of 91 (2%) |
| Title changed by JavaScript | 8 of 87 (9%) | 8 of 91 (9%) |
| No internal links at all in the server HTML | 13 | 11 |
Did it hold a month later?
83 homepages were compared in both runs. 80 of them kept the same verdict on losing important content, and 81 kept the same verdict on being an empty shell. The three that changed show a big swing in how much of the text sits in the server HTML: site-0642 (Next.js): text in server HTML 102% → 14%; site-1166 (React): text in server HTML 91% → 9%; site-1188 (Next.js): text in server HTML 13% → 94%. Two of them swung on the rendered side, which points to the page or its loading changing between the runs. In the third the server HTML itself got much thinner, and that one may be the different user agent. Either way the totals barely moved.
By framework
The framework is the first fingerprint found in the server HTML. Nuxt sites also carry Vue fingerprints and count as Nuxt. The client-side group has only 24 sites, so read its share as a direction. The label comes from the server HTML fetched in each run, so a site that changed its HTML between the runs, or was excluded in one run and compared in the other, can change its framework or drop out of a row. That is why some framework counts differ between the runs while the client-side group has 24 sites in the first run and 24 in the second.
| Framework | Sites (run 1 / 2) | Lose important content (run 1 / 2) | Empty shell (run 1 / 2) |
|---|---|---|---|
| Next.js | 47 / 49 | 17 / 17 | 5 / 5 |
| Nuxt | 12 / 13 | 1 / 1 | 1 / 1 |
| React | 13 / 11 | 7 / 7 | 5 / 5 |
| Vue | 6 / 7 | 3 / 3 | 2 / 2 |
| Angular | 5 / 6 | 3 / 4 | 3 / 3 |
| SvelteKit | 2 / 3 | 0 / 0 | 0 / 0 |
| Gatsby | 2 / 2 | 0 / 0 | 0 / 0 |
| Server rendering by default (Next.js, Nuxt, SvelteKit, Gatsby) | 63 / 67 | 18 of 63 (29%) / 18 of 67 (27%) | 6 / 6 |
| Client-side by default (React, Vue, Angular) | 24 / 24 | 13 of 24 (54%) / 14 of 24 (58%) | 10 / 10 |
My own site
I ran the same parser on the cometweb.io homepage, which is built on SvelteKit. The server HTML has the same title, H1, meta description and canonical as the rendered page, and 54 of 54 internal links. About 81% of the rendered text is already in the server HTML. I diffed the two versions, and the remaining text comes only from the interactive Insight demo and the cookie banner. The numbers are in own-check.json.
What this data can't tell you
- I only checked homepages. Product pages, search results and filters often render differently.
- Cookie banners and personalised blocks add text to the rendered version, so a site near the "half the text" line may be fine for its main content. The empty-shell count is the more robust number.
- Fingerprints find only sites that leave a trace in their HTML. A framework hidden behind a custom build is missing from the sample.
- Everything was fetched from one connection in Poland. Some sites serve bots, other countries or mobile devices a different page, and the user agent differed between the runs.
- This shows what a crawler without JavaScript receives. It doesn't show what Google indexed or what any AI assistant answered; for that the article points to Google's documentation and to published crawler tests.
Files
sites.csv: every site in the repeat with the counts for both versions and each rulesites-2026-10.csv: the same table for the first runsummary.json: the numbers from the repeat used in the articlesummary-2026-10.json: the numbers from the first runstability.json: which sites kept or changed their verdict between the runsselected.json: the 100 sites taken for renderingfetch.jsonl: response codes from the repeat fetchscreen.jsonl: the sampled sites from the first run, with response codes and framework fingerprintsscreen.py: draws the sample and fetches the server HTML (first run)select.py: picks the framework sitesrefetch.py: fetches the server HTML again for the same sites (repeat)render.mjs: renders each homepage with Playwrightcompare.py: compares both versions and writes the CSV and summaryown-check.json: the same comparison for the cometweb.io homepage
To check your own list, save the sites you want to test as selected.json in the same format, then run python3 refetch.py, node render.mjs and python3 compare.py. The raw HTML of other people's pages isn't published here, so your run fetches fresh copies.