Server-side Rendering (SSR) vs. Client-side Rendering (CSR) in Next.js: When and Why to Use Each Approach


In the world of web development, rendering plays a pivotal role in shaping the user experience. It's not just about displaying content; it's about how that content is delivered to the user's browser. This choice can significantly impact factors such as page load times, search engine optimization (SEO), and overall user satisfaction. When working with Next.js, a popular React framework for building web applications, you can choose between two primary rendering methods: Server-side Rendering (SSR) and Client-side Rendering (CSR). This article aims to explore these two approaches comprehensively, providing insights into when and why you should opt for one over the other.

Understanding SSR:

Server-side Rendering, often abbreviated as SSR, is a rendering technique where the server generates the HTML for a web page and sends it to the client. The client's browser receives a fully rendered page, ready to be displayed. This approach contrasts with the traditional Client-side Rendering, where the browser downloads a minimal HTML file and relies on JavaScript to fetch, process, and render the content.

Benefits of SSR:

SSR offers several advantages that make it an attractive choice in many scenarios:

  1. SEO Optimization: One of the most compelling reasons to opt for SSR is its inherent SEO benefits. Search engines like Google can efficiently crawl and index SSR-rendered pages since all content is present in the initial HTML response. This improves your website's visibility in search engine results, a crucial factor for content-heavy websites, e-commerce platforms, and blogs.

  2. Improved Initial Load Performance: SSR can enhance the initial load performance of your web application. Since the server pre-renders the HTML, users see meaningful content sooner, reducing the time to first contentful paint (FCP). This quick initial rendering provides a smoother user experience, especially on slower networks or less capable devices.

  3. Social Sharing and Link Previews: SSR-rendered pages are naturally equipped for social sharing. When you share a link on social media, platforms like Facebook and Twitter can extract meaningful previews directly from the HTML, enhancing your content's appeal.

To implement SSR in Next.js, you'll typically use the built-in features that simplify the process. It involves creating special components and routes that are pre-rendered on the server, ensuring SEO benefits and faster initial loading. To make it even sweeter, according to the official docs, next.js uses a server component by default.

This means that, when writing a normal react/next function, you're using server components.

// pages/index.js

import React from 'react';

// This function gets called at build time on the server.
export async function getServerSideProps() {
  // Fetch data from an API or perform any other server-side tasks.
  const data = await fetchDataFromAPI();

  // Pass data as props to the page component.
  return {
    props: {

function Home({ data }) {
  // Data from getServerSideProps is available as props.
  return (
      <h1>Server-Side Rendering in Next.js</h1>

export default Home;

In this example:

  1. We have a Next.js page component called Home in the pages directory.

  2. We export an async function called getServerSideProps. This function is executed on the server at build time and can be used to fetch data or perform any other server-side tasks.

  3. Inside getServerSideProps, we fetch some data from an API (you should replace this with your own data-fetching logic) and pass it as a prop to the Home component.

  4. In the Home component, we can access the data prop and render it as part of the page.

When a user accesses the page, Next.js will run getServerSideProps on the server, fetch the data, and send the fully-rendered HTML to the client.

This is a basic example of server-side rendering in Next.js.

Client-side Rendering (CSR):

Client-side Rendering (CSR), on the other hand, takes a different approach. With CSR, the initial HTML returned by the server is minimal, often referred to as a "skeleton" or "shell" of the web page. This means the page will be rendered, but some contents in it are yet to be fetched. Once the full content is fetched, it's then rendered using JavaScript after the page has loaded in the browser.

An example of a webiste using csr

Benefits of CSR:

Interactivity: CSR shines when your application requires a high level of interactivity. This approach allows for dynamic content loading, real-time updates, and seamless user interactions. It's ideal for single-page applications (SPAs) and complex web apps.

2. Reduced Server Load: Since the server generates minimal HTML and leaves the rest to the client-side JavaScript, this approach can reduce server load. This can be beneficial for websites with high traffic.

3. Faster Navigation: Once the initial HTML is loaded, CSR can offer faster navigation between pages, as only the necessary content is fetched when the user interacts with the application.

Despite these advantages, CSR comes with some trade-offs. One significant drawback is the potential for SEO challenges, because since the page only loads the initial HTML it's hard for SEO crawlers to crawl the full content of your website, thus making it difficult for your website to rank.

Here's an example of how to fetch, and render content using CSR in next.js

'use client' //as per nextjs V 14, adding use client is a must if you're to use any client hooks such as useState.

import React, { useState, useEffect } from 'react';

function App() {
  const [data, setData] = useState([]);

  useEffect(() => {
    // Fetch data from an API or perform other client-side tasks.
      .then((result) => {
      .catch((error) => {
        console.error("Error fetching data:", error);
  }, []);

  return (
      <h1>Client-Side Rendering in React</h1>
        {, index) => (
          <li key={index}>{item}</li>

export default App;

In this example:

  1. We have a React component named App.

  2. Inside the component, we use the useState and useEffect hooks to manage the data and perform asynchronous data fetching.

  3. In the useEffect hook, we fetch data from an API (or any client-side task you need to perform) when the component is mounted. We update the data state once the data is fetched.

  4. The fetched data is then rendered in the component. In this case, we're rendering a list of items.

Client-side rendering (CSR) is performed on the client (browser), and the initial HTML sent to the client is minimal. The client JavaScript code is responsible for rendering and updating the content on the page, making it suitable for interactive and dynamic applications.

When to use SSR or CRS:

Server-Side Rendering (SSR) and Client-Side Rendering (CSR) are two different approaches to rendering web pages in a web application. The choice between SSR and CSR depends on various factors, and there is no one-size-fits-all answer. The decision on when to use SSR or CSR should be based on your specific project requirements, performance considerations, and user experience goals. Here are some guidelines to help you determine when to use each approach:

1. SSR (Server-Side Rendering):

- Use SSR when you want to improve initial page load performance and SEO: SSR can generate fully rendered HTML on the server and send it to the client, which can lead to faster initial page loads and better search engine optimization because search engines can easily crawl and index the content.

- Use SSR for better support of older browsers: Some older browsers may not fully support client-side JavaScript rendering, so using SSR can provide a more consistent experience.

2. CSR (Client-Side Rendering):

- Use CSR when you want to build highly interactive web applications: CSR is well-suited for applications where user interactions and dynamic updates are essential. It allows you to fetch and render data on the client side without full page reloads.

- Use CSR when you have a well-structured API: If your backend provides a RESTful or GraphQL API that allows you to fetch data efficiently, CSR can be a good choice because it enables the client to make API requests and render content dynamically.

- Use CSR when you want to reduce server load: If you have a high volume of traffic or want to minimize server load, CSR can offload rendering tasks to the client, reducing the server's rendering workload.

In many cases, a combination of both SSR and CSR can be used in a web application. This approach is often referred to as "Hybrid Rendering" and allows you to leverage the strengths of each method for different parts of your application. For example, you can use SSR for the initial page load and SEO benefits and then transition to CSR for highly interactive sections of your application.

Conclusion :

There are lots of ways to fetch, and render data in next.js and SSR & CSR are the two most popular ones. While this article is just to provide a quick overview and how to use them, ultimately, the decision should be based on a careful analysis of your project's requirements, performance goals, and the trade-offs between SSR and CSR.

Thank you for reading, and I hope you enjoyed this article.