SPA SEO Audit
Audit any single-page app for SEO
DeepAudit AI is a framework-agnostic real browser SEO audit and JavaScript SEO scanner. Whether the app is React, Vue, Angular, Svelte, or vanilla JS, the same hydration diff and render-budget instrumentation surfaces every indexing failure Google would.
Free. No signup. 60 seconds per URL.
Single-page apps share one SEO problem
The framework changes; the indexing problem does not. A SPA — whether React, Vue, Angular, Svelte, Solid, Lit, or a hand-rolled router — ships an empty HTML shell and renders content client-side. SEO tools that scan the initial HTML response see nothing.
Google sees nothing on its first-pass index, then queues the page for a second pass that runs JavaScript on a strict render budget. Anything that does not finish rendering inside that budget never gets indexed.
The AI crawlers behind ChatGPT, Claude, and Perplexity skip the second pass entirely. They never run your JavaScript, so a SPA shell is all they get. In our AI Visibility Study of 368 small business sites, 1 in 4 hid answer-critical content from these non-rendering crawlers, and single-page apps were the worst case. This audit shows you exactly what a SPA exposes to each.
The result is a recognizable pattern in Search Console. Pages report as discovered but not indexed. Snippets show fallback content that has not been on the page in months. Schema-driven rich results never appear despite valid markup in the source.
New routes take weeks to enter the index even with sitemap submissions. Every one of these symptoms traces back to client-side rendering and the render budget.
A real browser SEO audit fixes this by reproducing what Googlebot does. DeepAudit AI loads your URL in a headless Chromium runtime, waits for the network to settle and hydration to complete, then captures the post-hydration DOM and diffs it against the initial HTML response.
Framework fingerprinting layers framework-specific guidance on top of the universal indexing diagnostics, so the report tells you both the symptom and the framework-idiomatic remediation.
SPA SEO Failure Catalog
Eight failure modes every SPA shares
These are the failure patterns we see across every JavaScript framework, in roughly the same proportions. Hash routing was supposed to die a decade ago, and we still find it on production sites. Render-budget exhaustion is the silent killer of large SPAs — you do not see it in dev, you see it as gradual ranking drift that nobody can explain.
DeepAudit AI catches all eight regardless of framework. The detection panel below explains how the underlying diff engine produces framework-agnostic findings without sacrificing framework-specific remediation guidance.
Hash-based routing on content URLs
URLs like /#/products/widget look fine to users but Google strips everything after the hash before indexing. The result: the entire app collapses to a single indexable URL. We see this most often on legacy Angular 1 and React Router v3 apps; modern frameworks default to History API, but custom routers still fall into this trap.
Hydration mismatches that overwrite indexed content
When server-rendered HTML differs from the client render, the framework replaces the server output during hydration. Google has already indexed the server version. The most common cause is non-deterministic logic — Date.now(), Math.random(), feature flags, locale detection — leaking into render. The cached snippet shows your fallback content forever.
Meta tags set after the first render
react-helmet, vue-meta, @angular/platform-browser title services, and similar libraries that mutate document head client-side. The first-pass HTML contains your default app title; the real per-route metadata never reaches the indexed snapshot. Schema.org markup injected the same way disappears the same way.
Render-budget exhaustion on complex routes
Google grants each rendered page a few seconds of execution time. Routes with large bundles, heavy initial data fetching, or expensive hydration commonly run past the budget. The first-pass content is what gets indexed; the real content never makes it. Lighthouse will report a passing score for users but Search Console shows persistent thin-content flags.
Internal navigation that does not produce real <a href> links
Click handlers on buttons or divs that call router.push() or programmatic navigation create transitions Google cannot follow. Crawl reach collapses to whatever the sitemap explicitly enumerates and whatever inbound links exist. Every interactive nav element needs a real href that doubles as the click target.
Above-the-fold content lazy-loaded behind dynamic imports
import() and React.lazy() are useful for shipping less JavaScript, but when they wrap your H1, hero copy, or primary product info, the deferred chunk has to download and parse before that content paints. On a slow connection or under render-budget pressure, the indexable surface area shrinks to whatever rendered before the import resolved.
Sitemap drift from runtime routes
SPA route configs drift from the sitemap.xml file as features ship. New routes never get added; deprecated routes never get removed. Google discovers the gap on each crawl and slowly drops crawl budget for the domain. Our deep scan compares discovered routes against the sitemap and surfaces the diff in seconds.
Service workers caching empty shells
PWAs cache the SPA shell aggressively for offline use. When a service worker intercepts a search engine request and returns the cached empty shell instead of a fresh server-rendered response, the index gets garbage. We detect this by comparing fetch responses with and without service-worker registration.
How Detection Works
One engine, every framework
DeepAudit AI runs every audit through a headless Chromium instance — the same browser engine Googlebot uses. The audit fires three observations per URL: the raw initial HTML response from the server, the DOM at first contentful paint, and the fully-hydrated DOM after route data and JavaScript settle. Diffing those three snapshots produces every framework-agnostic finding the report contains.
Hash routing detection is mechanical: any route whose URL fragment carries the routing payload is flagged on entry.
Hydration mismatches surface when the post-hydration DOM differs structurally from the first contentful paint snapshot — a strong signal that the framework replaced server-rendered content with a different client render.
Render-budget overruns are detected by timing the gap between first contentful paint and DOM settlement; routes whose hydration finishes after our render-budget threshold are tagged as at risk.
Internal-link auditing inspects every interactive element in the rendered tree across the entire page. Buttons, divs, and other elements with click handlers that perform navigation but lack a real href attribute are flagged.
Sitemap drift is checked by crawling discovered routes during the deep scan and cross-referencing against the published sitemap.xml. Service-worker-driven response interception is detected by comparing fetch responses with and without service-worker registration.
Framework fingerprinting kicks in once the universal diagnostics are recorded.
The scanner detects React (DevTools hook), Vue 3 (reactivity proxies), Angular (zone.js, ng-version attribute), Svelte (action attributes and runtime markers), Solid, Lit, and a handful of less common frameworks.
Each detected framework adds remediation guidance: React-specific patterns reference react-helmet and useEffect; Vue findings reference vue-meta; Angular findings reference @angular/platform-browser. The universal Core Web Vitals audit and structured data validation run on every audit regardless of detected framework.
Audit any SPA in 60 seconds
DeepAudit AI runs the full real browser SEO audit, JavaScript SEO scanner, and Core Web Vitals audit on any single-page application — React, Vue, Angular, Svelte, Solid, Lit, or vanilla JS. Hydration diff, framework fingerprinting, sitemap-drift detection, and a downloadable PDF report.
Launch Free SEO AuditFAQ
SPA SEO questions, answered
What is a single-page application and why is its SEO different?
A single-page application loads a single HTML shell and uses JavaScript to render every route, swap content, and update history without full page reloads. SEO tools that scan only the initial HTML response see an empty shell. Search engines have to execute JavaScript to discover the real content, which works inconsistently and on a render budget. A real browser SEO audit reproduces what Googlebot sees instead of what curl returns.
Does this audit work for non-React SPAs?
Yes. DeepAudit AI is framework-agnostic. The detection engine runs a real Chromium instance, waits for hydration regardless of which framework triggered it, and diffs the initial HTML response against the post-hydration DOM. The same JavaScript SEO scanner catches the same indexing failures whether the app is React, Vue, Angular, Svelte, Solid, Lit, or hand-rolled vanilla JS.
How does Google handle SPAs in 2026?
Google indexes SPAs in two passes. The first pass reads the initial HTML response and discovers links. The second pass executes JavaScript on a render budget — typically a few seconds — and re-indexes whatever the rendered DOM contains. Pages that exceed the render budget get indexed only with their first-pass content, which for most SPAs is an empty shell. The audit shows you which routes are at risk before Search Console reports thin-content errors weeks later.
What is hash routing and is it still a problem for SEO?
Hash routing uses URLs like /#/about instead of /about. Google ignores everything after the hash for indexing purposes, so hash-routed apps publish exactly one indexable URL no matter how many routes they have. The fix is the History API with real path-based URLs. Our scanner detects hash routing automatically and flags it as a critical SEO issue.
Can a SPA pass Core Web Vitals?
Yes, but it requires deliberate engineering. JavaScript bundles, hydration cost, and runtime route transitions all push LCP and INP above the green thresholds. A Core Web Vitals audit on a SPA needs to measure the route transition itself, not just the initial load. DeepAudit AI runs the standard CWV battery on entry, and the deep scan captures route-transition metrics for the most important pages.
How does the audit detect framework-specific failures?
The scanner detects the framework from runtime fingerprints — React DevTools hook, Vue 3 reactivity proxies, Angular zone.js, Svelte action attributes — then applies framework-aware checks on top of the framework-agnostic core. The hydration diff, route-discoverability check, and meta tag timing audit are universal; the framework recognition produces tailored remediation guidance in the report.
Is server-side rendering required for SPA SEO?
Not strictly, but it raises the ceiling significantly. SSR or static generation lets Google index real content on the first pass without depending on the render budget. Pure CSR works for authenticated apps where SEO does not matter; for content sites, blogs, marketing pages, and ecommerce, SSR is the practical default. The audit identifies which routes need SSR most urgently based on render-budget risk and traffic potential.
How long does the SPA SEO audit take?
Single URL: about 60 seconds. Deep scan crawling up to 50 routes from the sitemap: 5 to 10 minutes. The result is a downloadable PDF with hydration diff, framework detection, route-discoverability findings, structured data validation, and a full Core Web Vitals audit. No signup, no credit card.
Related
Framework-specific deep dives
The same diff engine produces deeper guidance when paired with framework-aware remediation. Start with the framework that ships your app today.
SPA audits back the technical SEO in our digital marketing services. See all services.
React SEO Audit
React-specific failure modes: react-helmet timing, useEffect-set metadata, hydration mismatches, and the specific Next.js / Vite tradeoffs.
- react-helmet pitfalls
- SSR vs SSG vs CSR guidance
- React Router crawl gotchas
JavaScript Rendering & SEO
The technical foundation: how Google's two-pass index actually works, what the render budget is, and how to architect for it.
- Two-pass index walkthrough
- Render-budget diagnostics
- Hybrid rendering strategies
Get Started
Audit your SPA
Drop in any URL. DeepAudit AI runs the framework-agnostic real browser SEO audit, JavaScript SEO scanner, and Core Web Vitals audit. You get the diff between what Google's first-pass index sees and what your hydrated app actually renders, with the detected framework and route-specific remediation called out.