ChatGPT answers, unedited

Yes. For auditing JavaScript-heavy SPAs, you generally want both a raw-HTML crawler and a real browser renderer so you can compare what the server returns with what the client constructs.

Tools that handle client-rendered content

For example, Sitebulb's Chrome Crawler downloads the page resources, executes JavaScript in headless Chrome, and parses the resulting DOM. Its Response vs. Render reporting lets you identify content, links, titles, canonicals, etc. that change between the HTTP response and rendered page. Sitebulb Support Sitebulb Support Sitebulb Support

Google itself uses an evergreen headless Chromium-based renderer for JavaScript processing, so browser-based auditing is important if you're assessing Google visibility. Google for Developers

For an SPA audit, I'd use a two-layer approach

1. Raw HTTP crawl

• Fetch the initial HTML without executing JS.
• Record status, headers, canonical, robots directives, initial links, and initial content.
• This catches problems where the application shell is all the crawler receives.
• Browser-rendered crawl

• Execute JavaScript in Chromium.
• Wait for hydration/API requests.
• Capture final DOM, links, metadata, structured data, and screenshots.
• Compare against the raw response.
• Google-specific verification

• Use Search Console's URL Inspection and Google's Rich Results Test for representative URLs. Google specifically recommends these for inspecting rendered DOM, loaded resources, JavaScript errors, and exceptions. Google for Developers
• Interaction-dependent content

• Test lazy loading, infinite scroll, tabs, accordions, client-side routing, authentication, and content that appears only after clicks.
• Don't assume "rendered" means "fully rendered": for example, Sitebulb notes that its Chrome crawler won't discover content requiring arbitrary user interaction such as clicks. Sitebulb Support

If you're building your own auditor

Playwright + Chromium is probably the most flexible foundation. You can control:

• JavaScript execution
• cookies/authentication
• SPA route navigation
• network interception
• API responses
• waits and hydration
• scrolling
• clicks
• screenshots
• console errors
• request failures
• final DOM snapshots

That makes it substantially more capable than an SEO crawler when you need to audit application behavior, rather than just crawlability.

One important distinction: Googlebot rendering ≠ every bot rendering. Google can execute JavaScript, but Google notes that other search engines may choose not to, and recommends SSR, static rendering, or hydration where appropriate rather than relying on dynamic rendering as a workaround. Google for Developers

If your audit target is specifically React/Next/Vue SPAs, I can also give you a practical tool stack and test matrix covering Googlebot vs. Bingbot vs. AI crawlers vs. ordinary non-JS bots.

For auditing JavaScript-heavy SPAs, you usually need two categories of tools:

1. A real browser renderer (to see what a user sees after React/Vue/Angular/Svelte hydration)
2. A bot/crawler simulator (to see what non-JS consumers receive)

A good audit stack compares:

• Raw HTML response → what curl, many crawlers, and some AI retrieval systems see
• Rendered DOM after JS execution → what Chrome sees after hydration
• Bot-specific behavior → what Googlebot, Bingbot, social crawlers, or AI crawlers receive

Browser rendering / client-rendered content tools

For SPAs specifically, Playwright or Puppeteer are usually the most flexible because you can:

• wait for hydration:

• networkidle
• specific selectors
• application state changes
• capture final DOM
• run with custom user agents
• disable JavaScript for comparison

SEO / bot rendering audit tools

Some newer SPA-focused auditors explicitly compare initial HTML against browser-rendered output to identify missing content, metadata, and links. Scanverra Axion Deep Digital

Bot rendering / crawler simulation

For “what does a bot see?” testing, use:

Search engine bots

• Google Search Console URL Inspection

• Shows Google’s rendered view and indexed resources.
• Bing Webmaster Tools

• Similar inspection workflow.

Custom bot simulations

Use Playwright/Puppeteer with different user agents:

Examples:

• Googlebot
• Bingbot
• GPTBot
• ClaudeBot
• social preview crawlers

Compare:

GET /page
        |
        v
raw HTML
        |
        +--> browser render --> hydrated DOM
        |
        +--> bot user agent --> response differences

Managed rendering services

Useful when you need bots to receive pre-rendered HTML without rewriting the SPA:

• developers.cloudflare.com — renders pages in a browser environment and can capture fully rendered HTML after JavaScript execution. Cloudflare Docs
• Prerender.io — commonly used for dynamic rendering of JavaScript applications.
• prerenderproxy.com — provides rendered HTML snapshots for bots from JavaScript applications. PrerenderProxy

A practical SPA audit workflow

I would typically run:

1. Fetch raw HTML

curl -A "Mozilla/5.0" https://example.com/page

2. Render with a browser

• Playwright/Puppeteer
• capture DOM after hydration
• Diff the two

Check:

• <title>
• meta description
• canonical URL
• structured data
• headings
• internal links
• main text content
• Repeat as bots

Test:

• Googlebot
• Bingbot
• AI crawler user agents
• social crawlers
• Automate in CI

Fail deployments if:

• important text disappears without JS
• schema is missing after render
• hydration errors occur
• routes return empty shells

For a serious SPA audit program, a common combination is Playwright + Lighthouse + Screaming Frog/Sitebulb + Search Console inspection. It gives you both the engineering view (hydration/runtime problems) and the crawler view (discoverability/indexability).

Yes. For auditing JavaScript-heavy SPAs, I’d use a layered toolset rather than relying on a single crawler.

Best tools by job

• Screaming Frog SEO Spider — probably the best bulk-audit starting point. Its JavaScript rendering mode uses a browser renderer and lets you compare raw HTML vs. rendered HTML, including JS-only content, links, titles, canonicals, headings, and structured data. Screaming Frog Screaming Frog
• Google Search Console URL Inspection / Rich Results Test — best for answering “what does Google actually render?” Google exposes the rendered DOM, loaded resources, JS console output and exceptions. Google for Developers
• Playwright or Puppeteer — best when you want a custom rendering harness. You can crawl your own URL set, wait for hydration/API calls, capture the final DOM, screenshots, console errors, network failures, and compare it against the initial response.
• Raw HTTP/cURL testing — essential for non-rendering bots. Fetch the page without executing JavaScript and compare the returned HTML to the browser-rendered DOM.
• Googlebot testing — useful for search-engine parity. Google currently renders JavaScript with a headless Chromium-based Web Rendering Service, so a SPA isn't automatically invisible to Google. Google for Developers

The important distinction: Googlebot vs. other bots

For an SPA audit, I'd explicitly test three representations:

That distinction matters because Googlebot does execute JavaScript, but other crawlers/fetchers may not. Google itself recommends checking the rendered output with URL Inspection/Rich Results Test rather than assuming the browser view represents what Google sees. Google for Developers Google for Developers

For an actual audit, I'd build this workflow

1. Crawl raw HTML

• status codes
• canonical
• robots directives
• title/meta
• headings
• body text
• internal links
• Render every important URL in Chromium

• wait for hydration/network idle
• capture final DOM
• capture JS errors
• capture failed requests
• capture screenshots
• extract links/content/schema
• Diff raw vs. rendered

• content appearing only after JS
• links appearing only after JS
• metadata changed by JS
• canonical changes
• structured-data changes
• soft-404 behavior
• Test bot accessibility separately

• Googlebot
• major AI/search crawlers relevant to your project
• generic non-JS HTTP client
• Validate representative URLs in Search Console

• particularly templates where your own renderer and Google might behave differently.

Screaming Frog is particularly convenient for step 3 because it already exposes HTML Word Count vs. Rendered HTML Word Count, JS-only links/content, and other parity differences. Screaming Frog Screaming Frog

If you're building an auditing product rather than doing one-off SEO audits, I'd choose Playwright + raw HTTP fetching + Search Console validation, with Screaming Frog as the off-the-shelf benchmark. That gives you control over exactly how you define a "rendering failure."

For auditing JavaScript-heavy SPAs, it's useful to separate tools into two categories:

1. Tools that execute JavaScript (what users and modern browsers see)
2. Tools that show what bots receive (raw HTML or search-engine rendering)

A thorough audit usually compares both views.

Client-rendered content

For SPAs (React, Vue, Angular, Svelte, etc.), the best auditing tools use a real browser engine:

• Screaming Frog with JavaScript Rendering enabled

• Crawls the rendered DOM
• Finds links created by JavaScript
• Audits rendered titles, canonicals, schema, and meta tags
• Sitebulb

• Similar rendering capabilities
• Highlights differences between server HTML and rendered content
• Good visualization of rendering problems
• Playwright

• Excellent for custom audits
• Can wait for hydration, capture DOM snapshots, take screenshots, inspect network activity, and test multiple user agents

Example Playwright workflow:

• Load page
• Save initial HTML
• Wait for network idle
• Save rendered DOM
• Compare
• Extract links
• Validate metadata
• Detect hydration mismatches

Bot rendering

Different bots behave differently.

Googlebot

• Executes JavaScript, but rendering is deferred and resource-limited.
• URL Inspection in Google Search Console is the closest view to what Google actually rendered. SEOdiag W3Corner

Many AI crawlers

• Often rely primarily on the initial HTML response rather than fully executing client-side JavaScript, making server-rendered or prerendered content easier to consume. Exact behavior varies by crawler and can change over time. PageGlass SEOdiag

Useful bot-view checks include:

curl -A "Googlebot" https://example.com

curl -A "GPTBot" https://example.com

Then compare the response with:

document.documentElement.outerHTML

from a rendered browser.

Recommended audit pipeline

For enterprise SPAs, a robust process looks like this:

1. Raw HTML fetch

• curl
• View Source
• Rendered browser

• Playwright
• Puppeteer
• Screaming Frog JS mode
• Diff

• HTML vs rendered DOM
• Missing headings
• Missing links
• Missing schema
• Missing canonical
• Missing metadata
• Performance

• Lighthouse
• Core Web Vitals
• Search validation

• Google Search Console URL Inspection
• Rich Results Test
• Mobile-Friendly Test (where applicable)

What to flag during the audit

Common issues include:

