diff --git a/src/CONST.ts b/src/CONST.ts
index cd8b5d26c745b..e4d6d23c96df8 100755
--- a/src/CONST.ts
+++ b/src/CONST.ts
@@ -1436,6 +1436,8 @@ const CONST = {
             UNKNOWN: 'unknown',
         },
     },
+    // The number of milliseconds for an idle session to expire
+    SESSION_EXPIRATION_TIME_MS: 2 * 3600 * 1000, // 2 hours
     WEEK_STARTS_ON: 1, // Monday
     DEFAULT_TIME_ZONE: {automatic: true, selected: 'America/Los_Angeles'},
     DEFAULT_ACCOUNT_DATA: {errors: null, success: '', isLoading: false},
@@ -1551,6 +1553,7 @@ const CONST = {
     ATTACHMENT_PREVIEW_ATTRIBUTE: 'src',
     ATTACHMENT_ORIGINAL_FILENAME_ATTRIBUTE: 'data-name',
     ATTACHMENT_LOCAL_URL_PREFIX: ['blob:', 'file:'],
+    ATTACHMENT_OR_RECEIPT_LOCAL_URL: /^https:\/\/(www\.)?([a-z0-9_-]+\.)*expensify.com(:[0-9]+)?\/(chat-attachments|receipts)/,
     ATTACHMENT_THUMBNAIL_URL_ATTRIBUTE: 'data-expensify-thumbnail-url',
     ATTACHMENT_THUMBNAIL_WIDTH_ATTRIBUTE: 'data-expensify-width',
     ATTACHMENT_THUMBNAIL_HEIGHT_ATTRIBUTE: 'data-expensify-height',
diff --git a/src/ROUTES.ts b/src/ROUTES.ts
index c8e8ae582a5b2..1ade25d54c04c 100644
--- a/src/ROUTES.ts
+++ b/src/ROUTES.ts
@@ -327,7 +327,7 @@ const ROUTES = {
     ATTACHMENTS: {
         route: 'attachment',
         getRoute: (
-            reportID: string,
+            reportID: string | undefined,
             type: ValueOf<typeof CONST.ATTACHMENT_TYPE>,
             url: string,
             accountID?: number,
diff --git a/src/components/Attachments/AttachmentCarousel/extractAttachments.ts b/src/components/Attachments/AttachmentCarousel/extractAttachments.ts
index c0010af468af1..62660980f56f8 100644
--- a/src/components/Attachments/AttachmentCarousel/extractAttachments.ts
+++ b/src/components/Attachments/AttachmentCarousel/extractAttachments.ts
@@ -58,7 +58,7 @@ function extractAttachments(
             }
 
             if (name === 'img' && attribs.src) {
-                const expensifySource = attribs[CONST.ATTACHMENT_SOURCE_ATTRIBUTE];
+                const expensifySource = attribs[CONST.ATTACHMENT_SOURCE_ATTRIBUTE] ?? (new RegExp(CONST.ATTACHMENT_OR_RECEIPT_LOCAL_URL, 'i').test(attribs.src) ? attribs.src : null);
                 const source = tryResolveUrlFromApiRoot(expensifySource || attribs.src);
                 const previewSource = tryResolveUrlFromApiRoot(attribs.src);
                 const sourceLinkKey = `${source}|${currentLink}`;
diff --git a/src/components/HTMLEngineProvider/HTMLRenderers/ImageRenderer.tsx b/src/components/HTMLEngineProvider/HTMLRenderers/ImageRenderer.tsx
index c27eef1de91e4..36b7085275e0e 100644
--- a/src/components/HTMLEngineProvider/HTMLRenderers/ImageRenderer.tsx
+++ b/src/components/HTMLEngineProvider/HTMLRenderers/ImageRenderer.tsx
@@ -53,7 +53,8 @@ function ImageRenderer({tnode}: ImageRendererProps) {
     //           Concierge responder attachments are uploaded to S3 without any access
     //           control and thus require no authToken to verify access.
     //
-    const attachmentSourceAttribute = htmlAttribs[CONST.ATTACHMENT_SOURCE_ATTRIBUTE];
+    const attachmentSourceAttribute =
+        htmlAttribs[CONST.ATTACHMENT_SOURCE_ATTRIBUTE] ?? (new RegExp(CONST.ATTACHMENT_OR_RECEIPT_LOCAL_URL, 'i').test(htmlAttribs.src) ? htmlAttribs.src : null);
     const isAttachmentOrReceipt = !!attachmentSourceAttribute;
 
     // Files created/uploaded/hosted by App should resolve from API ROOT. Other URLs aren't modified
@@ -105,14 +106,14 @@ function ImageRenderer({tnode}: ImageRendererProps) {
                                 }
 
                                 const attachmentLink = tnode.parent?.attributes?.href;
-                                const route = ROUTES.ATTACHMENTS?.getRoute(reportID ?? '-1', type, source, accountID, isAttachmentOrReceipt, fileName, attachmentLink);
+                                const route = ROUTES.ATTACHMENTS?.getRoute(reportID, type, source, accountID, isAttachmentOrReceipt, fileName, attachmentLink);
                                 Navigation.navigate(route);
                             }}
                             onLongPress={(event) => {
                                 if (isDisabled) {
                                     return;
                                 }
-                                showContextMenuForReport(event, anchor, report?.reportID ?? '-1', action, checkIfContextMenuActive, ReportUtils.isArchivedRoom(report, reportNameValuePairs));
+                                showContextMenuForReport(event, anchor, report?.reportID, action, checkIfContextMenuActive, ReportUtils.isArchivedRoom(report, reportNameValuePairs));
                             }}
                             shouldUseHapticsOnLongPress
                             accessibilityRole={CONST.ROLE.BUTTON}
diff --git a/src/components/Image/index.tsx b/src/components/Image/index.tsx
index 5fe1ba3064000..2c01ebe9b6177 100644
--- a/src/components/Image/index.tsx
+++ b/src/components/Image/index.tsx
@@ -1,14 +1,17 @@
-import React, {useCallback, useContext, useMemo, useState} from 'react';
-import {withOnyx} from 'react-native-onyx';
+import React, {useCallback, useContext, useEffect, useMemo, useRef, useState} from 'react';
+import FullScreenLoadingIndicator from '@components/FullscreenLoadingIndicator';
+import {useSession} from '@components/OnyxProvider';
+import {isExpiredSession} from '@libs/actions/Session';
+import activateReauthenticator from '@libs/actions/Session/AttachmentImageReauthenticator';
 import CONST from '@src/CONST';
-import ONYXKEYS from '@src/ONYXKEYS';
 import BaseImage from './BaseImage';
 import {ImageBehaviorContext} from './ImageBehaviorContextProvider';
-import type {ImageOnLoadEvent, ImageOnyxProps, ImageOwnProps, ImageProps} from './types';
+import type {ImageOnLoadEvent, ImageProps} from './types';
 
-function Image({source: propsSource, isAuthTokenRequired = false, session, onLoad, objectPosition = CONST.IMAGE_OBJECT_POSITION.INITIAL, style, ...forwardedProps}: ImageProps) {
+function Image({source: propsSource, isAuthTokenRequired = false, onLoad, objectPosition = CONST.IMAGE_OBJECT_POSITION.INITIAL, style, ...forwardedProps}: ImageProps) {
     const [aspectRatio, setAspectRatio] = useState<string | number | null>(null);
     const isObjectPositionTop = objectPosition === CONST.IMAGE_OBJECT_POSITION.TOP;
+    const session = useSession();
 
     const {shouldSetAspectRatioInStyle} = useContext(ImageBehaviorContext);
 
@@ -37,6 +40,49 @@ function Image({source: propsSource, isAuthTokenRequired = false, session, onLoa
         },
         [onLoad, updateAspectRatio],
     );
+
+    // accepted sessions are sessions of a certain criteria that we think can necessitate a reload of the images
+    // because images sources barely changes unless specific events occur like network issues (offline/online) per example.
+    // Here we target new session received less than 60s after the previous session (that could be from fresh reauthentication, the previous session was not necessarily expired)
+    // or new session after the previous session was expired (based on timestamp gap between the 2 creationDate and the freshness of the new session).
+    const isAcceptedSession = useCallback((sessionCreationDateDiff: number, sessionCreationDate: number) => {
+        return sessionCreationDateDiff < 60000 || (sessionCreationDateDiff >= CONST.SESSION_EXPIRATION_TIME_MS && new Date().getTime() - sessionCreationDate < 60000);
+    }, []);
+
+    /**
+     * trying to figure out if the current session is expired or fresh from a necessary reauthentication
+     */
+    const previousSessionAge = useRef<number | undefined>();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const validSessionAge: number | undefined = useMemo(() => {
+        // Authentication is required only for certain types of images (attachments and receipts),
+        // so we only calculate the session age for those
+        if (!isAuthTokenRequired) {
+            return undefined;
+        }
+        if (session?.creationDate) {
+            if (previousSessionAge.current) {
+                // Most likely a reauthentication happened, but unless the calculated source is different from the previous, the image won't reload
+                if (isAcceptedSession(session.creationDate - previousSessionAge.current, session.creationDate)) {
+                    return session.creationDate;
+                }
+                return previousSessionAge.current;
+            }
+            if (isExpiredSession(session.creationDate)) {
+                // reset the countdown to now so future sessions creationDate can be compared to that time
+                return new Date().getTime();
+            }
+            return session.creationDate;
+        }
+        return undefined;
+    }, [session, isAuthTokenRequired, isAcceptedSession]);
+    useEffect(() => {
+        if (!isAuthTokenRequired) {
+            return;
+        }
+        previousSessionAge.current = validSessionAge;
+    });
+
     /**
      * Check if the image source is a URL - if so the `encryptedAuthToken` is appended
      * to the source.
@@ -48,24 +94,44 @@ function Image({source: propsSource, isAuthTokenRequired = false, session, onLoa
             }
             const authToken = session?.encryptedAuthToken ?? null;
             if (isAuthTokenRequired && authToken) {
-                return {
-                    ...propsSource,
-                    headers: {
-                        [CONST.CHAT_ATTACHMENT_TOKEN_KEY]: authToken,
-                    },
-                };
+                if (!!session?.creationDate && !isExpiredSession(session.creationDate)) {
+                    return {
+                        ...propsSource,
+                        headers: {
+                            [CONST.CHAT_ATTACHMENT_TOKEN_KEY]: authToken,
+                        },
+                    };
+                }
+                if (session) {
+                    activateReauthenticator(session);
+                }
+                return undefined;
             }
         }
         return propsSource;
         // The session prop is not required, as it causes the image to reload whenever the session changes. For more information, please refer to issue #26034.
+        // but we still need the image to reload sometimes (example : when the current session is expired)
+        // by forcing a recalculation of the source (which value could indeed change) through the modification of the variable validSessionAge
         // eslint-disable-next-line react-compiler/react-compiler, react-hooks/exhaustive-deps
-    }, [propsSource, isAuthTokenRequired]);
+    }, [propsSource, isAuthTokenRequired, validSessionAge]);
+    useEffect(() => {
+        if (!isAuthTokenRequired || source !== undefined) {
+            return;
+        }
+        forwardedProps?.waitForSession?.();
+    }, [source, isAuthTokenRequired, forwardedProps]);
 
     /**
      * If the image fails to load and the object position is top, we should hide the image by setting the opacity to 0.
      */
     const shouldOpacityBeZero = isObjectPositionTop && !aspectRatio;
 
+    if (source === undefined && !!forwardedProps?.waitForSession) {
+        return undefined;
+    }
+    if (source === undefined) {
+        return <FullScreenLoadingIndicator />;
+    }
     return (
         <BaseImage
             // eslint-disable-next-line react/jsx-props-no-spreading
@@ -77,18 +143,11 @@ function Image({source: propsSource, isAuthTokenRequired = false, session, onLoa
     );
 }
 
-function imagePropsAreEqual(prevProps: ImageOwnProps, nextProps: ImageOwnProps) {
+function imagePropsAreEqual(prevProps: ImageProps, nextProps: ImageProps) {
     return prevProps.source === nextProps.source;
 }
 
-const ImageWithOnyx = React.memo(
-    withOnyx<ImageProps, ImageOnyxProps>({
-        session: {
-            key: ONYXKEYS.SESSION,
-        },
-    })(Image),
-    imagePropsAreEqual,
-);
+const ImageWithOnyx = React.memo(Image, imagePropsAreEqual);
 
 ImageWithOnyx.displayName = 'Image';
 
diff --git a/src/components/Image/types.ts b/src/components/Image/types.ts
index 27964d8a67643..d6f2a0e51ff93 100644
--- a/src/components/Image/types.ts
+++ b/src/components/Image/types.ts
@@ -1,19 +1,12 @@
 import type {ImageSource} from 'expo-image';
 import type {ImageRequireSource, ImageResizeMode, ImageStyle, ImageURISource, StyleProp} from 'react-native';
-import type {OnyxEntry} from 'react-native-onyx';
 import type {ValueOf} from 'type-fest';
 import type CONST from '@src/CONST';
-import type {Session} from '@src/types/onyx';
 
 type ExpoImageSource = ImageSource | number | ImageSource[];
 
 type ImageObjectPosition = ValueOf<typeof CONST.IMAGE_OBJECT_POSITION>;
 
-type ImageOnyxProps = {
-    /** Session info for the currently logged in user. */
-    session: OnyxEntry<Session>;
-};
-
 type ImageOnLoadEvent = {
     nativeEvent: {
         width: number;
@@ -53,8 +46,15 @@ type ImageOwnProps = BaseImageProps & {
 
     /** The object position of image */
     objectPosition?: ImageObjectPosition;
+
+    /**
+     *  Called when the image should wait for a valid session to reload
+     *  At the moment this function is called, the image is not in cache anymore
+     *  cf https://github.com/Expensify/App/issues/51888
+     */
+    waitForSession?: () => void;
 };
 
-type ImageProps = ImageOnyxProps & ImageOwnProps;
+type ImageProps = ImageOwnProps;
 
-export type {BaseImageProps, ImageOwnProps, ImageOnyxProps, ImageProps, ExpoImageSource, ImageOnLoadEvent, ImageObjectPosition};
+export type {BaseImageProps, ImageOwnProps, ImageProps, ExpoImageSource, ImageOnLoadEvent, ImageObjectPosition};
diff --git a/src/components/ImageView/index.tsx b/src/components/ImageView/index.tsx
index 0bce2fd384321..319e81ac8c643 100644
--- a/src/components/ImageView/index.tsx
+++ b/src/components/ImageView/index.tsx
@@ -212,6 +212,7 @@ function ImageView({isAuthTokenRequired = false, url, fileName, onError}: ImageV
             />
         );
     }
+
     return (
         <View
             // eslint-disable-next-line react-compiler/react-compiler
@@ -238,6 +239,11 @@ function ImageView({isAuthTokenRequired = false, url, fileName, onError}: ImageV
                     resizeMode={RESIZE_MODES.contain}
                     onLoadStart={imageLoadingStart}
                     onLoad={imageLoad}
+                    waitForSession={() => {
+                        setIsLoading(true);
+                        setZoomScale(0);
+                        setIsZoomed(false);
+                    }}
                     onError={onError}
                 />
             </PressableWithoutFeedback>
diff --git a/src/components/ImageWithSizeCalculation.tsx b/src/components/ImageWithSizeCalculation.tsx
index ebea1a90efcac..f4b26597fd696 100644
--- a/src/components/ImageWithSizeCalculation.tsx
+++ b/src/components/ImageWithSizeCalculation.tsx
@@ -111,6 +111,13 @@ function ImageWithSizeCalculation({url, altText, style, onMeasure, onLoadFailure
                 }}
                 onError={onError}
                 onLoad={imageLoadedSuccessfully}
+                waitForSession={() => {
+                    // Called when the image should wait for a valid session to reload
+                    // At the moment this function is called, the image is not in cache anymore
+                    isLoadedRef.current = false;
+                    setIsImageCached(false);
+                    setIsLoading(true);
+                }}
                 objectPosition={objectPosition}
             />
             {isLoading && !isImageCached && !isOffline && <FullscreenLoadingIndicator style={[styles.opacity1, styles.bgTransparent]} />}
diff --git a/src/components/Lightbox/index.tsx b/src/components/Lightbox/index.tsx
index 9e1b007321cc5..ec0c6e5efcaaf 100644
--- a/src/components/Lightbox/index.tsx
+++ b/src/components/Lightbox/index.tsx
@@ -234,6 +234,14 @@ function Lightbox({isAuthTokenRequired = false, uri, onScaleChanged: onScaleChan
                                         updateContentSize(e);
                                         setLightboxImageLoaded(true);
                                     }}
+                                    waitForSession={() => {
+                                        // only active lightbox should call this function
+                                        if (!isActive || isFallbackVisible || !isLightboxVisible) {
+                                            return;
+                                        }
+                                        setContentSize(cachedImageDimensions.get(uri));
+                                        setLightboxImageLoaded(false);
+                                    }}
                                 />
                             </MultiGestureCanvas>
                         </View>
diff --git a/src/components/ShowContextMenuContext.ts b/src/components/ShowContextMenuContext.ts
index 6fefa987fac39..3bd98e90eec34 100644
--- a/src/components/ShowContextMenuContext.ts
+++ b/src/components/ShowContextMenuContext.ts
@@ -44,7 +44,7 @@ ShowContextMenuContext.displayName = 'ShowContextMenuContext';
 function showContextMenuForReport(
     event: GestureResponderEvent | MouseEvent,
     anchor: ContextMenuAnchor,
-    reportID: string,
+    reportID: string | undefined,
     action: OnyxEntry<ReportAction>,
     checkIfContextMenuActive: () => void,
     isArchivedRoom = false,
@@ -60,7 +60,7 @@ function showContextMenuForReport(
         anchor,
         reportID,
         action?.reportActionID,
-        ReportUtils.getOriginalReportID(reportID, action),
+        reportID ? ReportUtils.getOriginalReportID(reportID, action) : undefined,
         undefined,
         checkIfContextMenuActive,
         checkIfContextMenuActive,
diff --git a/src/components/TestToolMenu.tsx b/src/components/TestToolMenu.tsx
index 89f3fbc528efa..83aba3d4b61e5 100644
--- a/src/components/TestToolMenu.tsx
+++ b/src/components/TestToolMenu.tsx
@@ -111,6 +111,15 @@ function TestToolMenu() {
                 />
             </TestToolRow>
 
+            {/* Sends an expired session to the FE and invalidates the session by the same time in the BE. Action is delayed for 15s */}
+            <TestToolRow title={translate('initialSettingsPage.troubleshoot.authenticationStatus')}>
+                <Button
+                    small
+                    text={translate('initialSettingsPage.troubleshoot.invalidateWithDelay')}
+                    onPress={() => Session.expireSessionWithDelay()}
+                />
+            </TestToolRow>
+
             <TestCrash />
         </>
     );
diff --git a/src/languages/en.ts b/src/languages/en.ts
index eda70330d332d..6480b7e779ea7 100755
--- a/src/languages/en.ts
+++ b/src/languages/en.ts
@@ -1276,6 +1276,7 @@ const translations = {
             debugMode: 'Debug mode',
             invalidFile: 'Invalid file',
             invalidFileDescription: 'The file you are trying to import is not valid. Please try again.',
+            invalidateWithDelay: 'Invalidate with delay',
         },
         debugConsole: {
             saveLog: 'Save log',
diff --git a/src/languages/es.ts b/src/languages/es.ts
index ca12b0447bb63..183aa47bf5cea 100644
--- a/src/languages/es.ts
+++ b/src/languages/es.ts
@@ -1274,7 +1274,8 @@ const translations = {
             usingImportedState: 'Estás utilizando el estado importado. Pulsa aquí para borrarlo.',
             debugMode: 'Modo depuración',
             invalidFile: 'Archivo inválido',
-            invalidFileDescription: 'El archivo que estás intentando importar no es válido. Por favor, inténtalo de nuevo.',
+            invalidFileDescription: 'El archivo que ests intentando importar no es válido. Por favor, inténtalo de nuevo.',
+            invalidateWithDelay: 'Invalidar con retraso',
         },
         debugConsole: {
             saveLog: 'Guardar registro',
diff --git a/src/libs/E2E/actions/e2eLogin.ts b/src/libs/E2E/actions/e2eLogin.ts
index 25aee3c43d831..e325332d7dc7b 100644
--- a/src/libs/E2E/actions/e2eLogin.ts
+++ b/src/libs/E2E/actions/e2eLogin.ts
@@ -55,6 +55,7 @@ export default function (): Promise<boolean> {
                         .then((response) => {
                             Onyx.merge(ONYXKEYS.SESSION, {
                                 authToken: response.authToken,
+                                creationDate: new Date().getTime(),
                                 email: e2eUserCredentials.email,
                             });
                             console.debug('[E2E] Signed in finished!');
diff --git a/src/libs/actions/Session/AttachmentImageReauthenticator.ts b/src/libs/actions/Session/AttachmentImageReauthenticator.ts
new file mode 100644
index 0000000000000..ee4f8f4d8f7a3
--- /dev/null
+++ b/src/libs/actions/Session/AttachmentImageReauthenticator.ts
@@ -0,0 +1,72 @@
+import Onyx from 'react-native-onyx';
+import {reauthenticate} from '@libs/Authentication';
+import Log from '@libs/Log';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type Session from '@src/types/onyx/Session';
+
+let isOffline = false;
+let active = false;
+let currentActiveSession: Session = {};
+let timer: NodeJS.Timeout;
+// The delay before requesting a reauthentication once activated
+// When the session is expired we will give it this time to reauthenticate via normal flows, like the Reauthentication middleware, in an attempt to not duplicate authentication requests
+// also, this is an arbitrary number so we may tweak as needed
+const TIMING_BEFORE_REAUTHENTICATION_MS = 3500; // 3.5s
+
+// We subscribe to network's online/offline status
+Onyx.connect({
+    key: ONYXKEYS.NETWORK,
+    callback: (network) => {
+        if (!network) {
+            return;
+        }
+        isOffline = !!network.shouldForceOffline || !!network.isOffline;
+    },
+});
+
+// We subscribe to sessions changes
+Onyx.connect({
+    key: ONYXKEYS.SESSION,
+    callback: (value) => {
+        if (!value || isSameSession(value) || !active) {
+            return;
+        }
+        deactivate();
+    },
+});
+
+function isSameSession(session: Session): boolean {
+    return currentActiveSession.authToken === session.authToken && currentActiveSession.encryptedAuthToken === session.encryptedAuthToken;
+}
+
+function deactivate() {
+    active = false;
+    currentActiveSession = {};
+    clearInterval(timer);
+}
+
+/**
+ * The reauthenticator is currently only used by attachment images and only when the current session is expired.
+ * It will only request reauthentification only once between two receptions of different sessions from Onyx
+ * @param session the current session
+ * @returns
+ */
+function activate(session: Session) {
+    if (!session || isSameSession(session) || isOffline) {
+        return;
+    }
+    currentActiveSession = session;
+    active = true;
+    timer = setTimeout(tryReauthenticate, TIMING_BEFORE_REAUTHENTICATION_MS);
+}
+
+function tryReauthenticate() {
+    if (isOffline || !active) {
+        return;
+    }
+    reauthenticate().catch((error) => {
+        Log.hmmm('Could not reauthenticate attachment image or receipt', {error});
+    });
+}
+
+export default activate;
diff --git a/src/libs/actions/Session/index.ts b/src/libs/actions/Session/index.ts
index 1dbb01b008dd9..c854fbae401da 100644
--- a/src/libs/actions/Session/index.ts
+++ b/src/libs/actions/Session/index.ts
@@ -66,6 +66,9 @@ Onyx.connect({
     key: ONYXKEYS.SESSION,
     callback: (value) => {
         session = value ?? {};
+        if (!session.creationDate) {
+            session.creationDate = new Date().getTime();
+        }
         if (session.authToken && authPromiseResolver) {
             authPromiseResolver(true);
             authPromiseResolver = null;
@@ -115,6 +118,7 @@ function setSupportAuthToken(supportAuthToken: string, email: string, accountID:
         authToken: supportAuthToken,
         email,
         accountID,
+        creationDate: new Date().getTime(),
     }).then(() => {
         Log.info('[Supportal] Authtoken set');
     });
@@ -212,6 +216,14 @@ function hasAuthToken(): boolean {
     return !!session.authToken;
 }
 
+/**
+ * Indicates if the session which creation date is in parameter is expired
+ * @param sessionCreationDate the session creation date timestamp
+ */
+function isExpiredSession(sessionCreationDate: number): boolean {
+    return new Date().getTime() - sessionCreationDate >= CONST.SESSION_EXPIRATION_TIME_MS;
+}
+
 function signOutAndRedirectToSignIn(shouldResetToHome?: boolean, shouldStashSession?: boolean, killHybridApp = true) {
     Log.info('Redirecting to Sign In because signOut() was called');
     hideContextMenu(false);
@@ -764,7 +776,18 @@ function invalidateCredentials() {
 
 function invalidateAuthToken() {
     NetworkStore.setAuthToken('pizza');
-    Onyx.merge(ONYXKEYS.SESSION, {authToken: 'pizza'});
+    Onyx.merge(ONYXKEYS.SESSION, {authToken: 'pizza', encryptedAuthToken: 'pizza'});
+}
+
+/**
+ * Send an expired session to FE and invalidate the session in the BE perspective. Action is delayed for 15s
+ */
+function expireSessionWithDelay() {
+    // expires the session after 15s
+    setTimeout(() => {
+        NetworkStore.setAuthToken('pizza');
+        Onyx.merge(ONYXKEYS.SESSION, {authToken: 'pizza', encryptedAuthToken: 'pizza', creationDate: new Date().getTime() - CONST.SESSION_EXPIRATION_TIME_MS});
+    }, 15000);
 }
 
 /**
@@ -1226,11 +1249,13 @@ export {
     reauthenticatePusher,
     invalidateCredentials,
     invalidateAuthToken,
+    expireSessionWithDelay,
     isAnonymousUser,
     toggleTwoFactorAuth,
     validateTwoFactorAuth,
     waitForUserSignIn,
     hasAuthToken,
+    isExpiredSession,
     canAnonymousUserAccessRoute,
     signInWithSupportAuthToken,
     isSupportAuthToken,
diff --git a/src/libs/actions/Session/updateSessionAuthTokens.ts b/src/libs/actions/Session/updateSessionAuthTokens.ts
index 6f90b60ef06d2..8f98cf2fc5ddd 100644
--- a/src/libs/actions/Session/updateSessionAuthTokens.ts
+++ b/src/libs/actions/Session/updateSessionAuthTokens.ts
@@ -2,5 +2,5 @@ import Onyx from 'react-native-onyx';
 import ONYXKEYS from '@src/ONYXKEYS';
 
 export default function updateSessionAuthTokens(authToken?: string, encryptedAuthToken?: string) {
-    Onyx.merge(ONYXKEYS.SESSION, {authToken, encryptedAuthToken});
+    Onyx.merge(ONYXKEYS.SESSION, {authToken, encryptedAuthToken, creationDate: new Date().getTime()});
 }
diff --git a/src/types/onyx/Session.ts b/src/types/onyx/Session.ts
index 7cb47a380717d..da7bbc6840d1b 100644
--- a/src/types/onyx/Session.ts
+++ b/src/types/onyx/Session.ts
@@ -36,6 +36,9 @@ type Session = {
 
     /** User signed in with short lived token */
     signedInWithShortLivedAuthToken?: boolean;
+
+    /** Timestamp of the session creation date */
+    creationDate?: number;
 };
 
 export default Session;