React SEO: Best Practices to Make It SEO-Friendly

The rising pervasiveness of Respond in present-day web improvement can’t be overlooked.

Respond and other comparable libraries (like Vue.js) are turning into the true decision for bigger organizations that require complex improvement where a more oversimplified approach (like utilizing a WordPress subject) will not fulfill the prerequisites.

Regardless of that, SEOs didn’t at first hug libraries like Respond because of web crawlers attempting to actually deliver JavaScript, with content accessible inside the HTML source being the inclination.

In any case, advancements in both how Google and Respond can deliver JavaScript have worked on these intricacies, bringing about Search engine optimization being the blocker for utilizing Respond.

In any case, a few intricacies remain, which I’ll go through in this aide.

We’ll cover on that note, this:

  • What React is
  • Rendering with React
  • How Google processes pages
  • Common SEO issues with React

But first, what is React?

Respond is an open-source JavaScript library created by Meta (previously Facebook) for building web and versatile applications. The primary elements of Respond are that it is explanatory, is part-based, and permits simpler control of the DOM.

The least difficult method for understanding the parts is by considering their modules, as for WordPress. They permit engineers to rapidly construct a plan and add usefulness to a page utilizing part libraries like MUI or Tailwind UI.

On the off chance that you need the full lowdown on why engineers love to Respond, begin here:

Rendering with React, a short history

Respond executes an Application Shell Model, meaning by far most of the content, while possibly not all, will be Client-side Delivered (CSR) as a matter of course.

CSR implies the HTML basically contains the Respond JS library instead of the server sending the whole page’s items inside the underlying HTTP reaction from the server (the HTML source).

It will likewise incorporate different JavaScript containing JSON information or connections to JS records that contain Respond parts. You can rapidly tell a site is client-side delivered by checking the HTML source. That’s what to do, right-click and select “View Page Source” (or CTRL + U/CMD + U).

In the event that you don’t see many lines of HTML there, the application is logical client-side delivering.

Notwithstanding, when you examine the component by right-clicking and choosing “Assess component” (or F12/CMD + ⌥ + I), you’ll see the DOM produced by the program (where the program has delivered JavaScript).

The outcome is you’ll then, at that point, see the site has a ton of HTML:

Note the appMountPoint ID on the first. You’ll ordinarily see a component like that on a solitary page application (SPA), so a library like Respond knows where it ought to infuse HTML. Innovation discovery instruments, e.g., Wappalyzer, are additionally perfect at recognizing the library.

Stunningly better, you can look through both the Crude and Delivered HTML to understand what content is explicitly being delivered client-side. In the beneath model, you can see this site is client-side delivering key page content, for example, the  tag.

Sites made utilizing Respond contrast from the more conventional methodology of leaving the truly difficult work of delivering content on the server utilizing dialects like PHP — called Server-side Delivering (SSR).

The above shows the server delivering JavaScript into HTML with Respond (more on that in no time). The idea is no different for destinations working with PHP (like WordPress). It’s simply PHP being transformed into HTML as opposed to JavaScript.

Before SSR, designers kept it considerably less difficult.

They would make static HTML reports that didn’t change, have them on a server, and afterward send them right away. The server didn’t have to deliver anything, and the program frequently had very little to deliver.

SPAs (counting those utilizing Respond) are currently completing the cycle back to this static methodology. They’re currently pre-delivering JavaScript into HTML before a program demands the URL. This approach is called Static Site Age (SSG), otherwise called Static Delivering.

Practically speaking, SSR and SSG are comparable.

The key contrast is that delivering occurs with SSR when a program demands a URL versus a structure pre-delivering content at fabricating time with SSG (when designers convey new code or a web administrator changes the website’s substance).

SSR can be more powerful yet slower because of extra inactivity while the server delivers the substance prior to sending it to the client’s program.

SSG is quicker, as the substance has proactively been delivered, meaning it very well may be served to the client right away (meaning a faster TTFB).

How Google processes pages

To comprehend the reason why Respond’s default client-side delivering approach causes Web optimization issues, you first need to realize how Google creeps, cycles, and records pages.