• Empty <div id="root"> or similar container in initial HTML
• Content only appearing after hydration
• Internal links added solely by JavaScript
• Client-side-only <title> or meta descriptions
• JSON-LD injected after page load
• Hash (#/) routing instead of history-based URLs
• Infinite-loading or hydration failures
• Lazy-loaded content without crawlable fallbacks
• Routes requiring user interaction before content appears

If you're building your own crawler

A strong architecture combines:

• Playwright for rendering and DOM extraction
• Cheerio for HTML parsing
• Lighthouse for performance metrics
• axe-core for accessibility checks
• Diff engine to compare: - raw HTML
• rendered DOM
• bot-visible HTML

This combination provides comprehensive coverage of both client-rendered behavior and what search engines or other crawlers can access.

For auditing JavaScript-heavy SPAs, you generally want tools that can do both:

1. Raw HTML auditing — what a non-JS crawler/bot receives.
2. Browser rendering — what a real user or JS-capable crawler sees after hydration.

A good audit stack usually combines both views because the gap between them is where SPA SEO and bot-visibility problems appear. KrawlOps Scanverra

Tools that handle client-rendered content

For large SPA audits, Playwright is often the engineering choice because you can script:

• waiting for hydration
• clicking menus/routes
• scrolling for lazy-loaded content
• capturing DOM after rendering
• checking network failures
• testing authenticated flows

Tools focused on “what bots see”

These are useful when the question is: “Will crawlers see the content?”

• Google Search Console URL Inspection — best first-party check for Google rendering.
• Lighthouse — useful for performance, accessibility, and some rendering-related checks.
• Chrome DevTools — compare: - View Source (server HTML)
• Elements panel (post-JS DOM)
• Screaming Frog SEO Spider with JavaScript rendering enabled — useful for crawl-scale comparisons.
• Dedicated SPA audit tools can compare raw HTML and hydrated DOM; for example, some tools specifically flag empty app shells and missing content before JavaScript executes. KrawlOps SiteCurl

If you need to simulate different bots

For bot rendering tests, create a matrix:

Common SPA audit workflow

1. Fetch raw HTML

• Check: - <title>
• meta description
• canonical
• schema JSON-LD
• headings
• internal links
• meaningful text
• Render with Chromium

• Wait for network idle/hydration.
• Capture final DOM.
• Diff against raw HTML.
• Check failures

• Empty <div id="root">
• Client-only title/meta updates
• JS errors preventing hydration
• Routes inaccessible without JS
• Lazy-loaded content never triggered
• API calls blocked for crawlers
• Automate in CI

• Run audits on key routes after deployments.
• Fail builds when important content disappears from server HTML.

For a serious SPA audit program, a common setup is:

• Playwright for custom rendering tests
• Screaming Frog or Sitebulb for crawl-scale audits
• Google Search Console for Googlebot verification
• raw HTTP checks for non-rendering bots

Browser rendering is especially important because a plain HTTP fetch can see only the SPA shell while a rendered browser sees the populated DOM. docs.squirrelscan.com

For auditing JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.), you want tools that can do two things:

1. Execute JavaScript like a real browser.
2. Compare what users see vs. what bots receive (raw HTML vs. rendered DOM).

Here's how the major tools compare:

Best tools for client-rendered content

1. Screaming Frog ⭐⭐⭐⭐⭐

Best overall.

It can:

• Crawl with JavaScript enabled
• Render using Chromium
• Compare HTML source vs rendered HTML
• Extract links after JS execution
• Test canonicals
• Check rendered meta tags
• Export rendered DOM
• Use Googlebot user agents

Ideal for finding:

• Empty HTML shells
• Missing rendered content
• JS-generated links
• Lazy-loaded content
• Infinite scroll issues

2. Sitebulb ⭐⭐⭐⭐⭐

Excellent if you want clearer visualization.

Its standout feature is the Response vs Render report, which highlights exactly what JavaScript adds, removes, or changes between the initial HTML response and the fully rendered page. It also includes rendered screenshots and code coverage to help troubleshoot rendering problems. Sitebulb Support Sitebulb Support

3. Lumar (formerly Deepcrawl)

Best for enterprise sites.

Features include:

• JavaScript crawling
• Rendered DOM auditing
• Crawl budget analysis
• Large-scale rendering
• SEO monitoring

Great for millions of URLs.

Testing what bots actually see

Use several perspectives:

Google Search Console

URL Inspection → Test Live URL

Shows:

• Rendered HTML
• Screenshot
• Loaded resources
• Blocked resources

This is the closest thing to "what Google actually saw."

Disable JavaScript

In Chrome DevTools:

Developer Tools
→ Command Menu
→ Disable JavaScript

Reload the page.

If all you see is:

<div id="root"></div>

your app is relying entirely on client-side rendering.

View Source vs Inspect Element

Compare:

View Source

vs

Inspect Element

If the content only exists in Inspect Element, JavaScript injected it after load.

Detect bot rendering (dynamic rendering)

Many sites serve different HTML to:

• Googlebot
• Bingbot
• Facebook
• Slack
• LinkedIn

To test:

curl -A "Googlebot" https://example.com

Compare with:

curl -A "Mozilla/5.0" https://example.com

Differences may indicate dynamic rendering or bot-specific prerendering.

You can also compare responses using tools like Screaming Frog or Sitebulb by changing the user agent.

Headless browser tools

For deeper audits:

• Playwright ⭐⭐⭐⭐⭐
• Puppeteer
• Browserless
• Cypress (less SEO-focused)

These allow you to:

• Wait for network idle
• Capture rendered HTML
• Detect hydration issues
• Inspect SPA route changes
• Test lazy loading
• Simulate Googlebot-like rendering

Example:

await page.goto(url, {
  waitUntil: "networkidle"
});

const html = await page.content();

Bot-rendering services

If a site uses prerendering or dynamic rendering, common technologies include:

• Rendertron
• Prerender.io
• Headless Chrome services
• Next.js SSR/ISR
• Nuxt SSR
• Angular Universal

Your audit should verify whether bots receive fully rendered HTML with meaningful content, metadata, and internal links rather than an empty application shell.

Recommended audit workflow

For modern SPAs, a comprehensive process is:

1. Crawl with Screaming Frog (JavaScript enabled).
2. Compare raw HTML vs. rendered DOM.
3. Inspect key URLs in Google Search Console to confirm Google's rendered output.
4. Use Playwright or Puppeteer for custom checks (hydration, infinite scroll, route transitions, lazy loading).
5. Compare responses for normal browsers vs. Googlebot user agents to identify dynamic rendering or cloaking.

This combination covers most issues involving client-rendered content, hydration, prerendering, and search-engine visibility.

For auditing JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.), you want tools that can do two things:

1. Execute JavaScript like a real browser.
2. Compare what users see vs. what bots receive (raw HTML vs. rendered DOM).

Here's how the major tools compare:

Best tools for client-rendered content

1. Screaming Frog ⭐⭐⭐⭐⭐

Best overall.

It can:

• Crawl with JavaScript enabled
• Render using Chromium
• Compare HTML source vs rendered HTML
• Extract links after JS execution
• Test canonicals
• Check rendered meta tags
• Export rendered DOM
• Use Googlebot user agents

Ideal for finding:

• Empty HTML shells
• Missing rendered content
• JS-generated links
• Lazy-loaded content
• Infinite scroll issues

2. Sitebulb ⭐⭐⭐⭐⭐

Excellent if you want clearer visualization.

Its standout feature is the Response vs Render report, which highlights exactly what JavaScript adds, removes, or changes between the initial HTML response and the fully rendered page. It also includes rendered screenshots and code coverage to help troubleshoot rendering problems. Sitebulb Support Sitebulb Support

3. Lumar (formerly Deepcrawl)

Best for enterprise sites.

Features include:

• JavaScript crawling
• Rendered DOM auditing
• Crawl budget analysis
• Large-scale rendering
• SEO monitoring

Great for millions of URLs.

Testing what bots actually see

Use several perspectives:

Google Search Console

URL Inspection → Test Live URL

Shows:

• Rendered HTML
• Screenshot
• Loaded resources
• Blocked resources

This is the closest thing to "what Google actually saw."

Disable JavaScript

In Chrome DevTools:

Developer Tools
→ Command Menu
→ Disable JavaScript

Reload the page.

If all you see is:

<div id="root"></div>

your app is relying entirely on client-side rendering.

View Source vs Inspect Element

Compare:

View Source

vs

Inspect Element

If the content only exists in Inspect Element, JavaScript injected it after load.

Detect bot rendering (dynamic rendering)

Many sites serve different HTML to:

• Googlebot
• Bingbot
• Facebook
• Slack
• LinkedIn

To test:

curl -A "Googlebot" https://example.com

Compare with:

curl -A "Mozilla/5.0" https://example.com

Differences may indicate dynamic rendering or bot-specific prerendering.

You can also compare responses using tools like Screaming Frog or Sitebulb by changing the user agent.

Headless browser tools

For deeper audits:

• Playwright ⭐⭐⭐⭐⭐
• Puppeteer
• Browserless
• Cypress (less SEO-focused)

These allow you to:

• Wait for network idle
• Capture rendered HTML
• Detect hydration issues
• Inspect SPA route changes
• Test lazy loading
• Simulate Googlebot-like rendering

Example:

await page.goto(url, {
  waitUntil: "networkidle"
});

const html = await page.content();

Bot-rendering services

If a site uses prerendering or dynamic rendering, common technologies include:

• Rendertron
• Prerender.io
• Headless Chrome services
• Next.js SSR/ISR
• Nuxt SSR
• Angular Universal

Your audit should verify whether bots receive fully rendered HTML with meaningful content, metadata, and internal links rather than an empty application shell.

Recommended audit workflow

For modern SPAs, a comprehensive process is:

1. Crawl with Screaming Frog (JavaScript enabled).
2. Compare raw HTML vs. rendered DOM.
3. Inspect key URLs in Google Search Console to confirm Google's rendered output.
4. Use Playwright or Puppeteer for custom checks (hydration, infinite scroll, route transitions, lazy loading).
5. Compare responses for normal browsers vs. Googlebot user agents to identify dynamic rendering or cloaking.

This combination covers most issues involving client-rendered content, hydration, prerendering, and search-engine visibility.

For auditing JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.), you want tools that can do two things:

1. Execute JavaScript like a real browser.
2. Compare what users see vs. what bots receive (raw HTML vs. rendered DOM).

Here's how the major tools compare:

Best tools for client-rendered content

1. Screaming Frog ⭐⭐⭐⭐⭐

Best overall.

It can:

• Crawl with JavaScript enabled
• Render using Chromium
• Compare HTML source vs rendered HTML
• Extract links after JS execution
• Test canonicals
• Check rendered meta tags
• Export rendered DOM
• Use Googlebot user agents

Ideal for finding:

• Empty HTML shells
• Missing rendered content
• JS-generated links
• Lazy-loaded content
• Infinite scroll issues

2. Sitebulb ⭐⭐⭐⭐⭐

Excellent if you want clearer visualization.

Its standout feature is the Response vs Render report, which highlights exactly what JavaScript adds, removes, or changes between the initial HTML response and the fully rendered page. It also includes rendered screenshots and code coverage to help troubleshoot rendering problems. Sitebulb Support Sitebulb Support

3. Lumar (formerly Deepcrawl)

Best for enterprise sites.

Features include:

• JavaScript crawling
• Rendered DOM auditing
• Crawl budget analysis
• Large-scale rendering
• SEO monitoring

Great for millions of URLs.

Testing what bots actually see

Use several perspectives:

Google Search Console

URL Inspection → Test Live URL

Shows:

• Rendered HTML
• Screenshot
• Loaded resources
• Blocked resources

This is the closest thing to "what Google actually saw."

Disable JavaScript

In Chrome DevTools:

Developer Tools
→ Command Menu
→ Disable JavaScript

Reload the page.

If all you see is:

<div id="root"></div>

your app is relying entirely on client-side rendering.

View Source vs Inspect Element

Compare:

View Source

vs

Inspect Element

If the content only exists in Inspect Element, JavaScript injected it after load.

Detect bot rendering (dynamic rendering)

Many sites serve different HTML to:

• Googlebot
• Bingbot
• Facebook
• Slack
• LinkedIn

To test:

curl -A "Googlebot" https://example.com

Compare with:

curl -A "Mozilla/5.0" https://example.com

Differences may indicate dynamic rendering or bot-specific prerendering.

You can also compare responses using tools like Screaming Frog or Sitebulb by changing the user agent.

