The Ultimate Guide to React useWebSocket

React is a popular JavaScript library used for building user interfaces. With React, developers can create reusable UI components that can be easily composed to build complex applications. One of the most powerful features of React is its ability to handle real-time data updates using websockets. In this article, we will explore the use of React useWebSocket hook and how it can be used to build real-time applications.

What is React useWebSocket?

React useWebSocket is a custom hook that allows developers to easily integrate websockets into their React applications. It provides a simple and declarative way to handle websocket connections and data updates. With useWebSocket, developers can subscribe to websocket events, send data to the server, and handle errors and connection status changes.

Setting up a WebSocket connection

The first step in using React useWebSocket is to set up a WebSocket connection. This can be done using the WebSocket API provided by the browser. Here is an example of how to set up a WebSocket connection:

const socket = new WebSocket('ws://localhost:8080');

socket.addEventListener('open', (event) => {console.log('WebSocket connection opened');});

socket.addEventListener('message', (event) => {console.log('Received message:',;});

socket.addEventListener('error', (event) => {console.error('WebSocket error:', event);});

socket.addEventListener('close', (event) => {console.log('WebSocket connection closed:', event.code, event.reason);});

In this example, we create a new WebSocket object and connect to the server at ‘ws://localhost:8080’. We add event listeners for the ‘open’, ‘message’, ‘error’, and ‘close’ events. When the connection is opened, we log a message to the console. When a message is received, we log the message data to the console. If an error occurs, we log the error object to the console. When the connection is closed, we log the close code and reason to the console.

Using React useWebSocket

Now that we have a WebSocket connection set up, we can use React useWebSocket to handle the connection and data updates. Here is an example of how to use the useWebSocket hook:

import { useWebSocket } from 'react-use-websocket';

const MyComponent = () => {const { sendMessage, lastMessage, readyState } = useWebSocket('ws://localhost:8080');

const handleClick = () => {sendMessage('Hello, server!');};

return (<div><p>WebSocket connection status: {readyState}</p><p>Last message received: {lastMessage?.data}</p><button onClick={handleClick}>Send message to server</button></div>);};

In this example, we import the useWebSocket hook from the ‘react-use-websocket’ library. We then create a new component that uses the hook to handle the WebSocket connection. The hook returns an object that contains a sendMessage function, a lastMessage object, and a readyState value.

The sendMessage function can be used to send data to the server. In this example, we send the string ‘Hello, server!’ when the button is clicked. The lastMessage object contains the last message received from the server. The readyState value indicates the current state of the WebSocket connection (0 = connecting, 1 = open, 2 = closing, 3 = closed).

Handling WebSocket events

React useWebSocket also provides a way to handle WebSocket events using callbacks. Here is an example of how to handle the ‘message’, ‘error’, and ‘close’ events:

import { useWebSocket } from 'react-use-websocket';

const MyComponent = () => {const onMessage = (event) => {console.log('Received message:',;};

const onError = (event) => {console.error('WebSocket error:', event);};

const onClose = (event) => {console.log('WebSocket connection closed:', event.code, event.reason);};

const { readyState } = useWebSocket('ws://localhost:8080', {onMessage,onError,onClose,});

return (<p>WebSocket connection status: {readyState}</p>);};

In this example, we define three callback functions for the ‘message’, ‘error’, and ‘close’ events. We then pass these callbacks to the useWebSocket hook using the options object. The hook will call these callbacks when the corresponding events occur.

Using React useWebSocket with Redux

If you are using Redux to manage your application state, you can integrate React useWebSocket with Redux using a middleware. Here is an example of how to create a WebSocket middleware:

import { useWebSocket } from 'react-use-websocket';

const socketMiddleware = () => {let socket = null;

const onOpen = (store) => (event) => {console.log('WebSocket connection opened');};

const onClose = (store) => (event) => {console.log('WebSocket connection closed:', event.code, event.reason);};

const onMessage = (store) => (event) => {const data = JSON.parse(;store.dispatch({ type: 'WEBSOCKET_MESSAGE', payload: data });};

return (store) => (next) => (action) => {switch (action.type) {case 'WEBSOCKET_CONNECT':if (socket !== null) {socket.close();}

socket = new WebSocket(action.payload);

socket.addEventListener('open', onOpen(store));socket.addEventListener('close', onClose(store));socket.addEventListener('message', onMessage(store));


case 'WEBSOCKET_SEND':socket.send(JSON.stringify(action.payload));break;

case 'WEBSOCKET_DISCONNECT':if (socket !== null) {socket.close();}

socket = null;break;

default:return next(action);}};};

export default socketMiddleware;

In this example, we define three callback functions for the ‘open’, ‘close’, and ‘message’ events. We also define a middleware function that creates a WebSocket connection when a ‘WEBSOCKET_CONNECT’ action is dispatched, sends data to the server when a ‘WEBSOCKET_SEND’ action is dispatched, and closes the connection when a ‘WEBSOCKET_DISCONNECT’ action is dispatched.

To use this middleware with Redux, you can add it to your store’s middleware array:

import { createStore, applyMiddleware } from 'redux';import socketMiddleware from './socketMiddleware';import rootReducer from './reducers';

const store = createStore(rootReducer,applyMiddleware(socketMiddleware()));


React useWebSocket is a powerful tool for building real-time applications with React. With useWebSocket, developers can easily handle WebSocket connections and data updates using a simple and declarative API. Whether you are building a chat application or a real-time dashboard, React useWebSocket can help you build a responsive and scalable application.


  1. What is a WebSocket?

    A WebSocket is a protocol for bi-directional, real-time communication between a client and a server over a single TCP connection. Unlike HTTP, which is a request-response protocol, WebSockets allow both the client and server to send messages to each other at any time.

  2. What are the advantages of using WebSockets?

    WebSockets provide several advantages over traditional HTTP requests:

    • Real-time communication: WebSockets allow for real-time communication between the client and server, enabling applications like chat rooms, real-time games, and real-time dashboards.
    • Reduced latency: Because WebSockets use a single TCP connection, there is less overhead and latency compared to HTTP requests.
    • Less server load: WebSockets enable server-side push, which means the server can send updates to clients without the need for clients to poll the server for updates.
  3. What is a custom hook in React?

    A custom hook is a JavaScript function that uses one or more of the built-in React hooks (like useState or useEffect) to provide a specific functionality to a React component. Custom hooks allow developers to encapsulate complex logic and reuse it across multiple components.