How to use React's useTransition Hook

  • 23 Oct, 2023
  • read

React is a popular JavaScript library used for building user interfaces, and it provides a set of hooks that enable developers to manage state and lifecycle in a more efficient and organized way. One of the most powerful hooks in React is the useTransition hook, which allows you to manage asynchronous updates and control the user experience during loading states. In this article, we will explore the use cases and benefits of using the useTransition hook in your React applications.

What is the useTransition Hook?

The useTransition hook is a built-in React hook introduced in React 18. It enables you to create a smooth transition between different states in your React components, especially during async updates. It allows you to define a loading state and manage how your UI behaves while waiting for data or performing async operations.

Unlike other hooks like useState or useEffect, the useTransition hook is not used to manage state directly. Instead, it provides a way to coordinate between synchronous rendering and the update of state that happens asynchronously. It gives you control over how the UI interacts with data fetching or other async operations.

How the useTransition Hook Works

The useTransition hook takes two optional parameters: config and prefetchCallback. Let’s take a closer look at each of these parameters and their use cases.


The config parameter defines the behavior of the transition. It allows you to control some aspects of the transition, such as its priority and timeout. By default, config is an empty object.

Here’s an example of a config object:

const config = {
  timeoutMs: 3000, // Specifies the maximum amount of time for the transition to occur.
  busyDelayMs: 500, // Specifies the amount of time to wait before transitioning to the busy state.
  busyMinDurationMs: 1000 // Specifies the minimum amount of time to keep the busy state.


The prefetchCallback parameter is an optional function that allows you to prefetch data before starting the transition. It’s useful when you want to fetch data in advance, such as when a user hovers over a specific component.

Here’s an example of using prefetchCallback:

const transition = useTransition(config, prefetchCallback);

Common Use Cases for the useTransition Hook

Now that we understand the basics of the useTransition hook let’s explore some common use cases where it can be beneficial.

1. Smooth Loading States

When fetching data from an API or performing expensive computations, it’s important to provide a smooth loading experience for users. The useTransition hook allows you to define loading states and control how your UI behaves during those states.

import { useTransition } from 'react';

const MyComponent = () => {
  const [isLoading, setLoading] = useState(false);
  const transition = useTransition();

  const fetchData = async () => {
    await transition.start(() => fetchDataFromAPI());

  return (
      {isLoading ? (
        <Spinner /> // Show a spinner while data is loading
      ) : (
        <DataComponent /> // Render the component with fetched data
      <button onClick={fetchData}>Fetch Data</button>

In the example above, the useTransition hook is used to coordinate the fetching of data and update the loading state accordingly. During the transition, the spinning indicator is shown to indicate that the data is being fetched.

2. Managing User Input Delay

In situations where you expect a delay between user input and the result, the useTransition hook can be used to manage the UI’s response to user input and prevent jitteriness or flickering.

import { useTransition, useState } from 'react';

const TextInput = () => {
  const [text, setText] = useState('');
  const transition = useTransition();

  const handleChange = async (event) => {
    const newText =;
    await transition.start(() => updateText(newText));

  return <input value={text} onChange={handleChange} />;

In this example, the useTransition hook is used to manage the delay between each keypress and the actual update of the text. This prevents unnecessary rerendering and improves the user experience.

3. Optimistic UI Updates

Optimistic UI updates are a technique used to provide an immediate response to user actions while waiting for the server’s response. The useTransition hook can be used to implement optimistic UI updates and display an optimistic UI state during async operations.

import { useTransition, useState } from 'react';

const LikeButton = ({ postId }) => {
  const [liked, setLiked] = useState(false);
  const transition = useTransition();

  const handleLike = async () => {
    await transition.start(() => likePost(postId));

  return (
    <button onClick={handleLike}>
      {liked ? 'Liked' : 'Like'}

In this example, the useTransition hook is used to handle the optimistic UI update when the user likes or unlikes a post. It immediately updates the UI to reflect the new state and then performs the actual server request in the background without blocking the UI.


In this article, we explored the useTransition hook in React and its use cases. We learned that the useTransition hook is a powerful tool for managing asynchronous updates and controlling the user experience during loading states. We saw examples of how to use useTransition to create smooth loading states, manage user input delay, and implement optimistic UI updates.

Using the useTransition hook can greatly improve the user experience by providing seamless transitions and better control over how your UI behaves during async updates. It’s an essential tool for building performant and user-friendly React applications.

Keep in mind that the examples provided in this article are simplified for demonstration purposes, and it’s important to adapt the code to your specific use cases and requirements.


Disclaimer: This blog post was written by the AI assistant and the code examples were created for this article. External references were used to gather information on the topic and ensure accuracy.