Headless browser tools

For deeper audits:

• Playwright ⭐⭐⭐⭐⭐
• Puppeteer
• Browserless
• Cypress (less SEO-focused)

These allow you to:

• Wait for network idle
• Capture rendered HTML
• Detect hydration issues
• Inspect SPA route changes
• Test lazy loading
• Simulate Googlebot-like rendering

Example:

await page.goto(url, {
  waitUntil: "networkidle"
});

const html = await page.content();

Bot-rendering services

If a site uses prerendering or dynamic rendering, common technologies include:

• Rendertron
• Prerender.io
• Headless Chrome services
• Next.js SSR/ISR
• Nuxt SSR
• Angular Universal

Your audit should verify whether bots receive fully rendered HTML with meaningful content, metadata, and internal links rather than an empty application shell.

Recommended audit workflow

For modern SPAs, a comprehensive process is:

1. Crawl with Screaming Frog (JavaScript enabled).
2. Compare raw HTML vs. rendered DOM.
3. Inspect key URLs in Google Search Console to confirm Google's rendered output.
4. Use Playwright or Puppeteer for custom checks (hydration, infinite scroll, route transitions, lazy loading).
5. Compare responses for normal browsers vs. Googlebot user agents to identify dynamic rendering or cloaking.

This combination covers most issues involving client-rendered content, hydration, prerendering, and search-engine visibility.

For auditing JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.), you want tools that can do two things:

1. Execute JavaScript like a real browser.
2. Compare what users see vs. what bots receive (raw HTML vs. rendered DOM).

Here's how the major tools compare:

Best tools for client-rendered content

1. Screaming Frog ⭐⭐⭐⭐⭐

Best overall.

It can:

• Crawl with JavaScript enabled
• Render using Chromium
• Compare HTML source vs rendered HTML
• Extract links after JS execution
• Test canonicals
• Check rendered meta tags
• Export rendered DOM
• Use Googlebot user agents

Ideal for finding:

• Empty HTML shells
• Missing rendered content
• JS-generated links
• Lazy-loaded content
• Infinite scroll issues

2. Sitebulb ⭐⭐⭐⭐⭐

Excellent if you want clearer visualization.

Its standout feature is the Response vs Render report, which highlights exactly what JavaScript adds, removes, or changes between the initial HTML response and the fully rendered page. It also includes rendered screenshots and code coverage to help troubleshoot rendering problems. Sitebulb Support Sitebulb Support

3. Lumar (formerly Deepcrawl)

Best for enterprise sites.

Features include:

• JavaScript crawling
• Rendered DOM auditing
• Crawl budget analysis
• Large-scale rendering
• SEO monitoring

Great for millions of URLs.

Testing what bots actually see

Use several perspectives:

Google Search Console

URL Inspection → Test Live URL

Shows:

• Rendered HTML
• Screenshot
• Loaded resources
• Blocked resources

This is the closest thing to "what Google actually saw."

Disable JavaScript

In Chrome DevTools:

Developer Tools
→ Command Menu
→ Disable JavaScript

Reload the page.

If all you see is:

<div id="root"></div>

your app is relying entirely on client-side rendering.

View Source vs Inspect Element

Compare:

View Source

vs

Inspect Element

If the content only exists in Inspect Element, JavaScript injected it after load.

Detect bot rendering (dynamic rendering)

Many sites serve different HTML to:

• Googlebot
• Bingbot
• Facebook
• Slack
• LinkedIn

To test:

curl -A "Googlebot" https://example.com

Compare with:

curl -A "Mozilla/5.0" https://example.com

Differences may indicate dynamic rendering or bot-specific prerendering.

You can also compare responses using tools like Screaming Frog or Sitebulb by changing the user agent.

Headless browser tools

For deeper audits:

• Playwright ⭐⭐⭐⭐⭐
• Puppeteer
• Browserless
• Cypress (less SEO-focused)

These allow you to:

• Wait for network idle
• Capture rendered HTML
• Detect hydration issues
• Inspect SPA route changes
• Test lazy loading
• Simulate Googlebot-like rendering

Example:

await page.goto(url, {
  waitUntil: "networkidle"
});

const html = await page.content();

Bot-rendering services

If a site uses prerendering or dynamic rendering, common technologies include:

• Rendertron
• Prerender.io
• Headless Chrome services
• Next.js SSR/ISR
• Nuxt SSR
• Angular Universal

Your audit should verify whether bots receive fully rendered HTML with meaningful content, metadata, and internal links rather than an empty application shell.

Recommended audit workflow

For modern SPAs, a comprehensive process is:

1. Crawl with Screaming Frog (JavaScript enabled).
2. Compare raw HTML vs. rendered DOM.
3. Inspect key URLs in Google Search Console to confirm Google's rendered output.
4. Use Playwright or Puppeteer for custom checks (hydration, infinite scroll, route transitions, lazy loading).
5. Compare responses for normal browsers vs. Googlebot user agents to identify dynamic rendering or cloaking.

This combination covers most issues involving client-rendered content, hydration, prerendering, and search-engine visibility.

For auditing JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.), you want tools that can do two things:

1. Execute JavaScript like a real browser.
2. Compare what users see vs. what bots receive (raw HTML vs. rendered DOM).

Here's how the major tools compare:

Best tools for client-rendered content

1. Screaming Frog ⭐⭐⭐⭐⭐

Best overall.

It can:

• Crawl with JavaScript enabled
• Render using Chromium
• Compare HTML source vs rendered HTML
• Extract links after JS execution
• Test canonicals
• Check rendered meta tags
• Export rendered DOM
• Use Googlebot user agents

Ideal for finding:

• Empty HTML shells
• Missing rendered content
• JS-generated links
• Lazy-loaded content
• Infinite scroll issues

2. Sitebulb ⭐⭐⭐⭐⭐

Excellent if you want clearer visualization.

Its standout feature is the Response vs Render report, which highlights exactly what JavaScript adds, removes, or changes between the initial HTML response and the fully rendered page. It also includes rendered screenshots and code coverage to help troubleshoot rendering problems. Sitebulb Support Sitebulb Support

3. Lumar (formerly Deepcrawl)

Best for enterprise sites.

Features include:

• JavaScript crawling
• Rendered DOM auditing
• Crawl budget analysis
• Large-scale rendering
• SEO monitoring

Great for millions of URLs.

Testing what bots actually see

Use several perspectives:

Google Search Console

URL Inspection → Test Live URL

Shows:

• Rendered HTML
• Screenshot
• Loaded resources
• Blocked resources

This is the closest thing to "what Google actually saw."

Disable JavaScript

In Chrome DevTools:

Developer Tools
→ Command Menu
→ Disable JavaScript

Reload the page.

If all you see is:

<div id="root"></div>

your app is relying entirely on client-side rendering.

View Source vs Inspect Element

Compare:

View Source

vs

Inspect Element

If the content only exists in Inspect Element, JavaScript injected it after load.

Detect bot rendering (dynamic rendering)

Many sites serve different HTML to:

• Googlebot
• Bingbot
• Facebook
• Slack
• LinkedIn

To test:

curl -A "Googlebot" https://example.com

Compare with:

curl -A "Mozilla/5.0" https://example.com

Differences may indicate dynamic rendering or bot-specific prerendering.

You can also compare responses using tools like Screaming Frog or Sitebulb by changing the user agent.

Headless browser tools

For deeper audits:

• Playwright ⭐⭐⭐⭐⭐
• Puppeteer
• Browserless
• Cypress (less SEO-focused)

These allow you to:

• Wait for network idle
• Capture rendered HTML
• Detect hydration issues
• Inspect SPA route changes
• Test lazy loading
• Simulate Googlebot-like rendering

Example:

await page.goto(url, {
  waitUntil: "networkidle"
});

const html = await page.content();

Bot-rendering services

If a site uses prerendering or dynamic rendering, common technologies include:

• Rendertron
• Prerender.io
• Headless Chrome services
• Next.js SSR/ISR
• Nuxt SSR
• Angular Universal

Your audit should verify whether bots receive fully rendered HTML with meaningful content, metadata, and internal links rather than an empty application shell.

Recommended audit workflow

For modern SPAs, a comprehensive process is:

1. Crawl with Screaming Frog (JavaScript enabled).
2. Compare raw HTML vs. rendered DOM.
3. Inspect key URLs in Google Search Console to confirm Google's rendered output.
4. Use Playwright or Puppeteer for custom checks (hydration, infinite scroll, route transitions, lazy loading).
5. Compare responses for normal browsers vs. Googlebot user agents to identify dynamic rendering or cloaking.

This combination covers most issues involving client-rendered content, hydration, prerendering, and search-engine visibility.

For auditing JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.), you want tools that can do two things:

1. Execute JavaScript like a real browser.
2. Compare what users see vs. what bots receive (raw HTML vs. rendered DOM).

Here's how the major tools compare:

Best tools for client-rendered content

1. Screaming Frog ⭐⭐⭐⭐⭐

Best overall.

It can:

• Crawl with JavaScript enabled
• Render using Chromium
• Compare HTML source vs rendered HTML
• Extract links after JS execution
• Test canonicals
• Check rendered meta tags
• Export rendered DOM
• Use Googlebot user agents

Ideal for finding:

• Empty HTML shells
• Missing rendered content
• JS-generated links
• Lazy-loaded content
• Infinite scroll issues

2. Sitebulb ⭐⭐⭐⭐⭐

Excellent if you want clearer visualization.

Its standout feature is the Response vs Render report, which highlights exactly what JavaScript adds, removes, or changes between the initial HTML response and the fully rendered page. It also includes rendered screenshots and code coverage to help troubleshoot rendering problems. Sitebulb Support Sitebulb Support

3. Lumar (formerly Deepcrawl)

Best for enterprise sites.

Features include:

• JavaScript crawling
• Rendered DOM auditing
• Crawl budget analysis
• Large-scale rendering
• SEO monitoring

Great for millions of URLs.

Testing what bots actually see

Use several perspectives:

Google Search Console

URL Inspection → Test Live URL

Shows:

• Rendered HTML
• Screenshot
• Loaded resources
• Blocked resources

This is the closest thing to "what Google actually saw."

Disable JavaScript

In Chrome DevTools:

Developer Tools
→ Command Menu
→ Disable JavaScript

Reload the page.

If all you see is:

<div id="root"></div>

your app is relying entirely on client-side rendering.

View Source vs Inspect Element

Compare:

View Source

vs

Inspect Element

If the content only exists in Inspect Element, JavaScript injected it after load.

Detect bot rendering (dynamic rendering)

Many sites serve different HTML to:

• Googlebot
• Bingbot
• Facebook
• Slack
• LinkedIn

To test:

curl -A "Googlebot" https://example.com

Compare with:

curl -A "Mozilla/5.0" https://example.com

Differences may indicate dynamic rendering or bot-specific prerendering.

You can also compare responses using tools like Screaming Frog or Sitebulb by changing the user agent.

Headless browser tools

For deeper audits:

• Playwright ⭐⭐⭐⭐⭐
• Puppeteer
• Browserless
• Cypress (less SEO-focused)

These allow you to:

• Wait for network idle
• Capture rendered HTML
• Detect hydration issues
• Inspect SPA route changes
• Test lazy loading
• Simulate Googlebot-like rendering

