Skip to content
Searchpedia SEO field notes Callum Bennett Callum

Site ops

SEO React

If you build a React app that needs organic traffic, you must deliver content in the initial HTML – client-side rendering alone won't cut it.

Beginner5 min readUpdated 2026-07-27Notes by Callum Bennett

Start here

  • Use server-side rendering or static site generation to expose page content in the initial HTML response.
  • Set a unique <title> and meta description per route with react-helmet-async, matching visible content.
  • Replace onClick handlers with real <a> tags to make navigation crawlable.
  • Generate an XML sitemap with all indexable routes and submit it to Google Search Console.
  • Inject structured data in JSON-LD server-side for eligible content types to enable rich results.

Plain-English take

React SEO is about making sure search engines can see and understand your React app. The core problem is that React apps often render content in the browser, which means Google might not see the content until it runs JavaScript – and that can be slow or incomplete. The fix is to deliver key SEO elements in the initial HTML. For pages that need organic traffic, I would use server-side rendering (SSR) or static site generation (SSG) to expose text, links, and metadata before any JavaScript executes. Prerendering tools can also help for sites that cannot run a Node server. Without this, Googlebot may only see a blank shell or a loading spinner. Even when Google can render JS, it defers the crawl and may not process all resources. The goal is to make your React app behave like a traditional server-rendered site for search engines while keeping the interactivity for users. This also means every route must have a unique title and meta description, and navigation must use real anchor elements, not just onClick handlers. Structured data in JSON-LD helps describe your content and is part of a broader [technical SEO](/technical-seo/) approach. And performance matters: code splitting, lazy loading, and image compression improve Core Web Vitals, which affect ranking. In short, React SEO is not optional if you want search traffic; it is an engineering choice that determines whether Google can index your pages.

When it actually matters

React SEO matters whenever your site has pages you want listed in search results. Blog posts, product pages, and landing pages all need it. If your app relies on dynamic content – user-generated comments, real-time prices, personalised recommendations – then SSR or Incremental Static Regeneration (ISR) becomes necessary because that content changes often and must be reflected in the HTML crawl. Another case is a large e-commerce site with thousands of product URLs. Without proper crawlable links and a sitemap, Google may never discover all pages. I also consider structured data crucial for rich results. If your site uses FAQ, Product, or Breadcrumb markup, it must be injected into the HTML server-side or pre-rendered. Performance is another driver. Google's [Core Web Vitals](/core-web-vitals/) are harder to satisfy on a client-rendered React app because of larger JavaScript bundles. Investing in code splitting and server rendering can reduce Largest Contentful Paint. However, React SEO matters less for internal tools, password-protected areas, or single-page apps that don't need organic traffic. I once worked on a dashboard where we skipped all SEO optimisation – that was fine because no page needed indexing. The decision rule: if a page has a URL, it should be optimised for search unless you explicitly block it with [robots.txt](/robots-txt/) or a noindex [directive](/directive/).

What I got wrong

The first mistake was thinking client-side rendering was enough. I assumed Google could always execute JavaScript perfectly. It can't. For complex apps with heavy frameworks, Google may time out, skip resources, or render only a partial DOM. I saw a site where several product pages were never indexed because their content was fetched via an API call after page load. Switching to SSR fixed it. The second mistake was using generic metadata. On one project, every page had the same title and meta description. Google ignored most of them. Unique, descriptive metadata per route is essential – I use react-helmet-async to set them dynamically. The third mistake was neglecting structured data. I thought JSON-LD would work even if injected client-side. It can, but Google often sees it late or not at all if the page fails to render. Now I inject structured data server-side for critical pages. I also underestimated the impact of performance on crawl budget. A slow React app wastes Google's resources; it crawls fewer pages. Code splitting and lazy loading are not just user experience improvements – they affect SEO directly. Finally, I overlooked semantic HTML. Using <div> for everything lost the content hierarchy that helps Google understand page structure. Now I use <article>, <nav>, and <header> where appropriate. For a deeper understanding of how Google processes JavaScript-heavy pages, read the [JavaScript SEO](/javascript-seo/) basics.

Next step

Quick answers

Does using React prevent Google from indexing my site?

No, but client-side rendering delays what Google sees. The framework is fine; the issue is how you deliver content. If the initial HTML is empty or just a loader, Google may not index your pages. Use server-side rendering or prerendering to expose text and metadata in the HTML response.

Should I use server-side rendering for every page in my React app?

No. Only pages that need organic traffic or rich results require SSR. Internal tools, logged-in pages, or single-use interfaces can stay client-side. Evaluate each route: if you want it indexed, render it server-side; otherwise, let the browser handle it.

Can I use a prerendering service instead of full SSR?

Yes. Tools like Prerender.io serve snapshotted HTML to crawlers while users get the client-rendered app. This works for mostly static sites but requires careful setup to ensure metadata and links appear in the snapshot. Verify with the URL Inspection Tool.

Do I need a sitemap for a React single-page app?

Absolutely. React SPAs with client-side routing make it hard for crawlers to discover all URLs. A [sitemap](/sitemap/) lists every important route, including those using hash-based routing. Submit it via Search Console and ensure it only includes indexable pages.

Sources

Primary documentation is linked directly. Anything commercial is marked nofollow.

  • Google Search Central — Primary source for guidance on crawling, rendering, and indexing React apps.
  • JavaScript SEO basics — Explains how Googlebot processes JavaScript and what to do for discoverability.
  • Structured data — Authoritative guidance on JSON-LD and eligible rich result markup.
  • Sitemaps — Defines sitemap requirements and best practices for React apps.
  • Core Web Vitals — Official guidance for performance signals that commonly affect React sites.

Notes from Callum Bennett.