Best Practices to Make It SEO-Friendly


The growing prevalence of React in trendy internet growth can’t be ignored.

React and different comparable libraries (like Vue.js) have gotten the de facto alternative for bigger companies that require complicated growth the place a extra simplistic method (like utilizing a WordPress theme) received’t fulfill the necessities.

Regardless of that, SEOs didn’t initially embrace libraries like React resulting from serps struggling to successfully render JavaScript, with content material accessible within the HTML source being the choice.

Nonetheless, developments in each how Google and React can render JavaScript have simplified these complexities, leading to Web optimization not being the blocker for utilizing React.

Nonetheless, some complexities stay, which I’ll run by means of in this information.

On that word, right here’s what we’ll cowl:

However first, what’s React?

React is an open-source JavaScript library developed by Meta (previously Fb) for constructing internet and cellular functions. The primary options of React are that it is declarative, is component-based, and permits simpler manipulation of the DOM.

The best approach to perceive the elements is by pondering of them as plugins, like for WordPress. They permit builders to rapidly construct a design and add performance to a web page utilizing component libraries like MUI or Tailwind UI.

If you’d like the complete lowdown on why builders love React, begin right here:

Rendering with React, a brief historical past

React implements an App Shell Model, which means the overwhelming majority of content material, if not all, will likely be Shopper-side Rendered (CSR) by default.

CSR means the HTML primarily accommodates the React JS library reasonably than the server sending your complete web page’s contents throughout the preliminary HTTP response from the server (the HTML supply).

It’ll additionally embody miscellaneous JavaScript containing JSON data or hyperlinks to JS information that include React elements. You’ll be able to rapidly inform a website is client-side rendered by checking the HTML supply. To do this, right-click and choose “View Web page Supply” (or CTRL + U/CMD + U).

Netflix's homepage source HTML

A screenshot of the homepage supply HTML.

In case you don’t see many traces of HTML there, the applying is probably going client-side rendering.

Nonetheless, once you examine the aspect by right-clicking and deciding on “Examine aspect” (or F12/CMD + ⌥ + I), you’ll see the DOM generated by the browser (the place the browser has rendered JavaScript).

The result’s you’ll then see the positioning has plenty of HTML:

Lots of HTML

Word the appMountPoint ID on the primary <div>. You’ll generally see a component like that on a single-page application (SPA), so a library like React is aware of the place it ought to inject HTML. Technology detection tools, e.g., Wappalyzer, are additionally nice at detecting the library.

Editor’s Word

Ahrefs’ Website Audit saves each the Uncooked HTML despatched from the server and the Rendered HTML within the browser, making it simpler to identify whether or not a website has client-side rendered content material.

Gif showing Site Audit saves both Raw HTML and Rendered HTML

Even higher, you’ll be able to search each the Uncooked and Rendered HTML to know what content material is particularly being rendered client-side. Within the under instance, you’ll be able to see this website is client-side rendering key web page content material, such because the <h1> tag.

Gif showing site is client-side rendering key page content

Joshua Hardwick

Web sites created utilizing React differ from the extra conventional method of leaving the heavy-lifting of rendering content material on the server utilizing languages like PHP—known as Server-side Rendering (SSR).

Flowchart showing the SSR process

The above exhibits the server rendering JavaScript into HTML with React (extra on that shortly). The idea is similar for websites constructed with PHP (like WordPress). It’s simply PHP being changed into HTML reasonably than JavaScript.

Earlier than SSR, builders saved it even less complicated.

They’d create static HTML paperwork that didn’t change, host them on a server, after which ship them instantly. The server didn’t must render something, and the browser typically had little or no to render.

SPAs (together with these utilizing React) at the moment are coming full circle again to this static method. They’re now pre-rendering JavaScript into HTML earlier than a browser requests the URL. This method is named Static Website Technology (SSG), also referred to as Static Rendering.

Two flowcharts showing the SSG process

In apply, SSR and SSG are comparable.

The important thing distinction is that rendering occurs with SSR when a browser requests a URL versus a framework pre-rendering content material at construct time with SSG (when builders deploy new code or an online admin adjustments the positioning’s content material).

SSR could be extra dynamic however slower resulting from extra latency whereas the server renders the content material earlier than sending it to the person’s browser.

SSG is quicker, because the content material has already been rendered, which means it may be served to the person instantly (which means a faster TTFB).

How Google processes pages

To know why React’s default client-side rendering method causes Web optimization points, you first must know how Google crawls, processes, and indexes pages.