Example:

await page.goto(url, {
  waitUntil: "networkidle"
});

const html = await page.content();

Bot-rendering services

If a site uses prerendering or dynamic rendering, common technologies include:

• Rendertron
• Prerender.io
• Headless Chrome services
• Next.js SSR/ISR
• Nuxt SSR
• Angular Universal

Your audit should verify whether bots receive fully rendered HTML with meaningful content, metadata, and internal links rather than an empty application shell.

Recommended audit workflow

For modern SPAs, a comprehensive process is:

1. Crawl with Screaming Frog (JavaScript enabled).
2. Compare raw HTML vs. rendered DOM.
3. Inspect key URLs in Google Search Console to confirm Google's rendered output.
4. Use Playwright or Puppeteer for custom checks (hydration, infinite scroll, route transitions, lazy loading).
5. Compare responses for normal browsers vs. Googlebot user agents to identify dynamic rendering or cloaking.

This combination covers most issues involving client-rendered content, hydration, prerendering, and search-engine visibility.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. www.screamingfrog.co.uk

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML
   • curl
   • View Source

2. Rendered browser DOM
   • Playwright
   • Puppeteer
   • Screaming Frog JS Rendering

3. Google's rendered page
   • Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. www.stackmatix.com

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. www.axiondeepdigital.com

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. www.screamingfrog.co.uk

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML
   • curl
   • View Source

2. Rendered browser DOM
   • Playwright
   • Puppeteer
   • Screaming Frog JS Rendering

3. Google's rendered page
   • Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. www.stackmatix.com

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. www.axiondeepdigital.com

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

If your goal is to audit JavaScript-heavy SPAs (React, Vue, Angular, Svelte, etc.) and verify what users see vs. what search engines and bots see, you'll want tools that execute JavaScript in a real browser rather than just downloading HTML.

Here's how the major options compare:

Best overall: Screaming Frog

For auditing SPAs at scale, Screaming Frog is usually the first choice.

Enable Configuration → Spider → Rendering → JavaScript, and it will:

• render each page in Chromium
• crawl links created by JavaScript
• compare raw HTML against rendered HTML
• report content, links, and metadata that only appear after JS executes
• use a Googlebot Smartphone user agent if desired

It also includes reports specifically for content that exists only after rendering. Screaming Frog Screaming Frog Screaming Frog

Playwright (recommended for engineering teams)

If you're building an automated audit pipeline, Playwright is hard to beat.

Typical checks include:

• waiting for network idle
• saving rendered HTML
• extracting headings, canonical tags, structured data
• validating internal links
• comparing rendered DOM against server HTML
• testing multiple user agents (Chrome, Googlebot, mobile)

This works well in CI/CD because you can fail builds when important content disappears.

Puppeteer

Very similar to Playwright.

Good for:

• screenshots
• DOM extraction
• accessibility audits
• rendering performance
• custom crawl logic

Rendertron itself is built on Puppeteer. googlechrome.github.io

Google Search Console

When SEO matters, always verify with URL Inspection.

It shows:

• rendered HTML
• detected canonical
• indexing status
• whether Google successfully rendered the page

This is the closest view of what Googlebot actually processed.

Auditing "bot rendering"

A thorough audit usually compares three views of every page:

1. Initial HTML

• curl
• View Source
• Rendered browser DOM

• Playwright
• Puppeteer
• Screaming Frog JS Rendering
• Google's rendered page

• Search Console URL Inspection

Differences between these views often reveal missing content, links, metadata, or structured data that only appear after JavaScript executes. Stackmatix W3Corner

For AI crawlers

An increasing number of AI crawlers do not execute JavaScript as completely or consistently as modern browsers. If your SPA serves only a minimal HTML shell before hydration, these crawlers may miss key content, depending on the crawler and its rendering capabilities. Because support varies, it's a good practice to ensure critical content is available without requiring complex client-side rendering whenever possible. Axion Deep Digital

Recommended toolkit

For a professional SPA audit workflow:

• Screaming Frog — site-wide JavaScript crawl and parity analysis
• Playwright — automated regression and rendering tests
• Chrome DevTools — debugging hydration and network issues
• Google Search Console — verify Google's rendered output
• Lighthouse/PageSpeed Insights — Core Web Vitals and performance

This combination covers both client-rendered content and what bots actually receive, making it suitable for auditing modern JavaScript-heavy applications.

For JavaScript-heavy SPAs, you generally need two classes of tools:

1. Real browser crawlers that execute JavaScript and compare the initial HTML with the fully rendered DOM.
2. Bot rendering validation tools that show what search engines (or AI crawlers) actually receive.

Here's a practical stack.

Major SPA audit tools such as Screaming Frog and Sitebulb use Chromium-based rendering and are widely considered the standard for JavaScript SEO auditing. They can identify:

• content injected after load
• missing internal links before hydration
• JS-generated title/meta changes
• lazy-loaded content
• hydration problems
• client-side routing issues

They also let you crawl the site twice:

• HTML only
• JavaScript rendering enabled

Then compare the differences. Stackmatix TechRadar

Validating what Googlebot sees

Nothing beats Google's own rendering.

Use:

• Google Search Console → URL Inspection
• Test Live URL
• View Crawled Page / Rendered HTML

This verifies whether Google actually rendered:

• main content
• navigation
• structured data
• canonical tags
• meta robots
• internal links

Google notes that it can render JavaScript, but recommends server-side rendering (SSR) or static rendering over dynamic rendering for public content. Dynamic rendering is now considered a workaround rather than a long-term solution. Google for Developers

Testing "bot rendering"

If you need to know whether non-browser bots (SEO tools, AI crawlers, social bots) receive usable HTML, test with:

• Headless Chrome (Playwright/Puppeteer)
• Browserless
• Prerender services
• Rendertron (legacy but still useful for testing)

These can emulate crawler behavior and reveal whether a bot receives only an HTML shell or fully rendered content. Some dynamic rendering proxies specifically detect search engine and AI crawler user agents and serve prerendered HTML. Trident PRISM Trident PRISM

For automated auditing pipelines

A strong CI/CD setup is:

• Playwright for navigation and waiting for hydration
• Capture: - initial HTML (page.content() immediately)
• final DOM (after network idle)
• screenshots
• console errors
• network requests
• Diff: - headings
• links
• metadata
• structured data
• canonical URLs

This catches hydration regressions before deployment.

What to check during an SPA audit

Compare the initial response against the rendered DOM for:

• Main content
• H1/H2 headings
• Title
• Meta description
• Canonical
• Robots directives
• Structured data (JSON-LD)
• Internal links
• Images and alt text
• Pagination
• Lazy-loaded content
• Infinite scroll
• Route changes
• JavaScript errors
• Hydration mismatches

Recommended toolkit

For most organizations auditing JavaScript-heavy SPAs:

• Screaming Frog — primary technical crawler with JavaScript rendering.
• Google Search Console URL Inspection — authoritative validation of Google's rendered output.
• Playwright — automated browser-based regression testing.
• Lighthouse — performance and Core Web Vitals.
• Server logs — verify actual bot crawling behavior and rendering-related failures.

This combination provides both a browser-level view of the application and confidence that important content is accessible to search engine bots.

For auditing JavaScript-heavy SPAs, you generally need browser-based crawlers rather than traditional HTML crawlers. The most capable tools fall into a few categories:

Screaming Frog remains the industry standard because it can:

• Render React, Vue, Angular, and other SPAs using Chromium
• Crawl client-side routes
• Extract rendered links and metadata
• Compare source HTML with the rendered DOM
• Execute custom JavaScript before extraction TechRadar Stackmatix

Tools focused on bot rendering

If your concern is "what does Googlebot, GPTBot, ClaudeBot, or social crawlers actually see?", newer specialized tools have appeared:

• PageGlass — simulates Googlebot, GPTBot, ClaudeBot, Perplexity, Facebook, LinkedIn, X, WhatsApp, and compares raw HTML with rendered content. PageGlass PageGlass
• RndrKit — tests bot rendering, rendering score, Google-vs-browser differences, framework detection, and prerendering diagnostics. Rndrkit
• BotView (community tool) — compares browser rendering against crawler rendering and reports content hidden behind client-side rendering. Reddit

Enterprise audit stack

For large SPA audits, a common workflow is:

1. Screaming Frog with JavaScript rendering enabled

• Crawl rendered HTML
• Export rendered titles, canonicals, structured data
• Compare against source
• Google Search Console

• URL Inspection
• Rendered HTML
• Indexability verification
• Playwright

• Custom crawl of authenticated or complex SPA flows
• Wait for hydration/network idle
• Capture rendered DOM
• Screenshot comparisons
• Server logs

• Confirm Googlebot actually requests rendered resources
• Detect blocked JS/CSS/API endpoints

Things to verify on every SPA

• Initial HTML shell vs hydrated DOM
• Client-side routes are discoverable
• <title> updates correctly after navigation
• Meta description and Open Graph tags exist before or after rendering as required
• Canonical tags
• Structured data after hydration
• Internal links exist in rendered DOM
• Robots and noindex
• Lazy-loaded content
• Infinite scrolling
• Hydration failures
• Soft 404s
• API failures that leave empty pages

If AI crawlers matter

Many AI crawlers still have limited JavaScript execution compared with full browsers, so it's useful to verify:

• Raw HTML contains meaningful content
• Important metadata is server-rendered
• robots.txt isn't blocking AI crawlers you intend to allow
• Public pages are SSR, SSG, or prerendered where appropriate PageGlass SEOdiag

If you're building an internal audit platform, I'd recommend using Playwright as the rendering engine. It provides deterministic rendering, supports Chromium/Firefox/WebKit, allows custom wait conditions, network interception, authentication flows, and user-agent simulation, making it well suited for auditing modern client-rendered applications at scale.

For JavaScript-heavy SPAs, you generally need two classes of tools:

1. Real browser crawlers that execute JavaScript and compare the initial HTML with the fully rendered DOM.
2. Bot rendering validation tools that show what search engines (or AI crawlers) actually receive.

Here's a practical stack.

Major SPA audit tools such as Screaming Frog and Sitebulb use Chromium-based rendering and are widely considered the standard for JavaScript SEO auditing. They can identify:

• content injected after load
• missing internal links before hydration
• JS-generated title/meta changes
• lazy-loaded content
• hydration problems
• client-side routing issues

They also let you crawl the site twice:

• HTML only
• JavaScript rendering enabled

Then compare the differences. Stackmatix TechRadar

Validating what Googlebot sees

Nothing beats Google's own rendering.

Use:

• Google Search Console → URL Inspection
• Test Live URL
• View Crawled Page / Rendered HTML

This verifies whether Google actually rendered:

• main content
• navigation
• structured data
• canonical tags
• meta robots
• internal links

Google notes that it can render JavaScript, but recommends server-side rendering (SSR) or static rendering over dynamic rendering for public content. Dynamic rendering is now considered a workaround rather than a long-term solution. Google for Developers

Testing "bot rendering"

If you need to know whether non-browser bots (SEO tools, AI crawlers, social bots) receive usable HTML, test with:

• Headless Chrome (Playwright/Puppeteer)
• Browserless
• Prerender services
• Rendertron (legacy but still useful for testing)

