How to Check if a Website Uses Server-Side Rendering

Quick answer: Open the page's source (Ctrl+U, or Cmd+Option+U on a Mac) and search for the main text. If the heading and body copy are in the raw HTML, the server rendered them. If you find only an empty root element and script tags, the browser builds the page. Disabling JavaScript or fetching the page with curl gives the same answer.

The rest of this post shows each check, then what the response headers add. Every number below comes from 7 live pages we fetched with curl on 5 November 2026, using a desktop Chrome user agent and following redirects.

What does server-side rendering look like from the outside?

A server-rendered page arrives as finished HTML. The first response already holds the <h1>, the paragraphs and the links, and JavaScript, if any, only adds interactivity afterwards. A client-rendered page arrives as a shell: a small document with a mount point such as <div id="root"></div> and a bundle that draws everything once it runs.

Size is the quickest tell. On 5 November 2026 the HTML for our Server-side Rendering (SSR) Checker listing weighed 122,706 bytes, while the HTML for excalidraw.com weighed 6,930 bytes. A whiteboard app cannot fit its interface into 7 KB of markup; the drawing surface is assembled in the browser.

| Page (5 November 2026) | HTML bytes | server | x-powered-by | age (seconds) | <h1> in served HTML | |---|---|---|---|---|---| | devresourc.es SSR Checker listing | 122,706 | Vercel | Next.js | 62,508 | Server-side Rendering (SSR) Checker | | devresourc.es/category/seo | 159,282 | Vercel | not sent | 0 | Top 53 SEO Resources For Developers | | devresourc.es/category/testing | 156,114 | Vercel | not sent | 0 | Top 35 Testing Resources For Developers | | excalidraw.com | 6,930 | Vercel | not sent | 45,917 | Excalidraw | | vuejs.org SSR guide | 132,044 | Netlify | not sent | 0 | Server-Side Rendering (SSR) | | nextjs.org | 262,753 | Vercel | not sent | 5,165 | The React Framework for the Web | | testdev.tools/ssr-checker | 30,464 | Netlify | not sent | 0 | SSR Checker |

Note the Excalidraw row: its shell still carries an <h1>. A heading alone does not prove server rendering, so search for body text as well, a sentence from the second paragraph or a product name deep in the page.

How do you check with View Source (and why the DevTools Elements panel misleads)?

Press Ctrl+U in Chrome, Edge or Firefox, or type view-source: before the URL. That window shows the HTML exactly as the server sent it. Press Ctrl+F and search for a sentence you can see on the page. Found means server-rendered; not found means the browser added it.

Do not use the Elements panel for this. It shows the live DOM after every script has run, so a client-rendered app looks just as complete there as a server-rendered one. Our ranking of the best browsers for developers covers the DevTools differences, but for this test all of them mislead in the same way.

What happens when you disable JavaScript?

Turn JavaScript off and reload. In Chrome or Edge, open DevTools, press Ctrl+Shift+P (Cmd+Shift+P on a Mac), type "Disable JavaScript" and reload with DevTools still open. In Firefox, set javascript.enabled to false in about:config.

A server-rendered page still shows its text, images and links; menus and forms may stop working. A client-rendered page goes blank or shows a "please enable JavaScript" notice. This check is visual and quick, but it hides partial cases: a page can render its header on the server and fetch the main list in the browser, which you only spot by reading what is missing.

How do you check with curl?

curl fetches the HTML without running any script, which is exactly what a crawler without a rendering step sees. Search the response for text you expect:

curl -sL --compressed https://devresourc.es/category/seo | grep -o '<h1[^>]*>[^<]*'

On 5 November 2026 that returned the heading "Top 53 SEO Resources For Developers", so the category page is rendered before it leaves the server. Swap the <h1> pattern for a sentence from the body to rule out the Excalidraw case above.