We are able to summarize the fundamentals of how this works in the under steps:

  1. Crawling – Googlebot sends GET requests to a server for the URLs within the crawl queue and saves the response contents. Googlebot does this for HTML, JS, CSS, picture information, and extra.
  2. Processing – This contains including URLs to the crawl queue discovered inside <a href> hyperlinks throughout the HTML. It additionally contains queuing useful resource URLs (CSS/JS) discovered inside <link> tags or pictures inside <img src> tags. If Googlebot finds a noindex tag at this stage, the method stops, Googlebot received’t render the content material, and Caffeine (Google’s indexer) received’t index it.
  3. Rendering – Googlebot executes JavaScript code with a headless Chromium browser to seek out extra content material throughout the DOM, however not the HTML supply. It does this for all HTML URLs.
  4. Indexing – Caffeine takes the data from Googlebot, normalizes it (fixes damaged HTML), after which tries to make sense of all of it, precomputing some rating indicators prepared for serving inside a search outcome.
Flowchart showing how Google crawls, processes, and indexes pages

Traditionally, points with React and different JS libraries have been resulting from Google not dealing with the rendering step properly.

Some examples embody:

  • Not rendering JavaScript – It’s an older concern, however Google solely began rendering JavaScript in a limited way in 2008. Nonetheless, it was nonetheless reliant on a crawling scheme for JavaScript websites created in 2009. (Google has since deprecated the scheme.)
  • The rendering engine (Chromium) being outdated – This resulted in a lack of support for the latest browser and JavaScript features. In case you used a JavaScript characteristic that Googlebot didn’t assist, your web page may not render accurately, which may negatively impression your content material’s indexing.
  • Google had a rendering delay – In some instances, this might mean a delay of up to a few weeks, slowing down the time for adjustments to the content material to succeed in the indexing stage. This could have dominated out counting on Google to render content material for many websites.

Fortunately, Google has now resolved most of those points. Googlebot is now evergreen, which means it at all times helps the newest options of Chromium.

As well as, the rendering delay is now 5 seconds, as introduced by Martin Splitt on the Chrome Developer Summit in November 2019:

Final 12 months Tom Greenaway and I had been on this stage and telling you, ‘Effectively, you understand, it could take as much as every week, we’re very sorry for this.’ Overlook this, okay? As a result of the brand new numbers look so much higher. So we really went over the numbers and located that, it seems that at median, the time we spent between crawling and really having rendered these outcomes is – on median – it’s 5 seconds!”

This all sounds constructive. However is client-side rendering and leaving Googlebot to render content material the best technique?

The reply is most certainly nonetheless no.

Frequent Web optimization points with React

Up to now 5 years, Google has innovated its dealing with of JavaScript content material, however fully client-side rendered websites introduce different points that that you must take into account.

It’s vital to notice that you’ll be able to overcome all points with React and Web optimization.

React JS is a growth instrument. React isn’t any completely different from some other instrument inside a growth stack, whether or not that’s a WordPress plugin or the CDN you select. The way you configure it would resolve whether or not it detracts or enhances Web optimization.

Finally, React is sweet for Web optimization, because it improves person expertise. You simply must be sure to take into account the next widespread points.

1. Choose the best rendering technique

Probably the most important concern you’ll must sort out with React is how it renders content material.

As talked about, Google is nice at rendering JavaScript these days. However sadly, that isn’t the case with different serps. Bing has some support for JavaScript rendering, though its effectivity is unknown. Different serps like Baidu, Yandex, and others provide restricted assist.


This limitation doesn’t solely impression serps. Other than website auditors, Web optimization instruments that crawl the net and supply essential information on components like a website’s backlinks don’t render JavaScript. This may have a important impression on the standard of information they supply. The one exception is Ahrefs, which has been rendering JavaScript throughout the net since 2017 and presently renders over 200 million pages per day.

Introducing this unknown builds a very good case for choosing a server-side rendered answer to make sure that all crawlers can see the positioning’s content material.

As well as, rendering content material on the server has one other essential profit: load instances.

Load instances

Rendering JavaScript is intensive on the CPU; this makes giant libraries like React slower to load and grow to be interactive for customers. You’ll typically see Core Internet Vitals, comparable to Time to Interactive (TTI), being a lot greater for SPAs—particularly on cellular, the primary way users consume web content.

Overview of metrics' performance, including FCP, LCP, etc

An instance React utility that makes use of client-side rendering.

Nonetheless, after the preliminary render by the browser, subsequent load instances are usually faster because of the following:

