Effortless Data Fetching with SWR: A Comprehensive Guide for React Developers

As web applications become increasingly complex, the importance of efficient data fetching only grows. Traditional solutions, such as Redux or manual Fetch requests, can be time-consuming to set up and even more so to maintain.

Enter SWR, a simple yet powerful library that streamlines data fetching and optimizes caching behavior for React applications. In this comprehensive guide, we’ll dive into all things SWR: how to set it up, how to use it for optimized data fetching, and how to take advantage of real-time data updates.

What is SWR?

SWR, short for stale-while-revalidate, is a library that helps manage data fetching and caching within React applications. It allows developers to fetch data from various sources such as APIs, and optimize network requests using a caching strategy, all with little to no configuration. SWR also handles real-time updates by automatically revalidating data when it becomes stale or outdated.

How to Install SWR

To get started with SWR, we need to install it through NPM or Yarn:

$ npm install swr


$ yarn add swr

Using SWR for Data Fetching

Now that we have SWR installed, let’s see how we can use it to fetch data inside a React component. Let’s assume we have a simple API that returns an array of objects:

async function fetcher(url) {
  const res = await fetch(url);
  return res.json();
const { data, error } = useSWR('/api/data', fetcher);
if (error) return 
Failed to load data
; if (!data) return
; return ( <ul> {data.map((item) => ( <li key={item.id}>{item.name}</li> ))} </ul> );

So what’s going on in this code? First, we define an asynchronous function called `fetcher` that takes a URL and returns the parsed JSON response when called. Next, we use the `useSWR` hook to fetch data from our API endpoint at `/api/data`, using the `fetcher` function we defined earlier.

The `useSWR` hook returns an object with two properties: `data` and `error`. If the fetch was successful, `data` will contain the response data, and `error` will be null. If there was an error while fetching the data, `error` will contain the error message, and `data` will be null. If the data is still loading, both `data` and `error` will be null.

In the example above, we’re checking for `error` and `data`. If `error` contains a value, we display a message indicating that the data failed to load. If `data` is null, we display a message indicating that the data is still loading. If `data` contains a value, we map over the array and render each object item as an `li` element.

One of the most powerful features of SWR is that it automatically caches the response data and uses it for subsequent requests. This means that if we reload the page or revisit the same endpoint, SWR will first check its cache for the data and return it if it’s available. If the data is stale, SWR will fetch the data again in the background and re-render the component when it’s available.

Optimizing Caching Behavior with SWR

SWR’s caching behavior can be further optimized using various configuration options. For example, we can set a time to live for the cached data using the `refreshInterval` option, which specifies the number of milliseconds between automatic revalidation:

const { data } = useSWR('/api/data', fetcher, { refreshInterval: 5000 });

In this example, the data will be revalidated every five seconds.

Another useful option is `revalidateOnMount`, which revalidates the data when the component mounts:

const { data } = useSWR('/api/data', fetcher, { revalidateOnMount: true });

This can be useful for real-time data updates, as we’ll discuss in the next section.

Real-time Data Updates with SWR

SWR also supports real-time data updates using websockets, server-sent events, or any other protocol that can broadcast data updates to connected clients. In this example, we’ll use websockets to stream real-time updates to our data:

import { useEffect, useState } from 'react';
import useSWR from 'swr';
import io from 'socket.io-client';
const socket = io.connect('http://localhost:3001');
async function fetcher(url) {
  const res = await fetch(url);
  return res.json();
export default function RealTimeData() {
  const [data, setData] = useState([]);
  const { mutate } = useSWR('/api/data', fetcher);

  useEffect(() => {
    socket.on('data:update', (newData) => {
      // Update data when new data is received over the websocket
      setData((prevData) => [...prevData, newData]);
      // Revalidate SWR cache for the new data
  }, []);
  return (
      {data.map((item) => (
        <li key={item.id}>{item.name}</li>

In this example, we first import the `useEffect` and `useState` hooks from React, and the `io` method to connect to the websocket server. We then define the `fetcher` function that we used in the previous example, and create a new component called `RealTimeData`. Inside this component, we define a state variable called `data`, and use the `mutate` method returned by `useSWR` to refresh the cache when we receive new data over the websocket.

In the `useEffect` hook, we set up a listener for the `data:update` event, which is broadcast by the websocket server whenever new data is available. When we receive new data, we update the `data` state using the `setData` method, and revalidate the SWR cache using the `mutate` method.

Finally, we render the `data` array as a list of `li` elements, just like in the previous example.


SWR is a powerful tool for streamlining data fetching and optimizing caching behavior for React applications. With SWR, React developers can focus on building great user experiences rather than worrying about low-level networking details. Whether you’re building a simple CRUD app or a complex real-time dashboard, SWR has you covered.

We hope this comprehensive guide has helped you get started with SWR and shown you how to take advantage of its powerful features. If you have any questions or feedback, please feel free to leave a comment!