These can emulate crawler behavior and reveal whether a bot receives only an HTML shell or fully rendered content. Some dynamic rendering proxies specifically detect search engine and AI crawler user agents and serve prerendered HTML. Trident PRISM Trident PRISM

For automated auditing pipelines

A strong CI/CD setup is:

• Playwright for navigation and waiting for hydration
• Capture: - initial HTML (page.content() immediately)
• final DOM (after network idle)
• screenshots
• console errors
• network requests
• Diff: - headings
• links
• metadata
• structured data
• canonical URLs

This catches hydration regressions before deployment.

What to check during an SPA audit

Compare the initial response against the rendered DOM for:

• Main content
• H1/H2 headings
• Title
• Meta description
• Canonical
• Robots directives
• Structured data (JSON-LD)
• Internal links
• Images and alt text
• Pagination
• Lazy-loaded content
• Infinite scroll
• Route changes
• JavaScript errors
• Hydration mismatches

Recommended toolkit

For most organizations auditing JavaScript-heavy SPAs:

• Screaming Frog — primary technical crawler with JavaScript rendering.
• Google Search Console URL Inspection — authoritative validation of Google's rendered output.
• Playwright — automated browser-based regression testing.
• Lighthouse — performance and Core Web Vitals.
• Server logs — verify actual bot crawling behavior and rendering-related failures.

This combination provides both a browser-level view of the application and confidence that important content is accessible to search engine bots.

For JavaScript-heavy SPAs, you generally need two classes of tools:

1. Real browser crawlers that execute JavaScript and compare the initial HTML with the fully rendered DOM.
2. Bot rendering validation tools that show what search engines (or AI crawlers) actually receive.

Here's a practical stack.

Major SPA audit tools such as Screaming Frog and Sitebulb use Chromium-based rendering and are widely considered the standard for JavaScript SEO auditing. They can identify:

• content injected after load
• missing internal links before hydration
• JS-generated title/meta changes
• lazy-loaded content
• hydration problems
• client-side routing issues

They also let you crawl the site twice:

• HTML only
• JavaScript rendering enabled

Then compare the differences. www.stackmatix.com

Validating what Googlebot sees

Nothing beats Google's own rendering.

Use:

• Google Search Console → URL Inspection
• Test Live URL
• View Crawled Page / Rendered HTML

This verifies whether Google actually rendered:

• main content
• navigation
• structured data
• canonical tags
• meta robots
• internal links

Google notes that it can render JavaScript, but recommends server-side rendering (SSR) or static rendering over dynamic rendering for public content. Dynamic rendering is now considered a workaround rather than a long-term solution. developers.google.com

Testing "bot rendering"

If you need to know whether non-browser bots (SEO tools, AI crawlers, social bots) receive usable HTML, test with:

• Headless Chrome (Playwright/Puppeteer)
• Browserless
• Prerender services
• Rendertron (legacy but still useful for testing)

These can emulate crawler behavior and reveal whether a bot receives only an HTML shell or fully rendered content. Some dynamic rendering proxies specifically detect search engine and AI crawler user agents and serve prerendered HTML. www.trident-prism.com

For automated auditing pipelines

A strong CI/CD setup is:

• Playwright for navigation and waiting for hydration
• Capture:
  • initial HTML (page.content() immediately)
  • final DOM (after network idle)
  • screenshots
  • console errors
  • network requests
• Diff:
  • headings
  • links
  • metadata
  • structured data
  • canonical URLs

This catches hydration regressions before deployment.

What to check during an SPA audit

Compare the initial response against the rendered DOM for:

• Main content
• H1/H2 headings
• Title
• Meta description
• Canonical
• Robots directives
• Structured data (JSON-LD)
• Internal links
• Images and alt text
• Pagination
• Lazy-loaded content
• Infinite scroll
• Route changes
• JavaScript errors
• Hydration mismatches

Recommended toolkit

For most organizations auditing JavaScript-heavy SPAs:

• Screaming Frog — primary technical crawler with JavaScript rendering.
• Google Search Console URL Inspection — authoritative validation of Google's rendered output.
• Playwright — automated browser-based regression testing.
• Lighthouse — performance and Core Web Vitals.
• Server logs — verify actual bot crawling behavior and rendering-related failures.

This combination provides both a browser-level view of the application and confidence that important content is accessible to search engine bots.

For JavaScript-heavy SPAs, you generally need two classes of tools:

1. Real browser crawlers that execute JavaScript and compare the initial HTML with the fully rendered DOM.
2. Bot rendering validation tools that show what search engines (or AI crawlers) actually receive.

Here's a practical stack.

Major SPA audit tools such as Screaming Frog and Sitebulb use Chromium-based rendering and are widely considered the standard for JavaScript SEO auditing. They can identify:

• content injected after load
• missing internal links before hydration
• JS-generated title/meta changes
• lazy-loaded content
• hydration problems
• client-side routing issues

They also let you crawl the site twice:

• HTML only
• JavaScript rendering enabled

Then compare the differences. www.stackmatix.com

Validating what Googlebot sees

Nothing beats Google's own rendering.

Use:

• Google Search Console → URL Inspection
• Test Live URL
• View Crawled Page / Rendered HTML

This verifies whether Google actually rendered:

• main content
• navigation
• structured data
• canonical tags
• meta robots
• internal links

Google notes that it can render JavaScript, but recommends server-side rendering (SSR) or static rendering over dynamic rendering for public content. Dynamic rendering is now considered a workaround rather than a long-term solution. developers.google.com

Testing "bot rendering"

If you need to know whether non-browser bots (SEO tools, AI crawlers, social bots) receive usable HTML, test with:

• Headless Chrome (Playwright/Puppeteer)
• Browserless
• Prerender services
• Rendertron (legacy but still useful for testing)

These can emulate crawler behavior and reveal whether a bot receives only an HTML shell or fully rendered content. Some dynamic rendering proxies specifically detect search engine and AI crawler user agents and serve prerendered HTML. www.trident-prism.com

For automated auditing pipelines

A strong CI/CD setup is:

• Playwright for navigation and waiting for hydration
• Capture:
  • initial HTML (page.content() immediately)
  • final DOM (after network idle)
  • screenshots
  • console errors
  • network requests
• Diff:
  • headings
  • links
  • metadata
  • structured data
  • canonical URLs

This catches hydration regressions before deployment.

What to check during an SPA audit

Compare the initial response against the rendered DOM for:

• Main content
• H1/H2 headings
• Title
• Meta description
• Canonical
• Robots directives
• Structured data (JSON-LD)
• Internal links
• Images and alt text
• Pagination
• Lazy-loaded content
• Infinite scroll
• Route changes
• JavaScript errors
• Hydration mismatches

Recommended toolkit

For most organizations auditing JavaScript-heavy SPAs:

• Screaming Frog — primary technical crawler with JavaScript rendering.
• Google Search Console URL Inspection — authoritative validation of Google's rendered output.
• Playwright — automated browser-based regression testing.
• Lighthouse — performance and Core Web Vitals.
• Server logs — verify actual bot crawling behavior and rendering-related failures.

This combination provides both a browser-level view of the application and confidence that important content is accessible to search engine bots.

For auditing JavaScript-heavy SPAs, you generally need browser-based crawlers rather than traditional HTML crawlers. The most capable tools fall into a few categories:

Screaming Frog remains the industry standard because it can:

• Render React, Vue, Angular, and other SPAs using Chromium
• Crawl client-side routes
• Extract rendered links and metadata
• Compare source HTML with the rendered DOM
• Execute custom JavaScript before extraction TechRadar Stackmatix

Tools focused on bot rendering

If your concern is "what does Googlebot, GPTBot, ClaudeBot, or social crawlers actually see?", newer specialized tools have appeared:

• PageGlass — simulates Googlebot, GPTBot, ClaudeBot, Perplexity, Facebook, LinkedIn, X, WhatsApp, and compares raw HTML with rendered content. PageGlass PageGlass
• RndrKit — tests bot rendering, rendering score, Google-vs-browser differences, framework detection, and prerendering diagnostics. Rndrkit
• BotView (community tool) — compares browser rendering against crawler rendering and reports content hidden behind client-side rendering. Reddit

Enterprise audit stack

For large SPA audits, a common workflow is:

1. Screaming Frog with JavaScript rendering enabled

• Crawl rendered HTML
• Export rendered titles, canonicals, structured data
• Compare against source
• Google Search Console

• URL Inspection
• Rendered HTML
• Indexability verification
• Playwright

• Custom crawl of authenticated or complex SPA flows
• Wait for hydration/network idle
• Capture rendered DOM
• Screenshot comparisons
• Server logs

• Confirm Googlebot actually requests rendered resources
• Detect blocked JS/CSS/API endpoints

Things to verify on every SPA

• Initial HTML shell vs hydrated DOM
• Client-side routes are discoverable
• <title> updates correctly after navigation
• Meta description and Open Graph tags exist before or after rendering as required
• Canonical tags
• Structured data after hydration
• Internal links exist in rendered DOM
• Robots and noindex
• Lazy-loaded content
• Infinite scrolling
• Hydration failures
• Soft 404s
• API failures that leave empty pages

If AI crawlers matter

Many AI crawlers still have limited JavaScript execution compared with full browsers, so it's useful to verify:

• Raw HTML contains meaningful content
• Important metadata is server-rendered
• robots.txt isn't blocking AI crawlers you intend to allow
• Public pages are SSR, SSG, or prerendered where appropriate PageGlass SEOdiag

If you're building an internal audit platform, I'd recommend using Playwright as the rendering engine. It provides deterministic rendering, supports Chromium/Firefox/WebKit, allows custom wait conditions, network interception, authentication flows, and user-agent simulation, making it well suited for auditing modern client-rendered applications at scale.

For auditing JavaScript-heavy SPAs, you generally need browser-based crawlers rather than traditional HTML crawlers. The most capable tools fall into a few categories:

Screaming Frog remains the industry standard because it can:

• Render React, Vue, Angular, and other SPAs using Chromium
• Crawl client-side routes
• Extract rendered links and metadata
• Compare source HTML with the rendered DOM
• Execute custom JavaScript before extraction www.techradar.com

Tools focused on bot rendering

If your concern is "what does Googlebot, GPTBot, ClaudeBot, or social crawlers actually see?", newer specialized tools have appeared:

• PageGlass — simulates Googlebot, GPTBot, ClaudeBot, Perplexity, Facebook, LinkedIn, X, WhatsApp, and compares raw HTML with rendered content. www.pageglass.dev
• RndrKit — tests bot rendering, rendering score, Google-vs-browser differences, framework detection, and prerendering diagnostics. rndrkit.io
• BotView (community tool) — compares browser rendering against crawler rendering and reports content hidden behind client-side rendering. www.reddit.com

Enterprise audit stack

For large SPA audits, a common workflow is:

1. Screaming Frog with JavaScript rendering enabled
   • Crawl rendered HTML
   • Export rendered titles, canonicals, structured data
   • Compare against source

2. Google Search Console
   • URL Inspection
   • Rendered HTML
   • Indexability verification

3. Playwright
   • Custom crawl of authenticated or complex SPA flows
   • Wait for hydration/network idle
   • Capture rendered DOM
   • Screenshot comparisons