We can sum up the nuts and bolts of how this functions in the steps:

  1. Crawling – Googlebot sends GET requests to a server for the URLs in the crawl queue and saves the response contents. Googlebot does this for HTML, JS, CSS, image files, and more.
  2. Processing – This includes adding URLs to the crawl queue found within <a href> links within the HTML. It also includes queuing resource URLs (CSS/JS) found within <link> tags or images within <img src> tags. If Googlebot finds a noindex tag at this stage, the process stops, Googlebot won’t render the content, and Caffeine (Google’s indexer) won’t index it.
  3. Rendering – Googlebot executes JavaScript code with a headless Chromium browser to find additional content within the DOM, but not the HTML source. It does this for all HTML URLs.
  4. Indexing – Caffeine takes the information from Googlebot, normalizes it (fixes broken HTML), and then tries to make sense of it all, precomputing some ranking signals ready for serving within a search result.

By and large, issues with Respond and other JS libraries have been because of Google not taking care of the delivering step well.

A few models include:

  • Not rendering JavaScript – It’s an older issue, but Google only started rendering JavaScript in a limited way in 2008. However, it was still reliant on a crawling scheme for JavaScript sites created in 2009. (Google has since deprecated the scheme.)
  • The rendering engine (Chromium) is out of date – This resulted in a lack of support for the latest browser and JavaScript features. If you used a JavaScript feature that Googlebot didn’t support, your page might not render correctly, which could negatively impact your content’s indexing.
  • Google had a rendering delay – In some cases, this could mean a delay of up to a few weeks, slowing down the time for changes to the content to reach the indexing stage. This would have ruled out relying on Google to render content for most sites.

Fortunately, Google has now settled the greater part of these issues. Googlebot is currently evergreen, meaning it generally upholds the most recent elements of Chromium.

Moreover, the delivery delay is presently five seconds, as declared by Martin Splitt at the Chrome Designer Highest point in November 2019:

This all sounds positive. However, is client-side delivering and passing on Googlebot to deliver content the right system?

The response is probably still no.

Common SEO issues with React

In the beyond five years, Google has advanced its treatment of JavaScript content, however altogether client-side delivered locales present different issues that you want to consider.

It’s vital to take note that you can beat all issues with Respond and Website optimization.

Respond JS is an improvement instrument. Respond is the same as some other instrument inside an improvement stack, whether that is a WordPress module or the CDN you pick. How you design it will conclude whether it reduces or improves Web optimization.

At last, Respond is great for Website optimization, as it further develops client experience. You simply have to ensure you think about the accompanying normal issues.

1. Pick the right rendering strategy

The main issue you’ll have to handle with Respond is the way it renders content.

As referenced, Google is perfect at delivering JavaScript these days. However, tragically, that isn’t true with other web indexes. Bing has some help with JavaScript delivering, despite the fact that its productivity is obscure. Other web search tools like Baidu, Yandex, and others offer restricted help.

SIDENOTE. This restriction doesn’t just affect web search tools. Aside from website reviewers, Search engine optimization instruments that slither the web and give basic information on components like a website’s backlinks don’t deliver JavaScript. This can essentially affect the nature of the information they give. The main special case is Ahrefs, which has been delivering JavaScript across the web beginning around 2017 and as of now delivers north of 200 million pages each day.

Presenting this obscure forms a decent case for choosing a server-side delivered answer to guarantee that all crawlers can see the site’s substance.

Moreover, delivering content on the server has another significant advantage: load times.

Load times

Delivering JavaScript is serious on the central processor; this makes enormous libraries like Respond slow to stack and become intuitive for clients. You’ll by and large see Center Web Vitals, for example, Time to Intuitive (TTI), being a lot higher for SPAs — particularly on versatile, the essential way clients consume web content.

In any case, after the underlying render by the program, ensuing burden times will generally be faster because of the accompanying:

  • Client-side rendering is not causing a full-page refresh, meaning the library only needs loading once.
  • React’s diffing algorithm only changes HTML in the DOM that has changed state—resulting in the browser only re-rendering content that has changed.

