Quick answer
A JavaScript SEO rendering check compares the raw HTML your server sends with the page after JavaScript runs. If the title, H1, canonical, main text or links only appear after rendering, Google indexes them later and less reliably, and most AI crawlers don't see them. Server-render those elements.
A page can look perfect in your browser and be nearly empty to a crawler. The browser runs JavaScript and builds the page; a crawler that doesn't run JavaScript sees only what the server sent. A rendering check shows you both versions side by side.
Why rendering still matters in 2026
Google renders JavaScript using an up-to-date Chrome, so it usually sees client-rendered content in the end. The catch is "in the end". Google crawls the HTML first and renders later, and when scripts fail, time out or depend on blocked resources, the rendered page can be incomplete. Pages whose core content depends on rendering are indexed more slowly and less predictably.
The bigger change is everyone else. Analysis of crawler traffic published by Vercel in late 2024 found that OpenAI's and Anthropic's crawlers fetched JavaScript files without executing them. For those crawlers, content injected by JavaScript doesn't exist, which matters if you want to be cited in ChatGPT or Claude answers. Social preview bots behave similarly, which is why links from single-page apps often share with blank previews.
How to run a rendering check in 5 minutes
- Open the page, then view the page source (Ctrl+U or Cmd+Option+U), which shows the raw HTML the server sent.
- Search the source for the page's
<title>, the H1 text,rel="canonical"and a sentence from the main content. - Open DevTools, disable JavaScript in the settings, reload, and look at what's left on screen.
- In Search Console, run URL Inspection, then view the crawled page's HTML and screenshot to see Google's rendered version.
- Note anything present in the rendered version but missing from the raw HTML; those are your rendering dependencies.
For a quick command-line version, curl -s https://example.com/page | grep -i "<h1" shows whether the H1 exists without JavaScript.
What a JavaScript SEO rendering check should look for
| Element | If missing from raw HTML | Risk | Fix |
|---|---|---|---|
<title> | Generic or framework default title | High | Set it server-side per route |
| H1 and main text | Page looks empty to non-rendering crawlers | High | Server-render or prerender content |
| Canonical tag | Google may choose its own canonical | High | Output in server HTML |
| Internal links | Crawlers can't discover linked pages | High | Use real <a href> elements in HTML |
| Structured data | Not read by non-rendering crawlers | Medium | Include JSON-LD in server HTML |
| Images | Lazy images may never load for bots | Medium | Use native loading="lazy" with real src |
Also check for a noindex that differs between versions. Some apps ship noindex in the HTML and remove it with JavaScript, expecting Google to see the rendered version. Google may not render a page it has been told not to index.
Fixes by approach
- Server-side rendering or static generation (Next.js, Nuxt, SvelteKit, Astro): the most reliable fix. Content is in the HTML on first request. The Next.js SEO checklist covers the App Router specifics.
- Prerendering for single-page apps that can't move to SSR: generate static HTML snapshots of key routes at build time.
- Hybrid: server-render the content that needs to be indexed (title, H1, main text, links) and keep interactive parts client-side.
Avoid dynamic rendering (serving bots a different version based on user agent). Google describes it as a workaround rather than a long-term solution, and it is easy to get wrong.
Seotific audits each page in both forms: the raw HTML and a real-browser render. When the title, H1, canonical or main text only appears after JavaScript, it flags a high-priority rendering issue and names the element. For the other technical checks, see the technical SEO audit checklist, part of the SEO audit checklist.
Frequently asked questions
Can Google index JavaScript content?
Yes. Google renders pages with a recent version of Chrome and indexes content added by JavaScript. Rendering happens after the initial crawl and can fail if scripts error or resources are blocked, so content in the raw HTML is indexed faster and more reliably.
Do AI crawlers render JavaScript?
Most don't. Published analyses of crawler traffic showed OpenAI's and Anthropic's crawlers fetching JavaScript files without running them. If you want AI search products to read your content, put it in the HTML the server sends.
How do I check if my content is rendered by JavaScript?
View the page source and search for a sentence from your main content. If it isn't there but appears on the page, it's added by JavaScript. Disabling JavaScript in DevTools and reloading gives the same answer visually.
Is client-side rendering bad for SEO?
Not automatically, but it adds risk. Google usually handles it; many other crawlers don't. For pages that need to rank or be cited, server-rendering the title, headings, main text and links removes the risk at little cost.
What is the difference between raw and rendered HTML?
Raw HTML is what the server sends before any scripts run. Rendered HTML is the page after the browser executes JavaScript and builds the final DOM. Search engines that render see the second; crawlers that don't see only the first.
Check your own page
Seotific audits a URL against the keyword it should rank for and lists the fixes in order of impact. Free plan, no card.
Run a free audit