4. Server logs
   • Confirm Googlebot actually requests rendered resources
   • Detect blocked JS/CSS/API endpoints

Things to verify on every SPA

• Initial HTML shell vs hydrated DOM
• Client-side routes are discoverable
• <title> updates correctly after navigation
• Meta description and Open Graph tags exist before or after rendering as required
• Canonical tags
• Structured data after hydration
• Internal links exist in rendered DOM
• Robots and noindex
• Lazy-loaded content
• Infinite scrolling
• Hydration failures
• Soft 404s
• API failures that leave empty pages

If AI crawlers matter

Many AI crawlers still have limited JavaScript execution compared with full browsers, so it's useful to verify:

• Raw HTML contains meaningful content
• Important metadata is server-rendered
• robots.txt isn't blocking AI crawlers you intend to allow
• Public pages are SSR, SSG, or prerendered where appropriate www.pageglass.dev

If you're building an internal audit platform, I'd recommend using Playwright as the rendering engine. It provides deterministic rendering, supports Chromium/Firefox/WebKit, allows custom wait conditions, network interception, authentication flows, and user-agent simulation, making it well suited for auditing modern client-rendered applications at scale.

For auditing JavaScript-heavy SPAs, you generally need browser-based crawlers rather than traditional HTML crawlers. The most capable tools fall into a few categories:

Screaming Frog remains the industry standard because it can:

• Render React, Vue, Angular, and other SPAs using Chromium
• Crawl client-side routes
• Extract rendered links and metadata
• Compare source HTML with the rendered DOM
• Execute custom JavaScript before extraction www.techradar.com

Tools focused on bot rendering

If your concern is "what does Googlebot, GPTBot, ClaudeBot, or social crawlers actually see?", newer specialized tools have appeared:

• PageGlass — simulates Googlebot, GPTBot, ClaudeBot, Perplexity, Facebook, LinkedIn, X, WhatsApp, and compares raw HTML with rendered content. www.pageglass.dev
• RndrKit — tests bot rendering, rendering score, Google-vs-browser differences, framework detection, and prerendering diagnostics. rndrkit.io
• BotView (community tool) — compares browser rendering against crawler rendering and reports content hidden behind client-side rendering. www.reddit.com

Enterprise audit stack

For large SPA audits, a common workflow is:

1. Screaming Frog with JavaScript rendering enabled
   • Crawl rendered HTML
   • Export rendered titles, canonicals, structured data
   • Compare against source

2. Google Search Console
   • URL Inspection
   • Rendered HTML
   • Indexability verification

3. Playwright
   • Custom crawl of authenticated or complex SPA flows
   • Wait for hydration/network idle
   • Capture rendered DOM
   • Screenshot comparisons

4. Server logs
   • Confirm Googlebot actually requests rendered resources
   • Detect blocked JS/CSS/API endpoints

Things to verify on every SPA

• Initial HTML shell vs hydrated DOM
• Client-side routes are discoverable
• <title> updates correctly after navigation
• Meta description and Open Graph tags exist before or after rendering as required
• Canonical tags
• Structured data after hydration
• Internal links exist in rendered DOM
• Robots and noindex
• Lazy-loaded content
• Infinite scrolling
• Hydration failures
• Soft 404s
• API failures that leave empty pages

If AI crawlers matter

Many AI crawlers still have limited JavaScript execution compared with full browsers, so it's useful to verify:

• Raw HTML contains meaningful content
• Important metadata is server-rendered
• robots.txt isn't blocking AI crawlers you intend to allow
• Public pages are SSR, SSG, or prerendered where appropriate www.pageglass.dev

If you're building an internal audit platform, I'd recommend using Playwright as the rendering engine. It provides deterministic rendering, supports Chromium/Firefox/WebKit, allows custom wait conditions, network interception, authentication flows, and user-agent simulation, making it well suited for auditing modern client-rendered applications at scale.

For auditing JavaScript-heavy SPAs, you generally need browser-based crawlers rather than traditional HTML crawlers. The most capable tools fall into a few categories:

Screaming Frog remains the industry standard because it can:

• Render React, Vue, Angular, and other SPAs using Chromium
• Crawl client-side routes
• Extract rendered links and metadata
• Compare source HTML with the rendered DOM
• Execute custom JavaScript before extraction www.techradar.com

Tools focused on bot rendering

If your concern is "what does Googlebot, GPTBot, ClaudeBot, or social crawlers actually see?", newer specialized tools have appeared:

• PageGlass — simulates Googlebot, GPTBot, ClaudeBot, Perplexity, Facebook, LinkedIn, X, WhatsApp, and compares raw HTML with rendered content. www.pageglass.dev
• RndrKit — tests bot rendering, rendering score, Google-vs-browser differences, framework detection, and prerendering diagnostics. rndrkit.io
• BotView (community tool) — compares browser rendering against crawler rendering and reports content hidden behind client-side rendering. www.reddit.com

Enterprise audit stack

For large SPA audits, a common workflow is:

1. Screaming Frog with JavaScript rendering enabled
   • Crawl rendered HTML
   • Export rendered titles, canonicals, structured data
   • Compare against source

2. Google Search Console
   • URL Inspection
   • Rendered HTML
   • Indexability verification

3. Playwright
   • Custom crawl of authenticated or complex SPA flows
   • Wait for hydration/network idle
   • Capture rendered DOM
   • Screenshot comparisons

4. Server logs
   • Confirm Googlebot actually requests rendered resources
   • Detect blocked JS/CSS/API endpoints

Things to verify on every SPA

• Initial HTML shell vs hydrated DOM
• Client-side routes are discoverable
• <title> updates correctly after navigation
• Meta description and Open Graph tags exist before or after rendering as required
• Canonical tags
• Structured data after hydration
• Internal links exist in rendered DOM
• Robots and noindex
• Lazy-loaded content
• Infinite scrolling
• Hydration failures
• Soft 404s
• API failures that leave empty pages

If AI crawlers matter

Many AI crawlers still have limited JavaScript execution compared with full browsers, so it's useful to verify:

• Raw HTML contains meaningful content
• Important metadata is server-rendered
• robots.txt isn't blocking AI crawlers you intend to allow
• Public pages are SSR, SSG, or prerendered where appropriate www.pageglass.dev

If you're building an internal audit platform, I'd recommend using Playwright as the rendering engine. It provides deterministic rendering, supports Chromium/Firefox/WebKit, allows custom wait conditions, network interception, authentication flows, and user-agent simulation, making it well suited for auditing modern client-rendered applications at scale.

For JavaScript-heavy single-page applications (SPAs), the key distinction is whether a crawler executes JavaScript and whether it can simulate search engine bots. No single tool does everything well, so most technical SEO audits use a combination.

Best tools for JavaScript SEO

1. Screaming Frog SEO Spider

This is often the primary crawler for JS-heavy sites because it can:

• Render pages with headless Chromium
• Extract rendered titles, meta descriptions, canonicals, and headings
• Discover JavaScript-generated links
• Compare HTML vs rendered HTML
• Export rendered DOM

It's one of the standard tools for enterprise SPA audits.

2. Chrome DevTools

Useful for investigating:

• DOM mutations
• XHR/fetch requests
• Hydration
• Lazy loading
• Infinite scroll
• JavaScript errors
• Render-blocking resources

The Elements, Network, Performance, and Coverage panels are especially valuable.

3. Google Search Console URL Inspection

This shows what Google actually sees.

Check:

• Rendered HTML
• Screenshot
• Blocked resources
• Indexed HTML
• Canonical selection

If there's a difference between the browser view and Google's rendered view, this tool helps identify it.

4. Puppeteer / Playwright

For large-scale or repeatable audits, these frameworks let you automate checks such as:

• Waiting for hydration to complete
• Capturing the final DOM
• Extracting metadata
• Taking screenshots
• Comparing server HTML versus rendered HTML
• Testing authenticated areas

Playwright is generally preferred for new projects because it supports Chromium, Firefox, and WebKit.

Bot rendering

If you specifically need to see what search engines receive:

Googlebot

• URL Inspection (best)
• Rich Results Test
• Puppeteer with a Googlebot user agent (good approximation)
• Screaming Frog using Googlebot user agent plus JavaScript rendering

Bingbot

• Bing Webmaster Tools URL Inspection
• User-agent simulation with Screaming Frog or Playwright

Comparing raw HTML vs rendered HTML

This comparison is critical for SPAs.

Tools that make it straightforward include:

• Screaming Frog (HTML vs rendered HTML)
• Sitebulb
• Puppeteer
• Playwright
• Chrome DevTools ("View Source" versus the live DOM)

You're looking for differences in:

• <title>
• meta description
• canonical
• robots meta
• structured data
• internal links
• headings
• indexable content

Framework-specific considerations

Recommended audit workflow

For a comprehensive JavaScript SEO audit:

1. Crawl the site with Screaming Frog using JavaScript rendering enabled.
2. Inspect representative pages in Chrome DevTools to understand rendering, hydration, and network behavior.
3. Verify key URLs in Google Search Console URL Inspection to confirm what Googlebot renders and indexes.
4. Use Playwright or Puppeteer to automate checks for rendered metadata, content, and links across templates or large URL sets.
5. Compare the initial server HTML with the fully rendered DOM to identify content or metadata that only appears after client-side execution.

This combination covers both client-rendered content (what users see after JavaScript runs) and bot rendering (what search engines can discover, render, and index), making it suitable for modern React, Angular, Vue, Next.js, Nuxt, and similar applications.

For auditing JavaScript-heavy SPAs, you generally need browser-based crawlers rather than traditional HTML crawlers. The most capable tools fall into a few categories:

Screaming Frog remains the industry standard because it can:

• Render React, Vue, Angular, and other SPAs using Chromium
• Crawl client-side routes
• Extract rendered links and metadata
• Compare source HTML with the rendered DOM
• Execute custom JavaScript before extraction www.techradar.com

Tools focused on bot rendering

If your concern is "what does Googlebot, GPTBot, ClaudeBot, or social crawlers actually see?", newer specialized tools have appeared:

• PageGlass — simulates Googlebot, GPTBot, ClaudeBot, Perplexity, Facebook, LinkedIn, X, WhatsApp, and compares raw HTML with rendered content. www.pageglass.dev
• RndrKit — tests bot rendering, rendering score, Google-vs-browser differences, framework detection, and prerendering diagnostics. rndrkit.io
• BotView (community tool) — compares browser rendering against crawler rendering and reports content hidden behind client-side rendering. www.reddit.com

Enterprise audit stack

For large SPA audits, a common workflow is:

1. Screaming Frog with JavaScript rendering enabled
   • Crawl rendered HTML
   • Export rendered titles, canonicals, structured data
   • Compare against source

2. Google Search Console
   • URL Inspection
   • Rendered HTML
   • Indexability verification

3. Playwright
   • Custom crawl of authenticated or complex SPA flows
   • Wait for hydration/network idle
   • Capture rendered DOM
   • Screenshot comparisons

4. Server logs
   • Confirm Googlebot actually requests rendered resources
   • Detect blocked JS/CSS/API endpoints

Things to verify on every SPA