Relying on the variety of pages considered per go to, this may end up in area information being constructive general.

Four bar graphs showing positive field data of FCP, LCP, FID, and CLS

Nonetheless, in case your website has a low variety of pages considered per go to, you’ll battle to get constructive area information for all Core Internet Vitals.


The best choice is to go for SSR or SSG primarily due to:

  • Sooner preliminary renders.
  • Not having to depend on search engine crawlers to render content material.
  • Enhancements in TTI resulting from much less JavaScript code for the browser to parse and render earlier than changing into interactive.

Implementing SSR inside React is feasible through ReactDOMServer. Nonetheless, I like to recommend utilizing a React framework known as Next.js and using its SSG and SSR options. You may as well implement CSR with Subsequent.js, however the framework nudges customers towards SSR/SSG resulting from pace.

Subsequent.js helps what it calls “Automatic Static Optimization.” In apply, this implies you’ll be able to have some pages on a website that use SSR (comparable to an account web page) and different pages utilizing SSG (comparable to your weblog).

The outcome: SSG and quick TTFB for non-dynamic pages, and SSR as a backup rendering technique for dynamic content material.


You’ll have heard about React Hydration with ReactDOM.hydrate(). That is the place content material is delivered through SSG/SSR after which turns right into a client-side rendered utility through the preliminary render. This can be the plain alternative for dynamic functions sooner or later reasonably than SSR. Nonetheless, hydration presently works by loading your complete React library after which attaching event handlers to HTML that may change. React then retains HTML between the browser and server in sync. Presently, I can’t advocate this method as a result of it nonetheless has adverse implications for internet vitals like TTI for the preliminary render. Partial Hydration might resolve this sooner or later by solely hydrating essential elements of the web page (like ones throughout the browser viewport) reasonably than your complete web page; till then, SSR/SSG is the higher possibility.

Since we’re speaking about pace, I’ll be doing you a disservice by not mentioning different methods Subsequent.js optimizes the critical rendering path for React functions with options like:

  • Image optimization – This provides width and top <img> attributes and srcset, lazy loading, and picture resizing.
  • Font optimization – This inlines essential font CSS and provides controls for font-display.
  • Script optimization – This allows you to decide when a script must be loaded: earlier than/after the web page is interactive or lazily.
  • Dynamic imports – In case you implement finest practices for code splitting, this characteristic makes it simpler to import JS code when required reasonably than leaving it to load on the preliminary render and slowing it down.

Speed and positive Core Web Vitals are a ranking factor, albeit a minor one. Subsequent.js options make it simpler to create nice internet experiences that will provide you with a aggressive benefit.


Many builders deploy their Subsequent.js internet functions utilizing Vercel (the creators of Subsequent.js), which has a global edge network of servers; this leads to quick load instances.

Vercel gives data on the Core Web Vitals of all sites deployed on the platform, however you can too get detailed internet important information for every URL utilizing Ahrefs’ Website Audit.

Merely add an API key throughout the crawl settings of your initiatives.

Text field to add API key

After you’ve run your audit, take a look on the efficiency space. There, Ahrefs’ Website Audit will present you charts displaying information from the Chrome Person Expertise Report (CrUX) and Lighthouse.

Pie charts and bar graphs showing data from CrUX and Lighthouse

2. Use standing codes accurately

A typical concern with most SPAs is that they don’t accurately report standing codes. That is because the server isn’t loading the web page—the browser is. You’ll generally see points with:

  • No 3xx redirects, with JavaScript redirects getting used as a substitute.
  • 4xx standing codes not reporting for “not discovered” URLs.

You’ll be able to see under I ran a take a look at on a React website with This web page ought to clearly be a 404 however, as a substitute, returns a 200 standing code. That is known as a gentle 404.

Table showing URL on left. On right, under "Status codes," it shows "200"

The chance right here is that Google might resolve to index that web page (relying on its content material). Google may then serve this to customers, or it’ll be used when evaluating a website.

As well as, reporting 404s helps SEOs audit a website. In case you by chance internally hyperlink to a 404 web page and it’s returning a 200 standing code, rapidly recognizing the world with an auditing instrument might grow to be rather more difficult.

There are a few methods to resolve this concern. In case you’re client-side rendering:

  1. Use the React Router framework.
  2. Create a 404 component that exhibits when a route isn’t acknowledged.
  3. Add a noindex tag to “not discovered” pages.
  4. Add a <h1> with a message like “404: Web page Not Discovered.” This isn’t very best, as we don’t report a 404 standing code. However it would forestall Google from indexing the web page and assist it acknowledge the web page as a gentle 404.
  5. Use JavaScript redirects when that you must change a URL. Once more, not very best, however Google does observe JavaScript redirects and cross rating indicators.

