SEO

Raw HTML versus rendered HTML checker

Missing SSR content, metadata changes and hydration/rendering differences

10 checks a day, 5 an hour · results are kept for 24 hours, then deleted

How to use it

  1. Enter the address you want to checkType or paste it into the field marked "Address to check", including the https:// at the front. Pick a page whose content you believe is built by JavaScript — a listing, a product grid, anything that appears after a spinner.
  2. Press Check and wait a few secondsThe request runs from our server rather than from your browser, so your cache, your extensions and your login session cannot affect the answer. That is the point of it: you are seeing what an anonymous visitor sees.
  3. Compare the two columnsThe left is the HTML the server sent. The right is the page after a real browser ran its JavaScript. Anything present only on the right exists solely because scripts built it.
  4. Look at what differs, not at how muchA large difference is normal on a modern site and is not itself a problem. What matters is WHICH things differ: a title, a canonical, a meta description or the main body text appearing only after rendering is a real risk, because a crawler may index the page before that happens.
  5. Treat a missing right-hand column as its own findingIf rendering failed or timed out, the tool says so rather than showing you an empty comparison. A page that a browser cannot render in time is a page a crawler may not render either.
  6. Share or keep the result within 24 hoursThe result has its own link you can send to whoever needs to act on it. It is deleted 24 hours after the check ran, so save anything you need to keep — and re-run the check after a change rather than trusting an old link.

About this tool

Modern sites often build their pages in the browser: the server sends a skeleton, and JavaScript fills in the content. This tool fetches both versions — the raw HTML a non-rendering crawler sees, and the fully rendered page a browser produces — and shows you exactly what changes in between.

The gap matters because not everything renders JavaScript. Social preview bots, many crawlers, feed readers and anything reading view-source see only the raw side. If your title, description or content exists only after rendering, those consumers see a page with none of it.

Understanding the result

The verdict says how much the page depends on rendering. "Empty shell" is the important one: the raw HTML is nearly blank while the rendered page is full — the classic single-page app served without server-side rendering.

Each difference shows the raw value and the rendered value side by side, ranked by how much it matters. Robots directives and canonicals that differ between the two worlds are critical: they change what gets indexed.

Errors captured during rendering are listed because they are usually the reason content fails to appear — an uncaught exception stops the page mid-build.

Example

Input

https://example.com/

Output

This page barely depends on JavaScript
Title, description, canonical, robots: unchanged
Raw 28 words → rendered 28 words · rendered in 1.8 s

Limitations

  • The page is rendered once, in a clean session with no cookies and no login. Content shown only to signed-in visitors or after interaction is not measured.
  • Raw and rendered text are measured differently (markup text versus what a browser displays), so small word-count differences are treated as noise, not as JavaScript activity.
  • A page that renders differently by geography or device may differ from what this check measures — it renders from our servers at a desktop viewport.

Questions

Google renders JavaScript — so why does the raw HTML matter?

Google renders, eventually, at its own pace — but the first wave of crawling reads raw HTML, and most other consumers (Bing to a lesser degree, social preview bots, LLM crawlers, RSS readers) render little or nothing. Server-side rendering means every consumer sees the same page.

What should I do about an "empty shell" verdict?

Add server-side rendering (Nuxt, Next and friends do this natively), prerender at build time, or use dynamic rendering for crawlers. Which is right depends on your stack — but the goal is the same: the content should exist in the HTML the server sends.

JavaScript adds a noindex to my page. Is that a problem?

Almost always, and possibly a serious one: Google renders pages and will honour a rendered noindex, so a script that injects one is quietly removing the page from search. The reverse — removing a noindex by script — is equally unreliable, because crawlers may act on the raw directive first.

Last updated 2026-08-16.

Related tools