diff --git a/client/src/App.tsx b/client/src/App.tsx
index 86c226f..69dd466 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -20,6 +20,7 @@
 import { json, LoaderFunctionArgs, Outlet, redirect } from 'react-router-dom';
 
 import WelcomeAnimation from './components/welcome';
+import { getAccessToken } from './utils/auth';
 import { apiUrl } from './utils/constants';
 
 export async function checkSetupStatus(): Promise<boolean> {
@@ -38,7 +39,7 @@
 }
 
 const App = () => {
-  const [displayWelcome, setDisplayWelcome] = useState<boolean>(true);
+  const [displayWelcome, setDisplayWelcome] = useState<boolean>(getAccessToken() === undefined);
 
   console.log('App render');
 
diff --git a/client/src/components/ConversationListItem.tsx b/client/src/components/ConversationListItem.tsx
index 2861eb8..30dc7bf 100644
--- a/client/src/components/ConversationListItem.tsx
+++ b/client/src/components/ConversationListItem.tsx
@@ -50,7 +50,7 @@
   const pathId = conversationId || contactId;
   const isSelected = conversation.getDisplayUri() === pathId;
   const navigate = useNavigate();
-  const [userId] = useState(conversation?.getFirstMember()?.contact.getUri());
+  const userId = conversation?.getFirstMember()?.contact.getUri();
   const uri = conversation.getId() ? `/conversation/${conversation.getId()}` : `/add-contact/${userId}`;
   return (
     <Box onContextMenu={contextMenuHandler.handleAnchorPosition}>
diff --git a/client/src/pages/Messenger.tsx b/client/src/pages/Messenger.tsx
index fd8dc99..47567cf 100644
--- a/client/src/pages/Messenger.tsx
+++ b/client/src/pages/Messenger.tsx
@@ -16,8 +16,8 @@
  * <https://www.gnu.org/licenses/>.
  */
 import { Stack } from '@mui/material';
-import { Contact, Conversation } from 'jami-web-common';
-import { useEffect, useState } from 'react';
+import { Contact, Conversation, WebSocketMessageType } from 'jami-web-common';
+import { useContext, useEffect, useState } from 'react';
 
 //import Sound from 'react-sound';
 import ConversationList from '../components/ConversationList';
@@ -26,14 +26,18 @@
 import LoadingPage from '../components/Loading';
 import NewContactForm from '../components/NewContactForm';
 import { useAuthContext } from '../contexts/AuthProvider';
-import { useAppSelector } from '../redux/hooks';
+import { WebSocketContext } from '../contexts/WebSocketProvider';
+import { setRefreshFromSlice } from '../redux/appSlice';
+import { useAppDispatch, useAppSelector } from '../redux/hooks';
 import { MessengerRouteParams } from '../router';
 import { useUrlParams } from '../utils/hooks';
 import AddContactPage from './AddContactPage';
 
 const Messenger = () => {
   const { refresh } = useAppSelector((state) => state.userInfo);
+  const dispatch = useAppDispatch();
   const { account, axiosInstance } = useAuthContext();
+  const webSocket = useContext(WebSocketContext);
 
   const [conversations, setConversations] = useState<Conversation[] | undefined>(undefined);
   const [searchQuery, setSearchQuery] = useState('');
@@ -58,6 +62,16 @@
   }, [axiosInstance, accountId, refresh]);
 
   useEffect(() => {
+    if (!webSocket) {
+      return;
+    }
+
+    const conversationMessageListener = () => dispatch(setRefreshFromSlice());
+    webSocket.bind(WebSocketMessageType.ConversationMessage, conversationMessageListener);
+    return () => webSocket.unbind(WebSocketMessageType.ConversationMessage, conversationMessageListener);
+  }, [webSocket, dispatch]);
+
+  useEffect(() => {
     if (!searchQuery) return;
     const controller = new AbortController();
     // TODO: Type properly https://git.jami.net/savoirfairelinux/jami-web/-/issues/92
diff --git a/client/src/utils/auth.ts b/client/src/utils/auth.ts
index 822771c..73b5522 100644
--- a/client/src/utils/auth.ts
+++ b/client/src/utils/auth.ts
@@ -80,9 +80,8 @@
   }
 }
 
-export function getAccessToken(): string {
-  const accessToken: string | null = localStorage.getItem('accessToken');
-  return accessToken ?? '';
+export function getAccessToken(): string | undefined {
+  return localStorage.getItem('accessToken') ?? undefined;
 }
 
 export function setAccessToken(accessToken: string): void {