Contingent upon the number of pages seen per visit, this can bring about field information being positive in general.

In any case, on the off chance that your webpage has a low number of pages seen per visit, you’ll battle to get positive field information for all Center Web Vitals.


The most ideal choice is to decide on SSR or SSG principally due to:

  • Faster initial renders.
  • Not having to rely on search engine crawlers to render content.
  • Improvements in TTI due to less JavaScript code for the browser to parse and render before becoming interactive.

Executing SSR inside Respond is conceivable by means of ReactDOMServer. Be that as it may, I suggest utilizing a Respond system called Next.js and utilizing its SSG and SSR choices. You can likewise execute CSR with Next.js, however, the system pushes clients toward SSR/SSG because of speed.

Next.js upholds what it calls “Programmed Static Improvement.” by and by, this implies you can have a few pages on a website that utilizes SSR, (for example, a record page) and different pages utilizing SSG (like your blog).

The outcome: SSG and quick TTFB for non-dynamic pages, and SSR as a reinforcement-delivering technique for dynamic substance.

SIDENOTE. You might have caught wind of Respond Hydration with ReactDOM.hydrate(). This is where content is conveyed through SSG/SSR and afterward transforms into a client-side delivered application during the underlying render. This might be the undeniable decision for dynamic applications in the future as opposed to SSR. Notwithstanding, hydration presently works by stacking the whole Respond library and afterward connecting occasion overseers to HTML that will change. Respond then keeps HTML between the program and server in a state of harmony. At present, I can’t suggest this approach since it actually has negative ramifications for web vitals like TTI for the underlying render. Halfway Hydration might determine this later on by just hydrating basic pieces of the page (like ones inside the program viewport) as opposed to the whole page; up to that point, SSR/SSG is the better choice.

Since we’re discussing speed, I’ll give you a raw deal by not referencing alternate ways Next.js upgrades the basic delivering way for Respond applications with highlights like:

  • Image optimization – This adds width and height <img> attributes and srcset, lazy loading, and image resizing.
  • Font optimization – This inlines critical font CSS and adds controls for font display.
  • Script optimization – This lets you pick when a script should be loaded: before/after the page is interactive or lazy.
  • Dynamic imports – If you implement best practices for code splitting, this feature makes it easier to import JS code when required rather than leaving it to load on the initial render and slowing it down.

Speed and positive Center Web Vitals are a positioning variable, but a minor one. Next.js highlights make it simpler to make extraordinary web encounters that will give you an upper hand.

2. Use status codes correctly

A typical issue with most SPAs is they don’t accurately report status codes. This is because the server isn’t stacking the page — the program is. You’ll normally see issues with:

  • No 3xx redirects, with JavaScript redirects being used instead.
  • 4xx status codes not reporting for “not found” URLs.

You can see beneath I ran a test on a Respond site with This page ought to clearly be a 404 yet, all things considered, returns a 200 status code. This is known as a delicate 404.

The gamble here is that Google might choose to record that page (contingent upon its substance). Google could then serve this to clients, or it’ll be utilized while assessing a site.

Moreover, detailing 404s assists SEOs with auditing a site. In the event that you unintentionally inside connect to a 404 page and it’s returning a 200 status code, rapidly recognizing the region with an examining device might turn out to be significantly more testing.

There are several methods for addressing this issue. Assuming you’re client-side delivering:

  1. Use the React Router framework.
  2. Create a 404 component that shows when a route isn’t recognized.
  3. Add a noindex tag to “not found” pages.
  4. Add a <h1> with a message like “404: Page Not Found.” This isn’t ideal, as we don’t report a 404 status code. But it will prevent Google from indexing the page and help it recognize the page as a soft 404.
  5. Use JavaScript redirects when you need to change a URL. Again, not ideal, but Google does follow JavaScript redirects and pass ranking signals.

On the off chance that you’re utilizing SSR, Next.js simplifies this with reaction partners, which let you set anything that status code you need, including 3xx sidetracks or a 4xx status code. The methodology I framed utilizing Respond Switch can likewise be tried while utilizing Next.js. In any case, in the event that you’re utilizing Next.js, you’re probably additionally carrying out SSR/SSG.