• Initial HTML shell vs hydrated DOM
• Client-side routes are discoverable
• <title> updates correctly after navigation
• Meta description and Open Graph tags exist before or after rendering as required
• Canonical tags
• Structured data after hydration
• Internal links exist in rendered DOM
• Robots and noindex
• Lazy-loaded content
• Infinite scrolling
• Hydration failures
• Soft 404s
• API failures that leave empty pages

If AI crawlers matter

Many AI crawlers still have limited JavaScript execution compared with full browsers, so it's useful to verify:

• Raw HTML contains meaningful content
• Important metadata is server-rendered
• robots.txt isn't blocking AI crawlers you intend to allow
• Public pages are SSR, SSG, or prerendered where appropriate www.pageglass.dev

If you're building an internal audit platform, I'd recommend using Playwright as the rendering engine. It provides deterministic rendering, supports Chromium/Firefox/WebKit, allows custom wait conditions, network interception, authentication flows, and user-agent simulation, making it well suited for auditing modern client-rendered applications at scale.

For JavaScript-heavy single-page applications (SPAs), the key distinction is whether a crawler executes JavaScript and whether it can simulate search engine bots. No single tool does everything well, so most technical SEO audits use a combination.

Best tools for JavaScript SEO

1. Screaming Frog SEO Spider

This is often the primary crawler for JS-heavy sites because it can:

• Render pages with headless Chromium
• Extract rendered titles, meta descriptions, canonicals, and headings
• Discover JavaScript-generated links
• Compare HTML vs rendered HTML
• Export rendered DOM

It's one of the standard tools for enterprise SPA audits.

2. Chrome DevTools

Useful for investigating:

• DOM mutations
• XHR/fetch requests
• Hydration
• Lazy loading
• Infinite scroll
• JavaScript errors
• Render-blocking resources

The Elements, Network, Performance, and Coverage panels are especially valuable.

3. Google Search Console URL Inspection

This shows what Google actually sees.

Check:

• Rendered HTML
• Screenshot
• Blocked resources
• Indexed HTML
• Canonical selection

If there's a difference between the browser view and Google's rendered view, this tool helps identify it.

4. Puppeteer / Playwright

For large-scale or repeatable audits, these frameworks let you automate checks such as:

• Waiting for hydration to complete
• Capturing the final DOM
• Extracting metadata
• Taking screenshots
• Comparing server HTML versus rendered HTML
• Testing authenticated areas

Playwright is generally preferred for new projects because it supports Chromium, Firefox, and WebKit.

Bot rendering

If you specifically need to see what search engines receive:

Googlebot

• URL Inspection (best)
• Rich Results Test
• Puppeteer with a Googlebot user agent (good approximation)
• Screaming Frog using Googlebot user agent plus JavaScript rendering

Bingbot

• Bing Webmaster Tools URL Inspection
• User-agent simulation with Screaming Frog or Playwright

Comparing raw HTML vs rendered HTML

This comparison is critical for SPAs.

Tools that make it straightforward include:

• Screaming Frog (HTML vs rendered HTML)
• Sitebulb
• Puppeteer
• Playwright
• Chrome DevTools ("View Source" versus the live DOM)

You're looking for differences in:

• <title>
• meta description
• canonical
• robots meta
• structured data
• internal links
• headings
• indexable content

Framework-specific considerations

Recommended audit workflow

For a comprehensive JavaScript SEO audit:

1. Crawl the site with Screaming Frog using JavaScript rendering enabled.
2. Inspect representative pages in Chrome DevTools to understand rendering, hydration, and network behavior.
3. Verify key URLs in Google Search Console URL Inspection to confirm what Googlebot renders and indexes.
4. Use Playwright or Puppeteer to automate checks for rendered metadata, content, and links across templates or large URL sets.
5. Compare the initial server HTML with the fully rendered DOM to identify content or metadata that only appears after client-side execution.

This combination covers both client-rendered content (what users see after JavaScript runs) and bot rendering (what search engines can discover, render, and index), making it suitable for modern React, Angular, Vue, Next.js, Nuxt, and similar applications.

For JavaScript-heavy single-page applications (SPAs), the key distinction is whether a crawler executes JavaScript and whether it can simulate search engine bots. No single tool does everything well, so most technical SEO audits use a combination.

Best tools for JavaScript SEO

1. Screaming Frog SEO Spider

This is often the primary crawler for JS-heavy sites because it can:

• Render pages with headless Chromium
• Extract rendered titles, meta descriptions, canonicals, and headings
• Discover JavaScript-generated links
• Compare HTML vs rendered HTML
• Export rendered DOM

It's one of the standard tools for enterprise SPA audits.

2. Chrome DevTools

Useful for investigating:

• DOM mutations
• XHR/fetch requests
• Hydration
• Lazy loading
• Infinite scroll
• JavaScript errors
• Render-blocking resources

The Elements, Network, Performance, and Coverage panels are especially valuable.

3. Google Search Console URL Inspection

This shows what Google actually sees.

Check:

• Rendered HTML
• Screenshot
• Blocked resources
• Indexed HTML
• Canonical selection

If there's a difference between the browser view and Google's rendered view, this tool helps identify it.

4. Puppeteer / Playwright

For large-scale or repeatable audits, these frameworks let you automate checks such as:

• Waiting for hydration to complete
• Capturing the final DOM
• Extracting metadata
• Taking screenshots
• Comparing server HTML versus rendered HTML
• Testing authenticated areas

Playwright is generally preferred for new projects because it supports Chromium, Firefox, and WebKit.

Bot rendering

If you specifically need to see what search engines receive:

Googlebot

• URL Inspection (best)
• Rich Results Test
• Puppeteer with a Googlebot user agent (good approximation)
• Screaming Frog using Googlebot user agent plus JavaScript rendering

Bingbot

• Bing Webmaster Tools URL Inspection
• User-agent simulation with Screaming Frog or Playwright

Comparing raw HTML vs rendered HTML

This comparison is critical for SPAs.

Tools that make it straightforward include:

• Screaming Frog (HTML vs rendered HTML)
• Sitebulb
• Puppeteer
• Playwright
• Chrome DevTools ("View Source" versus the live DOM)

You're looking for differences in:

• <title>
• meta description
• canonical
• robots meta
• structured data
• internal links
• headings
• indexable content

Framework-specific considerations

Recommended audit workflow

For a comprehensive JavaScript SEO audit:

1. Crawl the site with Screaming Frog using JavaScript rendering enabled.
2. Inspect representative pages in Chrome DevTools to understand rendering, hydration, and network behavior.
3. Verify key URLs in Google Search Console URL Inspection to confirm what Googlebot renders and indexes.
4. Use Playwright or Puppeteer to automate checks for rendered metadata, content, and links across templates or large URL sets.
5. Compare the initial server HTML with the fully rendered DOM to identify content or metadata that only appears after client-side execution.

This combination covers both client-rendered content (what users see after JavaScript runs) and bot rendering (what search engines can discover, render, and index), making it suitable for modern React, Angular, Vue, Next.js, Nuxt, and similar applications.

For JavaScript-heavy single-page applications (SPAs), the key distinction is whether a crawler executes JavaScript and whether it can simulate search engine bots. No single tool does everything well, so most technical SEO audits use a combination.

Best tools for JavaScript SEO

1. Screaming Frog SEO Spider

This is often the primary crawler for JS-heavy sites because it can:

• Render pages with headless Chromium
• Extract rendered titles, meta descriptions, canonicals, and headings
• Discover JavaScript-generated links
• Compare HTML vs rendered HTML
• Export rendered DOM

It's one of the standard tools for enterprise SPA audits.

2. Chrome DevTools

Useful for investigating:

• DOM mutations
• XHR/fetch requests
• Hydration
• Lazy loading
• Infinite scroll
• JavaScript errors
• Render-blocking resources

The Elements, Network, Performance, and Coverage panels are especially valuable.

3. Google Search Console URL Inspection

This shows what Google actually sees.

Check:

• Rendered HTML
• Screenshot
• Blocked resources
• Indexed HTML
• Canonical selection

If there's a difference between the browser view and Google's rendered view, this tool helps identify it.

4. Puppeteer / Playwright

For large-scale or repeatable audits, these frameworks let you automate checks such as:

• Waiting for hydration to complete
• Capturing the final DOM
• Extracting metadata
• Taking screenshots
• Comparing server HTML versus rendered HTML
• Testing authenticated areas

Playwright is generally preferred for new projects because it supports Chromium, Firefox, and WebKit.

Bot rendering

If you specifically need to see what search engines receive:

Googlebot

• URL Inspection (best)
• Rich Results Test
• Puppeteer with a Googlebot user agent (good approximation)
• Screaming Frog using Googlebot user agent plus JavaScript rendering

Bingbot

• Bing Webmaster Tools URL Inspection
• User-agent simulation with Screaming Frog or Playwright

Comparing raw HTML vs rendered HTML

This comparison is critical for SPAs.

Tools that make it straightforward include:

• Screaming Frog (HTML vs rendered HTML)
• Sitebulb
• Puppeteer
• Playwright
• Chrome DevTools ("View Source" versus the live DOM)

You're looking for differences in:

• <title>
• meta description
• canonical
• robots meta
• structured data
• internal links
• headings
• indexable content

Framework-specific considerations

Recommended audit workflow

For a comprehensive JavaScript SEO audit:

1. Crawl the site with Screaming Frog using JavaScript rendering enabled.
2. Inspect representative pages in Chrome DevTools to understand rendering, hydration, and network behavior.
3. Verify key URLs in Google Search Console URL Inspection to confirm what Googlebot renders and indexes.
4. Use Playwright or Puppeteer to automate checks for rendered metadata, content, and links across templates or large URL sets.
5. Compare the initial server HTML with the fully rendered DOM to identify content or metadata that only appears after client-side execution.

This combination covers both client-rendered content (what users see after JavaScript runs) and bot rendering (what search engines can discover, render, and index), making it suitable for modern React, Angular, Vue, Next.js, Nuxt, and similar applications.

For JavaScript-heavy single-page applications (SPAs), the key distinction is whether a crawler executes JavaScript and whether it can simulate search engine bots. No single tool does everything well, so most technical SEO audits use a combination.

Best tools for JavaScript SEO

1. Screaming Frog SEO Spider

This is often the primary crawler for JS-heavy sites because it can:

• Render pages with headless Chromium
• Extract rendered titles, meta descriptions, canonicals, and headings
• Discover JavaScript-generated links
• Compare HTML vs rendered HTML
• Export rendered DOM

It's one of the standard tools for enterprise SPA audits.

2. Chrome DevTools

Useful for investigating:

• DOM mutations
• XHR/fetch requests
• Hydration
• Lazy loading
• Infinite scroll
• JavaScript errors
• Render-blocking resources

The Elements, Network, Performance, and Coverage panels are especially valuable.

3. Google Search Console URL Inspection

This shows what Google actually sees.

Check:

• Rendered HTML
• Screenshot
• Blocked resources
• Indexed HTML
• Canonical selection

If there's a difference between the browser view and Google's rendered view, this tool helps identify it.

4. Puppeteer / Playwright

For large-scale or repeatable audits, these frameworks let you automate checks such as:

• Waiting for hydration to complete
• Capturing the final DOM
• Extracting metadata
• Taking screenshots
• Comparing server HTML versus rendered HTML
• Testing authenticated areas