To see the headers as well, add -D - to print them before the body, or use -I for headers alone. Two flags matter: --compressed decodes gzip or Brotli so grep can read the text, and -L follows redirects. testdev.tools/ssr-checker, for example, answered with one redirect to the same path with a trailing slash before returning 200. Some sites serve different HTML to unknown clients, so if the result looks odd, repeat it with a browser user agent via -A.

Which tools check SSR for you?

Two dedicated checkers answered on 5 November 2026:

1. Server-side Rendering (SSR) Checker. Our listing for it, linked above, has the screenshot, summary and link. It runs the source-versus-rendered comparison for you, which helps when you need to check many URLs. Verdict: the fastest route when you do not want a terminal.
2. testdev.tools SSR Checker. A single-purpose page at testdev.tools/ssr-checker, served from Netlify, that returned 200 after one redirect. Verdict: fine for a one-off check; it explains little about the result.

curl and View Source remain the reference: they show the evidence itself rather than a verdict. For crawl, indexing and rendering audits beyond one page, our SEO category held 53 resources and our testing category held 35, per each page's heading on 5 November 2026. Our data is thin on one point: we have not counted how many of those resources test rendering specifically, so treat the categories as a starting list.

How do you tell SSR from static generation and hydration?

From the HTML alone you cannot: a page rendered per request and a page built once at deploy time both arrive complete. The response headers narrow it down.

• age counts the seconds a shared cache has held the response. Our listing page came back with age: 62508, a copy about 17.4 hours old, and nextjs.org with 5,165 seconds (about 86 minutes). Both were served from a CDN cache, not rendered for that request. The category pages returned age: 0, which is consistent with a fresh render or a cache miss. Fetch twice: if the value climbs and the body is identical, you are reading a cached or statically generated page.
• x-powered-by names the framework only when the site leaves it on. Our listing sent Next.js; nextjs.org, the framework's own site, sent nothing. A missing header proves nothing.
• Framework cache headers such as x-nextjs-cache appear in some guides, but none of the 7 responses carried one, nextjs.org included, so do not rely on them.
• server names the host (Vercel or Netlify in every row above), not the rendering mode.

Hydration is the step where scripts attach to server-rendered HTML and make it interactive. A page that passes the View Source test and still ships a large script bundle is server-rendered and hydrated, the default pattern for React and Vue meta-frameworks. A page that fails the test and ships the same bundle is client-rendered.

What should you check first on your own site?

Run the curl command against one URL per template: the home page, a listing or product page, an article, and a search or filter page. Grep each for a sentence from the body, not only the heading. The template that comes back empty is the one search engines and AI crawlers may be reading as a shell, and it is where a rendering change pays off first. Save the command as a shell alias: our list of developer productivity tools ranks tools by actions per day, and a check you can repeat in two seconds earns its place by that measure. Our State of Developer Tools 2026 report shows how the directory's live tools spread across its 73 categories, SEO and testing included.

FAQ

How do you test server-side rendering?

Fetch the page without running JavaScript and look for its content. curl -sL --compressed <url> followed by grep for a body sentence is the most reliable test; View Source and disabling JavaScript in the browser give the same answer visually. If the text is there, the server rendered it.

What is meant by server-side rendering in React?

React components run on the server and produce HTML, which is sent to the browser as a complete page. The browser then loads the same components and hydrates the markup so buttons and forms respond. Frameworks such as Next.js handle this for you; plain React in a browser bundle renders on the client.

How can I check which server a website is on?

Read the response headers with curl -sI <url> or the DevTools Network tab. The server header usually names the host or web server: every page we probed on 5 November 2026 reported Vercel or Netlify. Some sites remove or rename the header, so it is a hint, not proof.

How do I check the status of a website?

curl -sI <url> prints the HTTP status on its first line; add -L to follow redirects to the final answer. A 200 means the page served, a 301 or 308 is a redirect, and 4xx or 5xx codes are errors. testdev.tools/ssr-checker, for example, redirected once and then returned 200.