3. Avoid hashed URLs

This issue isn’t as normal for Respond, however, it’s fundamental to stay away from hash URLs like the accompanying:

By and large, Google won’t see anything after the hash. These pages will be viewed as


SPAs with client-side steering ought to carry out the Set of experiences Programming interface to change pages.

You can do this generally effectively with both Respond Switch and Next.js.

4. Use <a href> links where relevant

A typical misstep with SPAs is utilizing a  or a  to change the URL. This isn’t an issue with Respond itself, yet the way that the library is utilized.

Doing this presents an issue with web indexes. As referenced before, when Google processes a URL, it searches for extra URLs to creep inside components.

On the off chance that the component is missing, Google won’t slither the URLs and pass PageRank.


The arrangement is to incorporate connections to URLs that you believe Google should find.

Checking whether you’re connecting to a URL accurately is simple. Examine the component that is inside connections and really look at the HTML to guarantee you’ve included joins.

As in the above model, you might have an issue on the off chance that they aren’t.

In any case, it’s fundamental to comprehend that absent joins aren’t generally an issue. One advantage of CSR is that when content is useful to clients yet not web crawlers, you can change the substance client-side and exclude the interface.

In the above model, the site utilizes a faceted route that connects to possibly a huge number of blends of channels that aren’t helpful for a web search tool to slither or file.

Stacking these channels client-side checks out here, as the site will ration slither spending plan by not adding joins for Google to creep.

Next.js makes this simple with its connection part, which you can design to permit the client-side route.

In the event that you’ve chosen to execute a completely CSR application, you can change URLs with Respond Switch utilizing onClick and the Set of experiences Programming interface.

5. Avoid lazy loading essential HTML

It’s normal for destinations created with Respond to infuse content into the DOM when a client snaps or drifts over a component — essentially on the grounds that the library makes that simple to do.

This isn’t innately terrible, however happy added to the DOM this way won’t be seen via web search tools. Assuming the substance infused incorporates significant literary substance or inner connections, this may adversely influence:

  • How well the page performs (as Google won’t see the content).
  • The discoverability of other URLs (as Google won’t find the internal links).

Here is a model on a Respond JS site I as of late evaluated. Here, I’ll show a notable online business brand with significant interior connections inside its faceted route.

Be that as it may, a modular appearance of the route on a portable was infused into the DOM when you clicked a “Channel” button. Watch the second  inside the HTML underneath to see this practically speaking:


It isn’t difficult to Detect these issues. Furthermore, supposedly, no instrument will straightforwardly inform you concerning them.

All things being equal, you ought to check for normal components, for example

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

You’ll then, at that point, need to examine the component on them and watch what occurs with the HTML as you open/close them by clicking or drifting (as I have done in the above GIF).

Assume you notice JavaScript is adding HTML to the page. All things considered, you’ll have to work with the engineers. This is so that as opposed to infusing the substance into the DOM, it’s incorporated inside the HTML as a matter of course and is covered up and shown through CSS utilizing properties like permeability: stowed away; or show: none;

6. Don’t forget the fundamentals

While there are extra Web optimization contemplations with Respond applications, that doesn’t mean different essentials don’t matter.

You’ll in any case have to ensure your Respond applications follow best practices for:

  • Canonicalization
  • Structured data
  • XML sitemaps
  • Mobile-first
  • Website structure
  • Title tags
  • Semantic HTML

Final thoughts

Tragically, working with Respond applications adds to the generally extensive rundown of issues a specialized Website optimization necessities to check. Yet, on account of structures like Next.js, it makes crafted by a Search engine optimization significantly more clear than what it was by and large. Give a read to learn What Are Core Web Vitals & How Can You Improve Them?

Ideally, this guide has assisted you with a better comprehension of the extra contemplations you really want to make as a Web optimization while working with Respond applications.

Total Views: 56 ,

Leave a Reply

Your email address will not be published. Required fields are marked *