diff --git a/lib/handlers/user-infos-handler.react.js b/lib/handlers/user-infos-handler.react.js
index dcf76c734..09c2a0884 100644
--- a/lib/handlers/user-infos-handler.react.js
+++ b/lib/handlers/user-infos-handler.react.js
@@ -1,95 +1,102 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useFindUserIdentities,
   findUserIdentitiesActionTypes,
 } from '../actions/user-actions.js';
 import { useGetAndUpdateDeviceListsForUsers } from '../hooks/peer-list-hooks.js';
 import { usersWithMissingDeviceListSelector } from '../selectors/user-selectors.js';
+import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js';
 import { getMessageForException } from '../utils/errors.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 import {
   relyingOnAuthoritativeKeyserver,
   usingCommServicesAccessToken,
 } from '../utils/services-utils.js';
 
 function UserInfosHandler(): React.Node {
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   const userInfosWithMissingUsernames = React.useMemo(() => {
     const entriesWithoutUsernames = Object.entries(userInfos).filter(
       ([, value]) => !value.username,
     );
     return Object.fromEntries(entriesWithoutUsernames);
   }, [userInfos]);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const findUserIdentities = useFindUserIdentities();
 
   const requestedIDsRef = React.useRef(new Set<string>());
 
   React.useEffect(() => {
     const newUserIDs = Object.keys(userInfosWithMissingUsernames).filter(
       id => !requestedIDsRef.current.has(id),
     );
     if (!usingCommServicesAccessToken || newUserIDs.length === 0) {
       return;
     }
 
     const promise = (async () => {
       newUserIDs.forEach(id => requestedIDsRef.current.add(id));
       // 1. Fetch usernames from identity
       const identities = await findUserIdentities(newUserIDs);
 
       // 2. Fetch avatars and settings from auth keyserver
       if (relyingOnAuthoritativeKeyserver) {
         // TODO
       }
       newUserIDs.forEach(id => requestedIDsRef.current.delete(id));
 
       const newUserInfos = [];
       for (const id in identities) {
         newUserInfos.push({
           id,
           username: identities[id].username,
         });
       }
       return { userInfos: newUserInfos };
     })();
     void dispatchActionPromise(findUserIdentitiesActionTypes, promise);
   }, [
     dispatchActionPromise,
     findUserIdentities,
     userInfos,
     userInfosWithMissingUsernames,
   ]);
 
   const usersWithMissingDeviceList = useSelector(
     usersWithMissingDeviceListSelector,
   );
   const getAndUpdateDeviceListsForUsers = useGetAndUpdateDeviceListsForUsers();
+  const { socketState } = useTunnelbroker();
   React.useEffect(() => {
     if (
       !usingCommServicesAccessToken ||
-      usersWithMissingDeviceList.length === 0
+      usersWithMissingDeviceList.length === 0 ||
+      !socketState.isAuthorized
     ) {
       return;
     }
     void (async () => {
       try {
         await getAndUpdateDeviceListsForUsers(usersWithMissingDeviceList, true);
       } catch (e) {
         console.log(
           `Error getting and setting peer device list: ${
             getMessageForException(e) ?? 'unknown'
           }`,
         );
       }
     })();
-  }, [getAndUpdateDeviceListsForUsers, usersWithMissingDeviceList]);
+  }, [
+    socketState.isAuthorized,
+    getAndUpdateDeviceListsForUsers,
+    usersWithMissingDeviceList,
+  ]);
 }
 
 export { UserInfosHandler };