In case you’re utilizing SSR, Subsequent.js makes this easy with response helpers, which allow you to set no matter standing code you need, together with 3xx redirects or a 4xx standing code. The method I outlined utilizing React Router can be put into apply whereas utilizing Subsequent.js. Nonetheless, if you’re utilizing Subsequent.js, you’re possible additionally implementing SSR/SSG.

3. Keep away from hashed URLs

This concern isn’t as widespread for React, however it’s important to keep away from hash URLs like the next:


Typically, Google isn’t going to see something after the hash. All of those pages will likely be seen as


SPAs with client-side routing ought to implement the Historical past API to alter pages.

You are able to do this comparatively simply with both React Router and Next.js.

4. Use <a href> hyperlinks the place related

A typical mistake with SPAs is utilizing a <div> or a <button> to alter the URL. This isn’t a difficulty with React itself, however how the library is used.

Doing this presents a difficulty with serps. As talked about earlier, when Google processes a URL, it appears for added URLs to crawl inside <a href> components.

If the <a href> aspect is lacking, Google received’t crawl the URLs and cross PageRank.


The answer is to incorporate <a href> hyperlinks to URLs that you really want Google to find.

Checking whether or not you’re linking to a URL accurately is simple. Examine the aspect that internally hyperlinks and test the HTML to make sure you’ve included <a href> hyperlinks.

As within the above instance, you could have a difficulty in the event that they aren’t.

Nonetheless, it’s important to grasp that lacking <a href> hyperlinks aren’t at all times a difficulty. One good thing about CSR is that when content material is useful to customers however not serps, you’ll be able to change the content material client-side and never embody the <a href> hyperlink.

Within the above instance, the positioning makes use of faceted navigation that hyperlinks to doubtlessly hundreds of thousands of mixtures of filters that aren’t helpful for a search engine to crawl or index.

List of genres

Loading these filters client-side is smart right here, as the positioning will preserve crawl funds by not including <a href> hyperlinks for Google to crawl.

Subsequent.js makes this straightforward with its link component, which you’ll configure to allow client-side navigation.

In case you’ve determined to implement a completely CSR utility, you can change URLs with React Router utilizing onClick and the History API.

5. Keep away from lazy loading important HTML

It’s widespread for websites developed with React to inject content material into the DOM when a person clicks or hovers over a component—just because the library makes that straightforward to do.

This isn’t inherently unhealthy, however content material added to the DOM this manner won’t be seen by search engines. If the content material injected contains vital textual content material or inner hyperlinks, this will negatively impression:

  • How properly the web page performs (as Google received’t see the content material).
  • The discoverability of different URLs (as Google received’t discover the inner hyperlinks).

Right here’s an instance on a React JS website I lately audited. Right here, I’ll present a well known e‑commerce model with vital inner hyperlinks inside its faceted navigation.

Nonetheless, a modal exhibiting the navigation on cellular was injected into the DOM once you clicked a “Filter” button. Watch the second <!—-> throughout the HTML under to see this in apply:

Gif of modal showing the navigation on mobile was injected into DOM


Recognizing these points isn’t straightforward. And so far as I do know, no instrument will immediately let you know about them.

As an alternative, you must test for widespread components such as:

  • Accordions
  • Modals
  • Tabs
  • Mega menus
  • Hamburger menus

You’ll then want to examine the aspect on them and watch what occurs with the HTML as you open/shut them by clicking or hovering (as I’ve finished within the above GIF).

Suppose you discover JavaScript is including HTML to the web page. In that case, you’ll must work with the builders. That is so that reasonably than injecting the content material into the DOM, it’s included throughout the HTML by default and is hidden and proven through CSS utilizing properties like visibility: hidden; or display: none;.

6. Don’t neglect the basics

Whereas there are extra Web optimization issues with React functions, that doesn’t imply different fundamentals don’t apply.

You’ll nonetheless want to ensure your React functions observe finest practices for:

Last ideas

Sadly, working with React functions does add to the already lengthy record of points a technical Web optimization must test. However due to frameworks like Subsequent.js, it makes the work of an Web optimization rather more easy than what it was traditionally.

Hopefully, this information has helped you higher perceive the extra issues that you must make as an Web optimization when working with React functions.

Have any questions on working with React? Tweet me.