JavaScript SEO Audit Checklist: 23 Checks for React, Vue and Angular Sites
In this article
A JavaScript SEO audit checks whether the content a visitor sees on a JavaScript-driven site is the content Google can crawl, render and index. Google renders JavaScript, but it does so in three separate phases, with a queue in the middle, and a long list of things that go wrong between the server's HTML and the rendered page. This checklist is the one we work through on any site built with React, Vue, Angular or a similar framework, with the fixes, and it is drawn from Google's own documentation for JavaScript sites as published in November 2026. For the rest of a technical audit, see our technical SEO audit checklist.
How Google processes a JavaScript site
Google works in three phases: crawling, rendering and indexing. Googlebot fetches the HTML, follows the links it can see, and queues every page that returns a 200 status for rendering. The page can sit in that queue for a few seconds or a good deal longer; when resources allow, a headless, evergreen version of Chromium renders it and Google indexes what the rendered page shows. Pages that return a non-200 status may skip rendering altogether, and Google will not render JavaScript from files or pages that robots.txt blocks. Google also says that server-side or pre-rendering is still a great idea, because not every crawler can run JavaScript at all.
Two consequences shape the whole checklist. Anything that needs a user action to appear, such as a click or a scroll, is invisible, because Google does not interact with the page. And anything that depends on state across page loads is lost, because the rendering service clears local storage, session storage and cookies between loads.
The JavaScript SEO audit checklist
Crawling and links
- Every route is a real link. Navigation uses
<a href>elements with real URLs, not click handlers. Googlebot queues links from the HTML and from JavaScript as long as they are crawlable links. - Client-side routing uses the History API, not fragments. URLs such as
/#/productscannot be reliably resolved; Google says not to use fragments to load different content, and the old AJAX-crawling scheme has been deprecated since 2015. - robots.txt does not block the JavaScript, CSS or API responses the page needs to render. Blocked resources mean an empty render.
- Content does not depend on a user action. Tabs, accordions and "load more" buttons are fine if the content is in the rendered HTML; content fetched only on click is not indexed.
Status codes and error pages
- Missing pages return a real 404. Single-page apps often answer every route with 200, so error pages get indexed as soft 404s. Either redirect the error state to a URL the server answers with 404, or add a noindex robots meta tag to the error view with JavaScript, or both.
- Logged-in content returns 401 or a redirect to the login page, not a 200 with an empty shell.
- Moved content uses a redirect, server-side where possible. The rendering service follows both server and client redirects, but a server redirect is what every other crawler sees.
Canonical and robots tags
- The canonical tag is in the server's HTML wherever possible. If JavaScript must set it, it sets the same value as the HTML, and the injected tag is the only rel="canonical" on the page; duplicates or changed values lead to unexpected results.
- JavaScript never changes the canonical to a different URL, and never removes a noindex. Google says that when it sees noindex it may skip rendering altogether, so a noindex removed by JavaScript may never be noticed.
- Titles and descriptions set by JavaScript match what you intended. Google honours them, so check the rendered values, not the template.
Rendering and content
- The rendered HTML contains the content, links and meta tags. Compare "View crawled page" in Search Console's URL Inspection, or the Rich Results Test, with what you see in the browser.
- Nothing essential relies on local storage, session storage or cookies across page loads, because the rendering service clears them.
- Nothing essential relies on a permission prompt. Google says to expect Googlebot to decline user permission requests, such as the camera API, so provide the content without the permission.
- Nothing essential relies on WebSockets or WebRTC. Googlebot does not support them; provide an HTTP fallback and error handling.
- Features that Googlebot lacks have fallbacks. Feature detection with a polyfill or a fallback for critical APIs; WebGL, for example, is not supported, so a WebGL-only effect needs a static alternative or server-side prerendering.
- Web components project their content with slot elements. Google flattens shadow DOM and light DOM, so only content visible in the rendered HTML is indexed; components that skip
<slot>may render nothing. - Paywalled content is not sent in full and hidden with JavaScript. Google says that is not a reliable way to limit access; send the full content only once subscription status is confirmed.
Lazy loading and infinite scroll
- Lazy-loaded content appears when it enters the viewport, through the browser's built-in lazy loading, the IntersectionObserver API or a library that loads on viewport entry, never on scroll or click events. Google does not scroll.
- Content likely to be visible on first load is not lazy-loaded at all, and image and video URLs appear in the
srcof the rendered<img>or<video>. Our guide to lazy loading images covers the trade-offs. - Infinite scroll has paginated URLs behind it. Each chunk gets its own persistent URL with an absolute page number such as
?page=12, the chunks link to each other, the content at each URL is the same on every load, and the History API updates the address as the visitor moves.
Caching and files
- Script and stylesheet filenames carry a content fingerprint, such as
main.2bb85551.js. Googlebot caches aggressively and may ignore caching headers, so an unfingerprinted file can leave Google rendering with outdated code. - Structured data injected by JavaScript is tested. Google reads JSON-LD added by scripts, but only the Rich Results Test will tell you it worked.
- JavaScript errors are logged for crawlers as well as users. A global error handler that reports to your logs shows what breaks for Googlebot; the crawl stats report in Search Console shows its activity, because client-side analytics will not.
Rendering choices: what Google recommends now
Dynamic rendering, serving a pre-rendered page to crawlers and the JavaScript app to people, was once Google's suggested workaround. Its documentation now calls it a workaround and not a recommended solution, because of the complexity and resource requirements it adds, and points to server-side rendering, static rendering or hydration instead. In plain terms: render the HTML on the server or at build time, and let JavaScript add interactivity on top. Our comparison of server-side and client-side rendering works through the trade-offs, and it is the reason we render every page of our own builds on the server.
How to run the audit
Take the ten most important URLs, including one of each template. For each, run URL Inspection in Search Console, open the rendered HTML, and tick the checklist against it. Then crawl the whole site with a crawler that renders JavaScript, compare the rendered page count with the HTML page count, and look for routes that only exist in the app. Fix the status codes and robots problems first, because they decide whether a page is rendered at all, then the content and lazy-loading problems, then caching. Re-test with the Rich Results Test after each fix.
Questions people ask
Does Google render JavaScript?
Yes. Google crawls the HTML, queues each 200 page for rendering, and renders it with an evergreen version of Chromium before indexing what the rendered page shows. The catch is the queue, which can delay rendering, and the long list of things the renderer does not do: it does not click, scroll, grant permissions, keep storage between loads, or support WebSockets.
Is client-side rendering bad for SEO?
It can work, but Google's own guidance says server-side or pre-rendering is still a great idea, and its documentation on rendering says client-side apps often need extra testing and overhead to index well. If the site matters for search, render the HTML on the server or at build time and hydrate on the client.
Is dynamic rendering still recommended?
No. Google's documentation describes it as a workaround and not a recommended solution, and recommends server-side rendering, static rendering or hydration instead. It does not generally treat it as cloaking as long as the content is similar, but it is no longer the answer.
How do I check what Google sees on a JavaScript page?
URL Inspection in Search Console shows the HTML Google fetched and rendered, and the Rich Results Test renders a page on demand and shows the result. Compare the rendered HTML with the page in your browser; anything missing from the rendered version is missing from the index.
Where to start
Inspect your homepage and one page of each template in Search Console today and read the rendered HTML. If the content is there, the rest of the checklist is detail. If it is not, nothing else matters until it is. On the sites we build, these checks are part of our technical SEO work; if yours was built elsewhere, book a free call and we will go through the rendered pages with you.