Playwright is generally preferred for new projects because it supports Chromium, Firefox, and WebKit.

Bot rendering

If you specifically need to see what search engines receive:

Googlebot

• URL Inspection (best)
• Rich Results Test
• Puppeteer with a Googlebot user agent (good approximation)
• Screaming Frog using Googlebot user agent plus JavaScript rendering

Bingbot

• Bing Webmaster Tools URL Inspection
• User-agent simulation with Screaming Frog or Playwright

Comparing raw HTML vs rendered HTML

This comparison is critical for SPAs.

Tools that make it straightforward include:

• Screaming Frog (HTML vs rendered HTML)
• Sitebulb
• Puppeteer
• Playwright
• Chrome DevTools ("View Source" versus the live DOM)

You're looking for differences in:

• <title>
• meta description
• canonical
• robots meta
• structured data
• internal links
• headings
• indexable content

Framework-specific considerations

Recommended audit workflow

For a comprehensive JavaScript SEO audit:

1. Crawl the site with Screaming Frog using JavaScript rendering enabled.
2. Inspect representative pages in Chrome DevTools to understand rendering, hydration, and network behavior.
3. Verify key URLs in Google Search Console URL Inspection to confirm what Googlebot renders and indexes.
4. Use Playwright or Puppeteer to automate checks for rendered metadata, content, and links across templates or large URL sets.
5. Compare the initial server HTML with the fully rendered DOM to identify content or metadata that only appears after client-side execution.

This combination covers both client-rendered content (what users see after JavaScript runs) and bot rendering (what search engines can discover, render, and index), making it suitable for modern React, Angular, Vue, Next.js, Nuxt, and similar applications.

For JavaScript-heavy single-page applications (SPAs), the key distinction is whether a crawler executes JavaScript and whether it can simulate search engine bots. No single tool does everything well, so most technical SEO audits use a combination.

Best tools for JavaScript SEO

1. Screaming Frog SEO Spider

This is often the primary crawler for JS-heavy sites because it can:

• Render pages with headless Chromium
• Extract rendered titles, meta descriptions, canonicals, and headings
• Discover JavaScript-generated links
• Compare HTML vs rendered HTML
• Export rendered DOM

It's one of the standard tools for enterprise SPA audits.

2. Chrome DevTools

Useful for investigating:

• DOM mutations
• XHR/fetch requests
• Hydration
• Lazy loading
• Infinite scroll
• JavaScript errors
• Render-blocking resources

The Elements, Network, Performance, and Coverage panels are especially valuable.

3. Google Search Console URL Inspection

This shows what Google actually sees.

Check:

• Rendered HTML
• Screenshot
• Blocked resources
• Indexed HTML
• Canonical selection

If there's a difference between the browser view and Google's rendered view, this tool helps identify it.

4. Puppeteer / Playwright

For large-scale or repeatable audits, these frameworks let you automate checks such as:

• Waiting for hydration to complete
• Capturing the final DOM
• Extracting metadata
• Taking screenshots
• Comparing server HTML versus rendered HTML
• Testing authenticated areas

Playwright is generally preferred for new projects because it supports Chromium, Firefox, and WebKit.

Bot rendering

If you specifically need to see what search engines receive:

Googlebot

• URL Inspection (best)
• Rich Results Test
• Puppeteer with a Googlebot user agent (good approximation)
• Screaming Frog using Googlebot user agent plus JavaScript rendering

Bingbot

• Bing Webmaster Tools URL Inspection
• User-agent simulation with Screaming Frog or Playwright

Comparing raw HTML vs rendered HTML

This comparison is critical for SPAs.

Tools that make it straightforward include:

• Screaming Frog (HTML vs rendered HTML)
• Sitebulb
• Puppeteer
• Playwright
• Chrome DevTools ("View Source" versus the live DOM)

You're looking for differences in:

• <title>
• meta description
• canonical
• robots meta
• structured data
• internal links
• headings
• indexable content

Framework-specific considerations

Recommended audit workflow

For a comprehensive JavaScript SEO audit:

1. Crawl the site with Screaming Frog using JavaScript rendering enabled.
2. Inspect representative pages in Chrome DevTools to understand rendering, hydration, and network behavior.
3. Verify key URLs in Google Search Console URL Inspection to confirm what Googlebot renders and indexes.
4. Use Playwright or Puppeteer to automate checks for rendered metadata, content, and links across templates or large URL sets.
5. Compare the initial server HTML with the fully rendered DOM to identify content or metadata that only appears after client-side execution.

This combination covers both client-rendered content (what users see after JavaScript runs) and bot rendering (what search engines can discover, render, and index), making it suitable for modern React, Angular, Vue, Next.js, Nuxt, and similar applications.

For JavaScript-heavy SPAs, the key distinction is whether the crawler executes JavaScript or only reads the initial HTML. If your goal is to audit what users, Googlebot, and other bots actually see, you'll typically need more than one tool.

Best tools for JavaScript SPAs

1. Screaming Frog (one of the best)

It can:

• render JavaScript using Chromium
• compare raw HTML vs rendered HTML
• discover client-side links
• audit React, Vue, Angular, Next.js, Nuxt, SvelteKit, etc.
• emulate Googlebot user agents

Useful for finding:

• pages that only appear after JS
• missing titles after hydration
• canonical issues
• broken client-side routes
• orphan pages

2. Sitebulb

Very similar to Screaming Frog but adds excellent visualizations.

Good at:

• rendering SPAs
• detecting hydration problems
• crawl maps
• internal linking analysis

3. Chrome DevTools

For individual pages:

• disable JavaScript to see server HTML
• inspect rendered DOM
• compare initial source vs final DOM
• analyze network waterfalls
• view hydration timing

Useful panels:

• Elements
• Network
• Performance
• Coverage

4. Google Search Console URL Inspection

This is the closest you'll get to seeing what Google actually indexed.

It shows:

• rendered HTML
• rendered screenshot
• blocked resources
• crawl status
• indexing issues

5. Puppeteer / Playwright

Ideal when you want automation.

Example tasks:

• wait for hydration
• capture rendered HTML
• compare DOM before and after JS
• test thousands of URLs
• take screenshots

Many SEO teams build custom auditors using Playwright because it is fast and reliable.

Bot rendering

When auditing bots, consider three scenarios:

Raw HTML

What a simple crawler receives.

curl https://example.com

Useful for:

• metadata
• SSR
• prerendering
• robots directives

Rendered DOM

What browsers (and Googlebot's rendering service) see after JavaScript runs.

Tools:

• Chrome
• Playwright
• Puppeteer
• Screaming Frog JS Rendering

Google rendering

The closest approximations are:

• Google Search Console URL Inspection
• Rich Results Test

These use Google's rendering infrastructure and can reveal issues that generic headless browsers might miss.

Dynamic rendering / bot rendering detection

If the site serves different HTML to bots (dynamic rendering or cloaking), compare responses for different user agents.

For example:

curl -A "Googlebot" https://example.com

versus

curl -A "Mozilla/5.0" https://example.com

Also compare the fully rendered DOM using a headless browser. Significant differences can indicate dynamic rendering or, in problematic cases, cloaking.

Complete SPA audit stack

For a thorough audit of a JavaScript-heavy SPA, a practical combination is:

1. Screaming Frog with JavaScript rendering enabled for a site-wide crawl.
2. Chrome DevTools to investigate individual rendering, hydration, and network issues.
3. Google Search Console URL Inspection to verify how Google rendered and indexed important pages.
4. Playwright or Puppeteer for automated regression checks, rendered HTML snapshots, and screenshots across many URLs.
5. Lighthouse for performance, Core Web Vitals, and SEO best-practice audits.

This combination lets you compare raw HTML, client-rendered content, and Google's rendered view, making it effective for detecting missing content after hydration, client-side routing issues, JavaScript-dependent links, metadata problems, rendering failures, and discrepancies between what users and search engines receive.

For JavaScript-heavy SPAs, the key distinction is whether the crawler executes JavaScript or only reads the initial HTML. If your goal is to audit what users, Googlebot, and other bots actually see, you'll typically need more than one tool.

Best tools for JavaScript SPAs

1. Screaming Frog (one of the best)

It can:

• render JavaScript using Chromium
• compare raw HTML vs rendered HTML
• discover client-side links
• audit React, Vue, Angular, Next.js, Nuxt, SvelteKit, etc.
• emulate Googlebot user agents

Useful for finding:

• pages that only appear after JS
• missing titles after hydration
• canonical issues
• broken client-side routes
• orphan pages

2. Sitebulb

Very similar to Screaming Frog but adds excellent visualizations.

Good at:

• rendering SPAs
• detecting hydration problems
• crawl maps
• internal linking analysis

3. Chrome DevTools

For individual pages:

• disable JavaScript to see server HTML
• inspect rendered DOM
• compare initial source vs final DOM
• analyze network waterfalls
• view hydration timing

Useful panels:

• Elements
• Network
• Performance
• Coverage

4. Google Search Console URL Inspection

This is the closest you'll get to seeing what Google actually indexed.

It shows:

• rendered HTML
• rendered screenshot
• blocked resources
• crawl status
• indexing issues

5. Puppeteer / Playwright

Ideal when you want automation.

Example tasks:

• wait for hydration
• capture rendered HTML
• compare DOM before and after JS
• test thousands of URLs
• take screenshots

Many SEO teams build custom auditors using Playwright because it is fast and reliable.

Bot rendering

When auditing bots, consider three scenarios:

Raw HTML

What a simple crawler receives.

curl https://example.com

Useful for:

• metadata
• SSR
• prerendering
• robots directives

Rendered DOM

What browsers (and Googlebot's rendering service) see after JavaScript runs.

Tools:

• Chrome
• Playwright
• Puppeteer
• Screaming Frog JS Rendering

Google rendering

The closest approximations are:

• Google Search Console URL Inspection
• Rich Results Test

These use Google's rendering infrastructure and can reveal issues that generic headless browsers might miss.

Dynamic rendering / bot rendering detection

If the site serves different HTML to bots (dynamic rendering or cloaking), compare responses for different user agents.

For example:

curl -A "Googlebot" https://example.com

versus

curl -A "Mozilla/5.0" https://example.com

Also compare the fully rendered DOM using a headless browser. Significant differences can indicate dynamic rendering or, in problematic cases, cloaking.

Complete SPA audit stack

For a thorough audit of a JavaScript-heavy SPA, a practical combination is:

1. Screaming Frog with JavaScript rendering enabled for a site-wide crawl.
2. Chrome DevTools to investigate individual rendering, hydration, and network issues.
3. Google Search Console URL Inspection to verify how Google rendered and indexed important pages.
4. Playwright or Puppeteer for automated regression checks, rendered HTML snapshots, and screenshots across many URLs.
5. Lighthouse for performance, Core Web Vitals, and SEO best-practice audits.

This combination lets you compare raw HTML, client-rendered content, and Google's rendered view, making it effective for detecting missing content after hydration, client-side routing issues, JavaScript-dependent links, metadata problems, rendering failures, and discrepancies between what users and search engines receive.

For JavaScript-heavy SPAs, the key distinction is whether the crawler executes JavaScript or only reads the initial HTML. If your goal is to audit what users, Googlebot, and other bots actually see, you'll typically need more than one tool.