diff --git a/packages/browser-utils/src/performance/entries.ts b/packages/browser-utils/src/performance/entries.ts
index f28e60f1cb3e..79eae716418d 100644
--- a/packages/browser-utils/src/performance/entries.ts
+++ b/packages/browser-utils/src/performance/entries.ts
@@ -5,6 +5,7 @@ import {
   browserPerformanceTimeOrigin,
   getActiveSpan,
   parseUrl,
+  performanceTimeToSeconds,
   RESOURCE_SPAN_NAME_FALLBACK,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   setMeasurement,
@@ -108,7 +109,7 @@ export function startTrackingLongTasks(): void {
     const { attributes: parentAttributes, start_timestamp: parentStartTimestamp } = spanToJSON(parent);
 
     for (const entry of entries) {
-      const startTime = msToSec((browserPerformanceTimeOrigin() as number) + entry.startTime);
+      const startTime = performanceTimeToSeconds(entry.startTime) as number;
       const duration = msToSec(entry.duration);
 
       if (parentAttributes[SENTRY_OP] === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {
@@ -147,7 +148,7 @@ export function startTrackingLongAnimationFrames(): void {
         continue;
       }
 
-      const startTime = msToSec((browserPerformanceTimeOrigin() as number) + entry.startTime);
+      const startTime = performanceTimeToSeconds(entry.startTime) as number;
 
       const {
         start_timestamp: parentStartTimestamp,
@@ -217,13 +218,14 @@ export function addPerformanceEntries(span: Span, options: AddPerformanceEntries
 
   const { spanStreamingEnabled, ignoreResourceSpans } = options;
 
-  const timeOrigin = msToSec(origin);
-
   const performanceEntries = performance.getEntries();
 
   const { attributes, start_timestamp: transactionStartTime } = spanToJSON(span);
 
   performanceEntries.slice(_performanceCursor).forEach(entry => {
+    // Navigations can happen long after page load, after a time origin reset. We use the origin from the entry's
+    // start for all its timings, so its duration stays correct.
+    const timeOrigin = msToSec(browserPerformanceTimeOrigin(entry.startTime) as number);
     const startTime = msToSec(entry.startTime);
     const duration = msToSec(
       // Inexplicably, Chrome sometimes emits a negative duration. We need to work around this.
diff --git a/packages/browser-utils/src/performance/interactions.ts b/packages/browser-utils/src/performance/interactions.ts
index 7a3cc89a981d..8ed72ad9c2d8 100644
--- a/packages/browser-utils/src/performance/interactions.ts
+++ b/packages/browser-utils/src/performance/interactions.ts
@@ -16,13 +16,13 @@ import {
 import { UI_ACTION_CLICK, UI_INTERACTION_CLICK } from '@sentry/conventions/op';
 import type { Client, IntegrationFn, Span, StartSpanOptions, TransactionSource } from '@sentry/core';
 import {
-  browserPerformanceTimeOrigin,
   debug,
   defineIntegration,
   filterCollectedUrl,
   getActiveSpan,
   getRootSpan,
   hasSpanStreamingEnabled,
+  performanceTimeToSeconds,
   spanToJSON,
   UI_ACTION_CLICK_SPAN_NAME_FALLBACK,
   UI_INTERACTION_CLICK_SPAN_NAME_FALLBACK,
@@ -242,7 +242,10 @@ function trackInteractionsAsSpans(client: Client): void {
     }
     for (const entry of entries) {
       if (entry.name === 'click') {
-        const startTime = msToSec((browserPerformanceTimeOrigin() as number) + entry.startTime);
+        const startTime = performanceTimeToSeconds(entry.startTime);
+        if (!startTime) {
+          return;
+        }
         const duration = msToSec(entry.duration);
 
         const selector = htmlTreeAsString(entry.target);
diff --git a/packages/browser-utils/src/performance/resourceTiming.ts b/packages/browser-utils/src/performance/resourceTiming.ts
index 5a711d307cf3..eef2594833f6 100644
--- a/packages/browser-utils/src/performance/resourceTiming.ts
+++ b/packages/browser-utils/src/performance/resourceTiming.ts
@@ -2,10 +2,10 @@ import type { SpanAttributes } from '@sentry/core';
 import { browserPerformanceTimeOrigin } from '@sentry/core';
 import { extractNetworkProtocol, getBrowserPerformanceAPI } from './utils';
 
-function getAbsoluteTime(time: number | undefined): number | undefined {
+function getAbsoluteTime(time: number | undefined, timeOrigin: number): number | undefined {
   // falsy values should be preserved so that we can later on drop undefined values and
   // preserve 0 vals for cross-origin resources without proper `Timing-Allow-Origin` header.
-  return time ? ((browserPerformanceTimeOrigin() || performance.timeOrigin) + time) / 1000 : time;
+  return time ? (timeOrigin + time) / 1000 : time;
 }
 
 /**
@@ -28,31 +28,33 @@ export function resourceTimingToSpanAttributes(resourceTiming: PerformanceResour
     timingSpanData['network.protocol.name'] = name;
   }
 
-  if (!(browserPerformanceTimeOrigin() || getBrowserPerformanceAPI()?.timeOrigin)) {
+  // Use the origin from the request start for all timings, so the durations between them stay correct.
+  const timeOrigin = browserPerformanceTimeOrigin(resourceTiming.startTime) || getBrowserPerformanceAPI()?.timeOrigin;
+  if (!timeOrigin) {
     return timingSpanData;
   }
 
   return dropUndefinedKeysFromObject({
     ...timingSpanData,
 
-    'http.request.redirect_start': getAbsoluteTime(resourceTiming.redirectStart),
-    'http.request.redirect_end': getAbsoluteTime(resourceTiming.redirectEnd),
+    'http.request.redirect_start': getAbsoluteTime(resourceTiming.redirectStart, timeOrigin),
+    'http.request.redirect_end': getAbsoluteTime(resourceTiming.redirectEnd, timeOrigin),
 
-    'http.request.worker_start': getAbsoluteTime(resourceTiming.workerStart),
+    'http.request.worker_start': getAbsoluteTime(resourceTiming.workerStart, timeOrigin),
 
-    'http.request.fetch_start': getAbsoluteTime(resourceTiming.fetchStart),
+    'http.request.fetch_start': getAbsoluteTime(resourceTiming.fetchStart, timeOrigin),
 
-    'http.request.domain_lookup_start': getAbsoluteTime(resourceTiming.domainLookupStart),
-    'http.request.domain_lookup_end': getAbsoluteTime(resourceTiming.domainLookupEnd),
+    'http.request.domain_lookup_start': getAbsoluteTime(resourceTiming.domainLookupStart, timeOrigin),
+    'http.request.domain_lookup_end': getAbsoluteTime(resourceTiming.domainLookupEnd, timeOrigin),
 
-    'http.request.connect_start': getAbsoluteTime(resourceTiming.connectStart),
-    'http.request.secure_connection_start': getAbsoluteTime(resourceTiming.secureConnectionStart),
-    'http.request.connection_end': getAbsoluteTime(resourceTiming.connectEnd),
+    'http.request.connect_start': getAbsoluteTime(resourceTiming.connectStart, timeOrigin),
+    'http.request.secure_connection_start': getAbsoluteTime(resourceTiming.secureConnectionStart, timeOrigin),
+    'http.request.connection_end': getAbsoluteTime(resourceTiming.connectEnd, timeOrigin),
 
-    'http.request.request_start': getAbsoluteTime(resourceTiming.requestStart),
+    'http.request.request_start': getAbsoluteTime(resourceTiming.requestStart, timeOrigin),
 
-    'http.request.response_start': getAbsoluteTime(resourceTiming.responseStart),
-    'http.request.response_end': getAbsoluteTime(resourceTiming.responseEnd),
+    'http.request.response_start': getAbsoluteTime(resourceTiming.responseStart, timeOrigin),
+    'http.request.response_end': getAbsoluteTime(resourceTiming.responseEnd, timeOrigin),
 
     // For TTFB we actually want the relative time from timeOrigin to responseStart
     // This way, TTFB always measures the "first page load" experience.
diff --git a/packages/browser-utils/src/performance/userTiming.ts b/packages/browser-utils/src/performance/userTiming.ts
index 02d6fc25694d..24559ba03c5d 100644
--- a/packages/browser-utils/src/performance/userTiming.ts
+++ b/packages/browser-utils/src/performance/userTiming.ts
@@ -26,11 +26,9 @@ const _userTimingIntegration = ((options: UserTimingOptions = {}) => {
     name: INTEGRATION_NAME,
     setup(client) {
       const performance = getBrowserPerformanceAPI();
-      const timeOrigin = browserPerformanceTimeOrigin();
-      if (!performance?.getEntries || !timeOrigin) {
+      if (!performance?.getEntries || !browserPerformanceTimeOrigin()) {
         return;
       }
-      const timeOriginInSeconds = msToSec(timeOrigin);
       let performanceCursor = 0;
 
       client.on('beforeIdleSpanEnd', idleSpan => {
@@ -49,6 +47,8 @@ const _userTimingIntegration = ((options: UserTimingOptions = {}) => {
             continue;
           }
 
+          // Navigations can happen long after page load, after a time origin reset.
+          const timeOriginInSeconds = msToSec(browserPerformanceTimeOrigin(entry.startTime) as number);
           const startTime = msToSec(entry.startTime);
           const absoluteStartTime = timeOriginInSeconds + startTime;
 
diff --git a/packages/browser-utils/src/web-vitals/spans.ts b/packages/browser-utils/src/web-vitals/spans.ts
index 424180427141..90ab1102c318 100644
--- a/packages/browser-utils/src/web-vitals/spans.ts
+++ b/packages/browser-utils/src/web-vitals/spans.ts
@@ -7,6 +7,7 @@ import {
   getClient,
   getRootSpan,
   hasSpanStreamingEnabled,
+  performanceTimeToSeconds,
   SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   spanToJSON,
@@ -193,10 +194,11 @@ export function _sendLcpSpan(
 
   DEBUG_BUILD && debug.log(`Sending LCP span (${lcpValue})`);
 
-  const performanceTimeOrigin = browserPerformanceTimeOrigin() || 0;
   // A soft navigation's LCP is measured from the triggering interaction, not the document time
   // origin. Starting the span there too keeps it inside the navigation span it is parented to and
-  // keeps its duration equal to the value it reports.
+  // keeps its duration equal to the reported value. The span's end uses the same origin, even if
+  // the time origin was reset in between.
+  const performanceTimeOrigin = browserPerformanceTimeOrigin(navigationStartTime || 0) || 0;
   const startTime = msToSec(performanceTimeOrigin + (navigationStartTime || 0));
   // Without an entry there is no render time to end at, so the span lasts the value it reports,
   // like an entry-less INP does. Ending at the time origin instead would invert the span.
@@ -297,12 +299,12 @@ export function _sendClsSpan(
 ): void {
   DEBUG_BUILD && debug.log(`Sending CLS span (${clsValue})`);
 
-  const performanceTimeOrigin = browserPerformanceTimeOrigin();
   // A CLS of 0 has no shift to place the span at. It is reported when the navigation it was
   // measured on is already over - the next soft navigation, or pagehide - so the current time would
   // land it outside that navigation, on the route that follows it.
   const offset = entry?.startTime ?? navigationStartTime ?? 0;
-  const startTime = performanceTimeOrigin ? msToSec(performanceTimeOrigin + offset) : timestampInSeconds();
+  // CLS is only reported on pagehide, so we use the time origin from when the layout shift happened.
+  const startTime = performanceTimeToSeconds(offset) ?? timestampInSeconds();
   const firstSourceNode = entry?.sources[0]?.node;
   const selector = entry ? htmlTreeAsString(firstSourceNode) : undefined;
   const componentName = firstSourceNode ? getComponentName(firstSourceNode) : null;
@@ -409,9 +411,9 @@ export function _sendInpSpan(
   // A web vital span carries the metric, not a real interaction timing, so an INP without an entry
   // is still worth reporting. It just has no element or interaction type to describe, and is placed
   // at the start of the navigation it belongs to rather than at the interaction.
-  const startTime = msToSec(
-    (browserPerformanceTimeOrigin() as number) + (entry?.startTime ?? metric?.navigationStartTime ?? 0),
-  );
+  // INP is reported on pagehide, often long after the interaction, so we use the time origin from when the
+  // interaction happened.
+  const startTime = performanceTimeToSeconds(entry?.startTime ?? metric?.navigationStartTime ?? 0) as number;
   const duration = msToSec(inpValue);
   // An INP without an entry has no interaction type to report. It still has to land inside the
   // `ui.interaction.*` family, because falling outside it would hide exactly the fast navigations
diff --git a/packages/browser-utils/test/performance/addPerformanceEntries.test.ts b/packages/browser-utils/test/performance/addPerformanceEntries.test.ts
new file mode 100644
index 000000000000..2c687749cab6
--- /dev/null
+++ b/packages/browser-utils/test/performance/addPerformanceEntries.test.ts
@@ -0,0 +1,79 @@
+import type { Span } from '@sentry/core';
+import * as SentryCore from '@sentry/core';
+import { getClient, getMainCarrier, SentrySpan, setCurrentClient, spanToJSON } from '@sentry/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { addPerformanceEntries } from '../../src/performance/entries';
+import { WINDOW } from '../../src/types';
+import { getDefaultClientOptions, TestClient } from '../utils/TestClient';
+
+vi.mock('@sentry/core', async () => {
+  const actual = await vi.importActual('@sentry/core');
+  return {
+    ...actual,
+    browserPerformanceTimeOrigin: vi.fn(),
+  };
+});
+
+const pageloadOriginMs = 1_000_000;
+const sleepDurationMs = 3_600_000;
+// The `performance.now()` time from which the reset time origin applies.
+const correctionFromMs = 10_000;
+
+describe('addPerformanceEntries', () => {
+  beforeEach(() => {
+    getMainCarrier().__SENTRY__ = undefined;
+    const client = new TestClient(getDefaultClientOptions({ tracesSampleRate: 1 }));
+    setCurrentClient(client);
+    client.init();
+
+    vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockImplementation((monotonicTimeInMs = 0) =>
+      monotonicTimeInMs < correctionFromMs ? pageloadOriginMs : pageloadOriginMs + sleepDurationMs,
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it('keeps the resource spans of a navigation that happens after a time origin reset', () => {
+    const resourceStartTime = 12_000;
+    vi.stubGlobal('addEventListener', vi.fn());
+    vi.stubGlobal('location', { origin: 'https://example.com' });
+    vi.spyOn(WINDOW.performance, 'getEntries').mockReturnValue([
+      {
+        entryType: 'resource',
+        name: 'https://example.com/app.js',
+        initiatorType: 'script',
+        startTime: resourceStartTime,
+        duration: 100,
+        responseEnd: resourceStartTime + 100,
+        toJSON: () => ({}),
+      } as PerformanceResourceTiming,
+    ]);
+
+    const navigationStartTimestamp = (pageloadOriginMs + sleepDurationMs + resourceStartTime - 50) / 1000;
+    const span = new SentrySpan({
+      op: 'navigation',
+      name: '/next',
+      sampled: true,
+      startTimestamp: navigationStartTimestamp,
+    });
+
+    const endedSpans: Span[] = [];
+    getClient()?.on('spanEnd', endedSpan => void endedSpans.push(endedSpan));
+
+    addPerformanceEntries(span, { ignoreResourceSpans: [] });
+
+    expect(endedSpans.map(spanToJSON)).toEqual([
+      expect.objectContaining({
+        start_timestamp: (pageloadOriginMs + sleepDurationMs + resourceStartTime) / 1000,
+        end_timestamp: (pageloadOriginMs + sleepDurationMs + resourceStartTime + 100) / 1000,
+        attributes: expect.objectContaining({
+          'sentry.op': 'resource.script',
+          'http.request.response_end': (pageloadOriginMs + sleepDurationMs + resourceStartTime + 100) / 1000,
+        }),
+      }),
+    ]);
+  });
+});
diff --git a/packages/browser-utils/test/web-vitals/spans.test.ts b/packages/browser-utils/test/web-vitals/spans.test.ts
index f9182b52d153..c0f165d618b9 100644
--- a/packages/browser-utils/test/web-vitals/spans.test.ts
+++ b/packages/browser-utils/test/web-vitals/spans.test.ts
@@ -22,6 +22,7 @@ vi.mock('@sentry/core', async () => {
   return {
     ...actual,
     browserPerformanceTimeOrigin: vi.fn(),
+    performanceTimeToSeconds: vi.fn(),
     timestampInSeconds: vi.fn(),
     getCurrentScope: vi.fn(),
     getClient: vi.fn(),
@@ -475,6 +476,22 @@ describe('_sendLcpSpan', () => {
     expect(mockSpan.end).toHaveBeenCalledWith(3.25);
   });
 
+  it('uses the time origin from the start of a soft navigation for LCP', () => {
+    // The soft navigation happens after a time origin reset.
+    const sleepDurationMs = 3_600_000;
+    vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockImplementation((monotonicTimeInMs = 0) =>
+      monotonicTimeInMs < 1500 ? 1000 : 1000 + sleepDurationMs,
+    );
+    const entry = { element: { tagName: 'img' } as Element, startTime: 2250 } as LargestContentfulPaint;
+
+    _sendLcpSpan(250, entry, undefined, 2, 'soft-navigation', 2000);
+
+    expect(SentryCoreBrowser.startInactiveSpan).toHaveBeenCalledWith(
+      expect.objectContaining({ startTime: (1000 + sleepDurationMs + 2000) / 1000 }),
+    );
+    expect(mockSpan.end).toHaveBeenCalledWith((1000 + sleepDurationMs + 2250) / 1000);
+  });
+
   it('drops implausible LCP values', () => {
     _sendLcpSpan(0, undefined);
     _sendLcpSpan(MAX_PLAUSIBLE_LCP_DURATION + 1, undefined);
@@ -497,6 +514,7 @@ describe('_sendClsSpan', () => {
   beforeEach(() => {
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.timestampInSeconds).mockReturnValue(1.5);
     vi.mocked(htmlTreeAsString).mockImplementation((node: any) => `<${node?.tagName || 'div'}>`);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue(mockSpan as any);
@@ -590,6 +608,7 @@ describe('_sendClsSpan', () => {
 
   it('falls back to the current time when there is no performance time origin', () => {
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(undefined);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockReturnValue(undefined);
 
     _sendClsSpan(0, undefined);
 
@@ -612,6 +631,7 @@ describe('_sendInpSpan', () => {
   beforeEach(() => {
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(htmlTreeAsString).mockReturnValue('<button>');
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue(mockSpan as any);
     vi.mocked(SentryCore.getActiveSpan).mockReturnValue(undefined);
@@ -667,6 +687,29 @@ describe('_sendInpSpan', () => {
     expect(mockSpan.end).toHaveBeenCalledWith(1.62);
   });
 
+  it('uses the time origin from when the interaction happened, not from when it was reported', () => {
+    vi.spyOn(inpModule, 'getCachedInteractionContext').mockReturnValue(undefined);
+
+    // INP is reported on pagehide. If the device slept in between, the time origin was reset, but the interaction
+    // should still use the old one.
+    const sleepDurationMs = 3_600_000;
+    vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000 + sleepDurationMs);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time =>
+      time < 500 ? (1000 + sleepDurationMs + time) / 1000 : (1000 + time) / 1000,
+    );
+
+    _sendInpSpan(120, {
+      name: 'pointerdown',
+      startTime: 500,
+      duration: 120,
+      interactionId: 1,
+      target: { tagName: 'button' },
+    } as any);
+
+    expect(SentryCoreBrowser.startInactiveSpan).toHaveBeenCalledWith(expect.objectContaining({ startTime: 1.5 }));
+    expect(mockSpan.end).toHaveBeenCalledWith(1.62);
+  });
+
   it('sends a streamed INP span for a keypress interaction', () => {
     vi.spyOn(inpModule, 'getCachedInteractionContext').mockReturnValue(undefined);
 
@@ -792,6 +835,7 @@ describe('trackInpAsSpan', () => {
 
   beforeEach(() => {
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.getActiveSpan).mockReturnValue(undefined);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue({ end: vi.fn() } as any);
@@ -890,6 +934,7 @@ describe('soft navigation web vitals', () => {
       supportedEntryTypes: ['largest-contentful-paint', 'layout-shift', 'soft-navigation'],
     });
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
+    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue({ end: vi.fn() } as any);
     vi.mocked(SentryCore.spanToJSON).mockImplementation(
diff --git a/packages/browser/src/client.ts b/packages/browser/src/client.ts
index 0221ca2d30ce..34fb6a98d66d 100644
--- a/packages/browser/src/client.ts
+++ b/packages/browser/src/client.ts
@@ -8,7 +8,7 @@ import type {
   SeverityLevel,
 } from '@sentry/core';
 import type { BrowserClientReplayOptions } from '@sentry/core/browser';
-import { addAutoIpAddressToSession, applySdkMetadata, Client, getSDKSource } from '@sentry/core';
+import { addAutoIpAddressToSession, applySdkMetadata, Client, getSDKSource, timestampInSeconds } from '@sentry/core';
 import { eventFromException, eventFromMessage } from './eventbuilder';
 import { WINDOW } from './helpers';
 import type { BrowserTransportOptions } from './transports/types';
@@ -130,6 +130,10 @@ export class BrowserClient extends Client<BrowserClientOptions> {
     // Client report outcomes don't listen to the `flush` hook, so we flush them separately.
     if (WINDOW.document) {
       WINDOW.document.addEventListener('visibilitychange', () => {
+        // Devices usually hide the page before they sleep and show it again after they wake up. Checking for drift
+        // at both points makes the time origin reset happen at the sleep, not at the next random timestamp.
+        timestampInSeconds();
+
         if (WINDOW.document.visibilityState === 'hidden') {
           if (sendClientReports) {
             this._flushOutcomes();
diff --git a/packages/browser/src/profiling/utils.ts b/packages/browser/src/profiling/utils.ts
index 2669e121ac97..9ecdf4ccb654 100644
--- a/packages/browser/src/profiling/utils.ts
+++ b/packages/browser/src/profiling/utils.ts
@@ -1,11 +1,11 @@
 /* eslint-disable max-lines */
 import type { Client, ContinuousThreadCpuProfile, DebugImage, ProfileChunk, Span } from '@sentry/core';
 import {
-  browserPerformanceTimeOrigin,
   debug,
   getClient,
   getDebugImagesForResources,
   GLOBAL_OBJ,
+  performanceTimeToSeconds,
   uuid4,
 } from '@sentry/core';
 import type { BrowserOptions } from '../client';
@@ -147,10 +147,8 @@ function convertToContinuousProfile(input: {
     stacks[i] = list;
   }
 
-  // Align timestamps to SDK time origin to match span/event timelines
-  const perfOrigin = browserPerformanceTimeOrigin();
-  const origin = typeof performance.timeOrigin === 'number' ? performance.timeOrigin : perfOrigin || 0;
-  const adjustForOriginChange = origin - (perfOrigin || origin);
+  // Only used if the Performance API is unavailable.
+  const origin = typeof performance.timeOrigin === 'number' ? performance.timeOrigin : 0;
 
   const samples: ContinuousThreadCpuProfile['samples'] = [];
   for (let i = 0; i < input.samples.length; i++) {
@@ -158,8 +156,8 @@ function convertToContinuousProfile(input: {
     if (!sample) {
       continue;
     }
-    // Convert ms to seconds epoch-based timestamp
-    const timestampSeconds = (origin + (sample.timestamp - adjustForOriginChange)) / 1000;
+    // Sample timestamps are relative to `performance.timeOrigin`, so we convert them like performance entries.
+    const timestampSeconds = performanceTimeToSeconds(sample.timestamp) ?? (origin + sample.timestamp) / 1000;
     samples[i] = {
       stack_id: sample.stackId ?? 0,
       thread_id: PROFILER_THREAD_ID_STRING,
diff --git a/packages/browser/test/client.test.ts b/packages/browser/test/client.test.ts
index cc7a6cbbafc9..e9752891877e 100644
--- a/packages/browser/test/client.test.ts
+++ b/packages/browser/test/client.test.ts
@@ -2,19 +2,29 @@
  * @vitest-environment jsdom
  */
 
+import * as SentryCore from '@sentry/core';
 import { getCurrentScope, makeSession, setCurrentClient } from '@sentry/core';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { applyDefaultOptions, BrowserClient } from '../src/client';
 import { WINDOW } from '../src/helpers';
 import { getDefaultBrowserClientOptions } from './helper/browser-client-options';
 
-function setDocumentHidden(): void {
+vi.mock('@sentry/core', async importOriginal => {
+  const actual = await importOriginal<typeof SentryCore>();
+  return { ...actual, timestampInSeconds: vi.fn(actual.timestampInSeconds) };
+});
+
+function setDocumentVisibility(visibilityState: DocumentVisibilityState): void {
   if (WINDOW.document) {
-    Object.defineProperty(WINDOW.document, 'visibilityState', { value: 'hidden', configurable: true });
+    Object.defineProperty(WINDOW.document, 'visibilityState', { value: visibilityState, configurable: true });
     WINDOW.document.dispatchEvent(new Event('visibilitychange'));
   }
 }
 
+function setDocumentHidden(): void {
+  setDocumentVisibility('hidden');
+}
+
 describe('BrowserClient', () => {
   let client: BrowserClient;
 
@@ -39,6 +49,19 @@ describe('BrowserClient', () => {
     expect(flushSpy).toHaveBeenCalledTimes(1);
   });
 
+  it('checks the clocks for drift when the page is hidden and shown again', () => {
+    client = new BrowserClient(getDefaultBrowserClientOptions());
+    vi.spyOn(client, 'flush').mockReturnValue(Promise.resolve(true) as any);
+    vi.mocked(SentryCore.timestampInSeconds).mockClear();
+
+    setDocumentHidden();
+    expect(SentryCore.timestampInSeconds).toHaveBeenCalled();
+
+    vi.mocked(SentryCore.timestampInSeconds).mockClear();
+    setDocumentVisibility('visible');
+    expect(SentryCore.timestampInSeconds).toHaveBeenCalled();
+  });
+
   it('does not flush outcomes when sendClientReports is disabled but still flushes the client', async () => {
     client = new BrowserClient(getDefaultBrowserClientOptions({ sendClientReports: false }));
     const flushSpy = vi.spyOn(client, 'flush').mockReturnValue(Promise.resolve(true) as any);
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 20b52be30603..5e4da3058682 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -276,7 +276,12 @@ export {
   supportsReferrerPolicy,
 } from './utils/supports';
 export { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './utils/syncpromise';
-export { browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds } from './utils/time';
+export {
+  browserPerformanceTimeOrigin,
+  dateTimestampInSeconds,
+  performanceTimeToSeconds,
+  timestampInSeconds,
+} from './utils/time';
 export {
   TRACEPARENT_REGEXP,
   extractTraceparentData,
diff --git a/packages/core/src/utils/time.ts b/packages/core/src/utils/time.ts
index b736f546c9c5..ac7c29b95bb1 100644
--- a/packages/core/src/utils/time.ts
+++ b/packages/core/src/utils/time.ts
@@ -3,6 +3,17 @@ import { GLOBAL_OBJ } from './worldwide';
 
 const ONE_SECOND_IN_MS = 1000;
 
+/**
+ * If `performance.timeOrigin + performance.now()` and `Date.now()` differ by more than this, we reset the time origin.
+ */
+const CLOCK_DRIFT_THRESHOLD_MS = 1_000;
+
+/**
+ * Max number of time origins we store. When we hit it, we drop the oldest one, except the page load origin, which
+ * the pageload span uses.
+ */
+const MAX_TIME_ORIGIN_SEGMENTS = 30;
+
 /**
  * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
  * for accessing a high-resolution monotonic clock.
@@ -25,6 +36,25 @@ export function dateTimestampInSeconds(): number {
   return safeDateNow() / ONE_SECOND_IN_MS;
 }
 
+/**
+ * A time origin and the `performance.now()` value from which it applies.
+ *
+ * When we reset the time origin, we keep the old ones. This way, a `performance.now()` value can be converted with the
+ * origin that was valid when it was measured, not the one that is valid now.
+ */
+interface TimeOriginSegment {
+  /** The `performance.now()` value from which `origin` applies. */
+  from: number;
+  /** Milliseconds since the UNIX epoch that `performance.now() === 0` corresponds to. */
+  origin: number;
+}
+
+/**
+ * All time origins of the page, oldest first. Empty until the first `timestampInSeconds` call, or if the Performance
+ * API is unavailable.
+ */
+let _timeOriginSegments: TimeOriginSegment[] = [];
+
 /**
  * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
  * support the API.
@@ -36,87 +66,106 @@ function createUnixTimestampInSecondsFunc(): () => number {
   // Some browser and environments don't have a performance or timeOrigin, so we fallback to
   // using Date.now() to compute the starting time.
   if (!performance?.now || !performance.timeOrigin) {
+    if (performance?.now) {
+      // We can still convert `performance.now()` values, just without drift correction.
+      _timeOriginSegments = [{ from: 0, origin: safeDateNow() - withRandomSafeContext(() => performance.now()) }];
+    }
     return dateTimestampInSeconds;
   }
 
-  const timeOrigin = performance.timeOrigin;
-
   // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current
   // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.
-  //
-  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the
-  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and
-  // correct for this.
-  // See: https://github.com/getsentry/sentry-javascript/issues/2590
-  // See: https://github.com/mdn/content/issues/4713
-  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6
+  // Due to device sleeps, the origin might need to be corrected to match the wall clock time over the SDK's lifetime.
+  let correctedTimeOrigin = performance.timeOrigin;
+  _timeOriginSegments = [{ from: 0, origin: correctedTimeOrigin }];
+  let isFirstCall = true;
+  let lastCheckedPerformanceNow = 0;
+
   return () => {
-    return (timeOrigin + withRandomSafeContext(() => performance.now())) / ONE_SECOND_IN_MS;
+    return withRandomSafeContext(() => {
+      const performanceNow = performance.now();
+      const dateNow = Date.now();
+
+      // `performance.now()` stops while the device sleeps, and the wall clock can be changed by NTP or the user. In
+      // both cases `timeOrigin + performance.now()` no longer matches `Date.now()`, so we reset the time origin.
+      // We still use `performance.now()` for elapsed time to keep sub-millisecond precision.
+      // See: https://github.com/getsentry/sentry-javascript/issues/2590
+      // See: https://github.com/mdn/content/issues/4713
+      // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6
+      if (Math.abs(correctedTimeOrigin + performanceNow - dateNow) > CLOCK_DRIFT_THRESHOLD_MS) {
+        correctedTimeOrigin = dateNow - performanceNow;
+
+        // after correcting the timeOrigin, we add an entry to _timeOriginSegments so that we
+        // can track when we made the correction. This is relevant for telemetry collected from
+        // performance entries that hold uncorrected time values. Used in browserPerformanceTimeOrigin return
+        // a corrected time origin value.
+        if (isFirstCall) {
+          // special case: We detect clock drift right away (basically at SDK init time), so we replace
+          // the initial _timeOriginSegments entry with the corrected value.
+          _timeOriginSegments = [{ from: 0, origin: correctedTimeOrigin }];
+        } else {
+          _timeOriginSegments.push({ from: lastCheckedPerformanceNow, origin: correctedTimeOrigin });
+          if (_timeOriginSegments.length > MAX_TIME_ORIGIN_SEGMENTS) {
+            // we keep the oldest entry (the page load origin) and drop the one after it.
+            _timeOriginSegments.splice(1, 1);
+          }
+        }
+      }
+      isFirstCall = false;
+      lastCheckedPerformanceNow = performanceNow;
+
+      return (correctedTimeOrigin + performanceNow) / ONE_SECOND_IN_MS;
+    });
   };
 }
 
-let _cachedTimestampInSeconds: (() => number) | undefined;
+let _cachedTimestampInSecondsFn: (() => number) | undefined;
+
+/**
+ * Converts a `performance.now()` based time in milliseconds (e.g. a `PerformanceEntry`'s `startTime`) to a UNIX
+ * timestamp in seconds, matching {@link timestampInSeconds}.
+ *
+ * Returns `undefined` if the Performance API is unavailable.
+ */
+export function performanceTimeToSeconds(monotonicTimeInMs: number): number | undefined {
+  const origin = browserPerformanceTimeOrigin(monotonicTimeInMs);
+  return origin === undefined ? undefined : (origin + monotonicTimeInMs) / ONE_SECOND_IN_MS;
+}
 
 /**
  * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
  * availability of the Performance API.
  *
- * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
- * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
- * skew can grow to arbitrary amounts like days, weeks or months.
+ * If the Performance API time and `Date.now()` differ by more than {@link CLOCK_DRIFT_THRESHOLD_MS} (e.g. after the
+ * device slept), the time origin is reset based on `Date.now()`.
  * See https://github.com/getsentry/sentry-javascript/issues/2590.
  */
 export function timestampInSeconds(): number {
   // We store this in a closure so that we don't have to create a new function every time this is called.
-  const func = _cachedTimestampInSeconds ?? (_cachedTimestampInSeconds = createUnixTimestampInSecondsFunc());
+  const func = _cachedTimestampInSecondsFn ?? (_cachedTimestampInSecondsFn = createUnixTimestampInSecondsFunc());
   return func();
 }
 
 /**
- * Cached result of getBrowserTimeOrigin.
- */
-let cachedTimeOrigin: number | null | undefined = null;
-
-/**
- * Gets the time origin and the mode used to determine it.
+ * Returns the time origin in milliseconds that was valid at the given `performance.now()` time. Defaults to the page
+ * load origin.
  *
- * Unfortunately browsers may report inaccurate time origin data through performance.timeOrigin,
- * which results in poor results in performance data. We only treat time origin data as reliable
- * if it is within a reasonable threshold of the current time.
+ * Pass the time you want to convert, so entries that are reported late (e.g. INP on pagehide) are not shifted by a
+ * drift that happened after they were recorded. Use the same time for all timings of one entry to keep its duration.
  *
- * TODO: move to `@sentry/browser-utils` package.
+ * Returns `undefined` if the Performance API is unavailable.
  */
-function getBrowserTimeOrigin(): number | undefined {
-  const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;
-  if (!performance?.now) {
-    return undefined;
-  }
-
-  const threshold = 300_000; // 5 minutes in milliseconds
-  const performanceNow = withRandomSafeContext(() => performance.now());
-  const dateNow = safeDateNow();
+export function browserPerformanceTimeOrigin(monotonicTimeInMs = 0): number | undefined {
+  // Makes sure `_timeOriginSegments` is set up.
+  timestampInSeconds();
 
-  const timeOrigin = performance.timeOrigin;
-  if (typeof timeOrigin === 'number') {
-    const timeOriginDelta = Math.abs(timeOrigin + performanceNow - dateNow);
-    if (timeOriginDelta < threshold) {
-      return timeOrigin;
+  let segment: TimeOriginSegment | undefined;
+  for (const candidate of _timeOriginSegments) {
+    if (segment && candidate.from > monotonicTimeInMs) {
+      break;
     }
+    segment = candidate;
   }
 
-  // timeOrigin is skewed or unavailable, fallback to subtracting
-  // `performance.now()` from `Date.now()`.
-  return dateNow - performanceNow;
-}
-
-/**
- * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
- * performance API is available.
- */
-export function browserPerformanceTimeOrigin(): number | undefined {
-  if (cachedTimeOrigin === null) {
-    cachedTimeOrigin = getBrowserTimeOrigin();
-  }
-
-  return cachedTimeOrigin;
+  return segment?.origin;
 }
diff --git a/packages/core/test/lib/utils/time.test.ts b/packages/core/test/lib/utils/time.test.ts
index 50ae3641701f..4d3979731ebe 100644
--- a/packages/core/test/lib/utils/time.test.ts
+++ b/packages/core/test/lib/utils/time.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 async function getFreshPerformanceTimeOrigin() {
   // Adding the query param with the date, forces a fresh import each time this is called
@@ -7,7 +7,375 @@ async function getFreshPerformanceTimeOrigin() {
   return timeModule.browserPerformanceTimeOrigin();
 }
 
-const RELIABLE_THRESHOLD_MS = 300_000;
+let freshImportCounter = 0;
+
+async function getFreshTimeModule(): Promise<{
+  timestampInSeconds: () => number;
+  performanceTimeToSeconds: (monotonicTimeInMs: number) => number | undefined;
+}> {
+  // We use a counter instead of `Date.now()` because fake timers freeze `Date.now()`, which would return a cached
+  // module.
+  return import(`../../../src/utils/time?update=${freshImportCounter++}`);
+}
+
+async function getFreshTimestampInSeconds(): Promise<() => number> {
+  return (await getFreshTimeModule()).timestampInSeconds;
+}
+
+const RELIABLE_THRESHOLD_MS = 1_000;
+
+describe('timestampInSeconds', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('derives the timestamp from `performance.timeOrigin` and `performance.now()`', async () => {
+    const currentTimeMs = 1767778040866;
+    const timeSincePageloadMs = 1_234.56789;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe(currentTimeMs / 1000);
+  });
+
+  it('falls back to `Date.now()` if the performance API is unavailable', async () => {
+    const currentTimeMs = 1767778040866;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', undefined);
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe(currentTimeMs / 1000);
+  });
+
+  it('keeps using `performance.timeOrigin` while the clocks agree', async () => {
+    const currentTimeMs = 1767778040866;
+    // Below the drift threshold, so we keep the (wrong) time origin.
+    const timeOriginSkewMs = RELIABLE_THRESHOLD_MS - 200;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs + timeOriginSkewMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe((currentTimeMs + timeOriginSkewMs) / 1000);
+
+    timeSincePageloadMs = 5_000;
+    vi.setSystemTime(new Date(currentTimeMs + 4_000));
+
+    expect(timestampInSeconds()).toBe((currentTimeMs + 4_000 + timeOriginSkewMs) / 1000);
+  });
+
+  it('resets the time origin when `performance.now()` drifts from `Date.now()`', async () => {
+    const currentTimeMs = 1767778040866;
+    const timeSincePageloadMs = 1_000;
+
+    // `performance.now()` stops during sleep, so `Date.now()` moves much further.
+    const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    expect(timestampInSeconds()).toBe(currentTimeMs / 1000);
+
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+
+    expect(timestampInSeconds()).toBe((currentTimeMs + sleepDurationMs) / 1000);
+  });
+
+  it('still uses `performance.now()` for elapsed time after a time origin reset', async () => {
+    const currentTimeMs = 1767778040866;
+    const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    timestampInSeconds();
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    const afterCorrection = timestampInSeconds();
+
+    // `Date.now()` stays the same while `performance.now()` moves by less than 1ms. This shows that elapsed time
+    // comes from `performance.now()`.
+    timeSincePageloadMs += 0.25;
+    expect(timestampInSeconds()).toBeCloseTo(afterCorrection + 0.25 / 1000, 10);
+  });
+
+  it('does not reset the time origin again once the clocks agree', async () => {
+    const currentTimeMs = 1767778040866;
+    const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    timestampInSeconds();
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    timestampInSeconds();
+
+    // Move both clocks by the same amount. The new time origin should stay in use.
+    for (let i = 1; i <= 3; i++) {
+      timeSincePageloadMs += 1_000;
+      vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs + i * 1_000));
+      expect(timestampInSeconds()).toBe((currentTimeMs + sleepDurationMs + i * 1_000) / 1000);
+    }
+  });
+
+  it('follows a backwards wall clock jump and keeps counting up afterwards', async () => {
+    const currentTimeMs = 1767778040866;
+
+    let timeSincePageloadMs = 1_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const timestampInSeconds = await getFreshTimestampInSeconds();
+
+    const before = timestampInSeconds();
+
+    // The wall clock jumps backwards by more than the threshold (e.g. NTP or the user changed it).
+    vi.setSystemTime(new Date(currentTimeMs - RELIABLE_THRESHOLD_MS - 60_000));
+    timeSincePageloadMs += 1_000;
+    const afterStep = timestampInSeconds();
+
+    // The reset moves the timestamp backwards once, but after that it counts up again.
+    timeSincePageloadMs += 1_000;
+    expect(timestampInSeconds()).toBeGreaterThan(afterStep);
+    expect(before).toBeGreaterThan(afterStep);
+  });
+});
+
+describe('performanceTimeToSeconds', () => {
+  const currentTimeMs = 1767778040866;
+  const timeSincePageloadMs = 1_000;
+  const sleepDurationMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('converts against `performance.timeOrigin` while the clocks agree', async () => {
+    const timeOrigin = currentTimeMs - timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', { timeOrigin, now: () => timeSincePageloadMs });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(500)).toBe((timeOrigin + 500) / 1000);
+  });
+
+  it('converts a time after a reset with the new time origin', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      // `performance.now()` stops during sleep, so it barely moves while `Date.now()` jumps ahead.
+      now: () => timeSincePageloadMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    timestampInSeconds();
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+
+    // Converting the current `performance.now()` must return the same time as `timestampInSeconds`. Otherwise,
+    // performance entries and spans would not line up.
+    expect(performanceTimeToSeconds(timeSincePageloadMs)).toBe(timestampInSeconds());
+    expect(performanceTimeToSeconds(timeSincePageloadMs)).toBe((currentTimeMs + sleepDurationMs) / 1000);
+  });
+
+  it('converts a time before a reset with the old time origin', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => monotonicNowMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    // An entry recorded before the drift.
+    const entryStartTime = 500;
+    const entryTimestampBefore = performanceTimeToSeconds(entryStartTime);
+    expect(entryTimestampBefore).toBe((currentTimeMs - timeSincePageloadMs + entryStartTime) / 1000);
+
+    // The device sleeps, we detect the drift, and reset the time origin.
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    monotonicNowMs += 10;
+    timestampInSeconds();
+
+    // Converting the same entry now must not shift it by the drift.
+    expect(performanceTimeToSeconds(entryStartTime)).toBe(entryTimestampBefore);
+  });
+
+  it('converts times before and after a reset with their own time origin', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => monotonicNowMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    // The new time origin applies from the last check where both clocks still matched.
+    const lastAgreedCheckMs = monotonicNowMs;
+    timestampInSeconds();
+
+    const monotonicAdvanceMs = 10;
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    monotonicNowMs += monotonicAdvanceMs;
+    timestampInSeconds();
+
+    const beforeCorrection = performanceTimeToSeconds(lastAgreedCheckMs - 1) as number;
+    const afterCorrection = performanceTimeToSeconds(lastAgreedCheckMs + 1) as number;
+
+    // The two times are 2ms apart in `performance.now()`, but their time origins are a whole sleep apart.
+    const driftMs = sleepDurationMs - monotonicAdvanceMs;
+    expect(afterCorrection - beforeCorrection).toBeCloseTo((driftMs + 2) / 1000, 6);
+  });
+
+  it('converts the first interaction after a sleep with the new time origin', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs,
+      now: () => monotonicNowMs,
+    });
+
+    const { performanceTimeToSeconds, timestampInSeconds } = await getFreshTimeModule();
+
+    timestampInSeconds();
+
+    // After waking up, the user clicks. The click's entry starts a few ms before we notice the drift.
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs));
+    const clickStartTime = (monotonicNowMs += 10);
+    monotonicNowMs += 5;
+    vi.setSystemTime(new Date(currentTimeMs + sleepDurationMs + 5));
+    const detectedAt = timestampInSeconds();
+
+    expect(performanceTimeToSeconds(clickStartTime)).toBeCloseTo(detectedAt - 0.005, 6);
+  });
+
+  it('keeps the page load origin when the max number of time origins is reached', async () => {
+    let monotonicNowMs = timeSincePageloadMs;
+    let wallNowMs = currentTimeMs;
+    const timeOrigin = currentTimeMs - timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(wallNowMs));
+    vi.stubGlobal('performance', { timeOrigin, now: () => monotonicNowMs });
+
+    const { browserPerformanceTimeOrigin, timestampInSeconds } = await getFreshTimeModule();
+
+    timestampInSeconds();
+    for (let i = 0; i < 40; i++) {
+      monotonicNowMs += 1_000;
+      wallNowMs += 1_000 + sleepDurationMs;
+      vi.setSystemTime(new Date(wallNowMs));
+      timestampInSeconds();
+    }
+
+    expect(browserPerformanceTimeOrigin()).toBe(timeOrigin);
+    expect(browserPerformanceTimeOrigin(monotonicNowMs)).toBe(wallNowMs - monotonicNowMs);
+  });
+
+  it('converts times before the oldest time origin with that origin', async () => {
+    const timeOrigin = currentTimeMs - timeSincePageloadMs;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', { timeOrigin, now: () => timeSincePageloadMs });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(0)).toBe(timeOrigin / 1000);
+  });
+
+  it('never uses a `performance.timeOrigin` that was already wrong at startup', async () => {
+    // Some browsers report a wrong `performance.timeOrigin`. We should never use it, not even for times from before
+    // our first check.
+    const timeOriginSkewMs = RELIABLE_THRESHOLD_MS + 60_000;
+
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', {
+      timeOrigin: currentTimeMs - timeSincePageloadMs + timeOriginSkewMs,
+      now: () => timeSincePageloadMs,
+    });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(0)).toBe((currentTimeMs - timeSincePageloadMs) / 1000);
+  });
+
+  it('converts against `Date.now() - performance.now()` if `performance.timeOrigin` is not available', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(currentTimeMs));
+    vi.stubGlobal('performance', { timeOrigin: undefined, now: () => timeSincePageloadMs });
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(500)).toBe((currentTimeMs - timeSincePageloadMs + 500) / 1000);
+  });
+
+  it('returns `undefined` if the performance API is unavailable', async () => {
+    vi.stubGlobal('performance', undefined);
+
+    const { performanceTimeToSeconds } = await getFreshTimeModule();
+
+    expect(performanceTimeToSeconds(500)).toBeUndefined();
+  });
+});
 
 describe('browserPerformanceTimeOrigin', () => {
   it('returns `performance.timeOrigin` if it is available and reliable', async () => {
diff --git a/packages/replay-internal/src/util/createPerformanceEntries.ts b/packages/replay-internal/src/util/createPerformanceEntries.ts
index 5d3435b7efbc..497f423c9083 100644
--- a/packages/replay-internal/src/util/createPerformanceEntries.ts
+++ b/packages/replay-internal/src/util/createPerformanceEntries.ts
@@ -1,4 +1,4 @@
-import { browserPerformanceTimeOrigin } from '@sentry/core';
+import { performanceTimeToSeconds } from '@sentry/core';
 import { record } from '@sentry/rrweb';
 import { WINDOW } from '../constants';
 import type {
@@ -87,9 +87,11 @@ function createPerformanceEntry(entry: AllPerformanceEntry): ReplayPerformanceEn
 }
 
 function getAbsoluteTime(time: number): number {
-  // browserPerformanceTimeOrigin can be undefined if `performance` or
-  // `performance.now` doesn't exist, but this is already checked by this integration
-  return ((browserPerformanceTimeOrigin() || WINDOW.performance.timeOrigin) + time) / 1000;
+  // Entries are only converted on flush, which can be minutes after they were recorded. `performanceTimeToSeconds`
+  // uses the time origin from when the entry was recorded, so a later reset does not shift it.
+  // It returns undefined if `performance` or `performance.now` doesn't exist, but this is already checked by this
+  // integration.
+  return performanceTimeToSeconds(time) ?? (WINDOW.performance.timeOrigin + time) / 1000;
 }
 
 function createPaintEntry(entry: PerformancePaintTiming): ReplayPerformanceEntry<PaintData> {
diff --git a/packages/replay-internal/test/integration/flush.test.ts b/packages/replay-internal/test/integration/flush.test.ts
index c7132595a424..ccc8ae8c607f 100644
--- a/packages/replay-internal/test/integration/flush.test.ts
+++ b/packages/replay-internal/test/integration/flush.test.ts
@@ -28,6 +28,7 @@ type MockRunFlush = MockedFunction<ReplayContainer['_runFlush']>;
 
 const prevLocation = WINDOW.location;
 const prevBrowserPerformanceTimeOrigin = SentryUtils.browserPerformanceTimeOrigin;
+const prevPerformanceTimeToSeconds = SentryUtils.performanceTimeToSeconds;
 
 describe('Integration | flush', () => {
   let domHandler: DomHandler;
@@ -92,6 +93,10 @@ describe('Integration | flush', () => {
       value: () => BASE_TIMESTAMP,
       writable: true,
     });
+    Object.defineProperty(SentryUtils, 'performanceTimeToSeconds', {
+      value: (time: number) => (BASE_TIMESTAMP + time) / 1000,
+      writable: true,
+    });
   });
 
   afterEach(async () => {
@@ -106,6 +111,10 @@ describe('Integration | flush', () => {
       value: () => prevBrowserPerformanceTimeOrigin,
       writable: true,
     });
+    Object.defineProperty(SentryUtils, 'performanceTimeToSeconds', {
+      value: prevPerformanceTimeToSeconds,
+      writable: true,
+    });
   });
 
   afterAll(() => {
diff --git a/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts b/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts
index c87d18bff325..8ce26a600dac 100644
--- a/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts
+++ b/packages/replay-internal/test/unit/util/createPerformanceEntry.test.ts
@@ -1,4 +1,5 @@
 import '../../utils/mock-internal-setTimeout';
+import { performanceTimeToSeconds } from '@sentry/core';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { WINDOW } from '../../../src/constants';
 import {
@@ -9,9 +10,12 @@ import {
 } from '../../../src/util/createPerformanceEntries';
 import { PerformanceEntryNavigation } from '../../fixtures/performanceEntry/navigation';
 
+const TIME_ORIGIN = new Date('2023-01-01').getTime();
+
 vi.mock('@sentry/core', async () => ({
   ...(await vi.importActual('@sentry/core')),
   browserPerformanceTimeOrigin: () => new Date('2023-01-01').getTime(),
+  performanceTimeToSeconds: vi.fn((time: number) => (new Date('2023-01-01').getTime() + time) / 1000),
 }));
 
 describe('Unit | util | createPerformanceEntries', () => {
@@ -21,6 +25,8 @@ describe('Unit | util | createPerformanceEntries', () => {
   });
 
   beforeEach(function () {
+    vi.mocked(performanceTimeToSeconds).mockImplementation(time => (TIME_ORIGIN + time) / 1000);
+
     if (!WINDOW.performance.getEntriesByType) {
       WINDOW.performance.getEntriesByType = vi.fn((type: string) => {
         if (type === 'navigation') {
@@ -67,6 +73,29 @@ describe('Unit | util | createPerformanceEntries', () => {
     expect(createPerformanceEntries([data])).toEqual([]);
   });
 
+  it('converts a buffered entry with the time origin from when it was recorded', () => {
+    // Entries are converted on flush, which can be after a time origin reset. Only times after the drift should use
+    // the new origin.
+    const driftPointMs = 200_000;
+    const sleepDurationMs = 3_600_000;
+    vi.mocked(performanceTimeToSeconds).mockImplementation(time =>
+      time < driftPointMs ? (TIME_ORIGIN + time) / 1000 : (TIME_ORIGIN + sleepDurationMs + time) / 1000,
+    );
+
+    const entries = createPerformanceEntries([
+      { name: 'first-paint', entryType: 'paint', startTime: 1000, duration: 0 },
+      { name: 'first-contentful-paint', entryType: 'paint', startTime: driftPointMs + 1000, duration: 0 },
+    ] as PerformanceEntry[]);
+
+    expect(entries).toEqual([
+      expect.objectContaining({ name: 'first-paint', start: (TIME_ORIGIN + 1000) / 1000 }),
+      expect.objectContaining({
+        name: 'first-contentful-paint',
+        start: (TIME_ORIGIN + sleepDurationMs + driftPointMs + 1000) / 1000,
+      }),
+    ]);
+  });
+
   describe('getLargestContentfulPaint', () => {
     it('works with an LCP metric', async () => {
       const metric = {