diff --git a/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts b/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
index 5a320ac4556a..f3998b693b38 100644
--- a/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
+++ b/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
@@ -4,10 +4,10 @@ import {
   SPAN_STATUS_OK,
   captureException,
   getClient,
-  getCurrentScope,
   handleCallbackErrors,
   startSpanManual,
   withIsolationScope,
+  withScope,
 } from '@sentry/core';
 import type { WebFetchHeaders } from '@sentry/types';
 import { propagationContextFromHeaders, winterCGHeadersToDict } from '@sentry/utils';
@@ -59,51 +59,53 @@ export function wrapGenerationFunctionWithSentry<F extends (...args: any[]) => a
         const propagationContext = commonObjectToPropagationContext(headers, incomingPropagationContext);
 
         return withIsolationScope(isolationScope, () => {
-          isolationScope.setTransactionName(`${componentType}.${generationFunctionIdentifier} (${componentRoute})`);
-          isolationScope.setSDKProcessingMetadata({
-            request: {
-              headers: headers ? winterCGHeadersToDict(headers) : undefined,
-            },
-          });
+          return withScope(scope => {
+            scope.setTransactionName(`${componentType}.${generationFunctionIdentifier} (${componentRoute})`);
+            isolationScope.setSDKProcessingMetadata({
+              request: {
+                headers: headers ? winterCGHeadersToDict(headers) : undefined,
+              },
+            });
 
-          getCurrentScope().setExtra('route_data', data);
-          getCurrentScope().setPropagationContext(propagationContext);
+            scope.setExtra('route_data', data);
+            scope.setPropagationContext(propagationContext);
 
-          return startSpanManual(
-            {
-              op: 'function.nextjs',
-              name: `${componentType}.${generationFunctionIdentifier} (${componentRoute})`,
-              forceTransaction: true,
-              attributes: {
-                [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
-                [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
-              },
-            },
-            span => {
-              return handleCallbackErrors(
-                () => originalFunction.apply(thisArg, args),
-                err => {
-                  if (isNotFoundNavigationError(err)) {
-                    // We don't want to report "not-found"s
-                    span.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
-                  } else if (isRedirectNavigationError(err)) {
-                    // We don't want to report redirects
-                    span.setStatus({ code: SPAN_STATUS_OK });
-                  } else {
-                    span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
-                    captureException(err, {
-                      mechanism: {
-                        handled: false,
-                      },
-                    });
-                  }
-                },
-                () => {
-                  span.end();
+            return startSpanManual(
+              {
+                op: 'function.nextjs',
+                name: `${componentType}.${generationFunctionIdentifier} (${componentRoute})`,
+                forceTransaction: true,
+                attributes: {
+                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
                 },
-              );
-            },
-          );
+              },
+              span => {
+                return handleCallbackErrors(
+                  () => originalFunction.apply(thisArg, args),
+                  err => {
+                    if (isNotFoundNavigationError(err)) {
+                      // We don't want to report "not-found"s
+                      span.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
+                    } else if (isRedirectNavigationError(err)) {
+                      // We don't want to report redirects
+                      span.setStatus({ code: SPAN_STATUS_OK });
+                    } else {
+                      span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
+                      captureException(err, {
+                        mechanism: {
+                          handled: false,
+                        },
+                      });
+                    }
+                  },
+                  () => {
+                    span.end();
+                  },
+                );
+              },
+            );
+          });
         });
       });
     },
diff --git a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
index b5da2743d97d..be378dc8cd5e 100644
--- a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
@@ -4,11 +4,11 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
   captureException,
-  getCurrentScope,
   handleCallbackErrors,
   setHttpStatus,
   startSpan,
   withIsolationScope,
+  withScope,
 } from '@sentry/core';
 import { propagationContextFromHeaders, winterCGHeadersToDict } from '@sentry/utils';
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
@@ -51,57 +51,59 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
 
         const propagationContext = commonObjectToPropagationContext(headers, incomingPropagationContext);
 
-        return withIsolationScope(isolationScope, async () => {
-          isolationScope.setTransactionName(`${method} ${parameterizedRoute}`);
-          getCurrentScope().setPropagationContext(propagationContext);
-          try {
-            return startSpan(
-              {
-                name: `${method} ${parameterizedRoute}`,
-                attributes: {
-                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
-                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
-                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
-                },
-                forceTransaction: true,
-              },
-              async span => {
-                const response: Response = await handleCallbackErrors(
-                  () => originalFunction.apply(thisArg, args),
-                  error => {
-                    // Next.js throws errors when calling `redirect()`. We don't wanna report these.
-                    if (isRedirectNavigationError(error)) {
-                      // Don't do anything
-                    } else if (isNotFoundNavigationError(error) && span) {
-                      span.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
-                    } else {
-                      captureException(error, {
-                        mechanism: {
-                          handled: false,
-                        },
-                      });
-                    }
+        return withIsolationScope(isolationScope, () => {
+          return withScope(async scope => {
+            scope.setTransactionName(`${method} ${parameterizedRoute}`);
+            scope.setPropagationContext(propagationContext);
+            try {
+              return startSpan(
+                {
+                  name: `${method} ${parameterizedRoute}`,
+                  attributes: {
+                    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+                    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
+                    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
                   },
-                );
+                  forceTransaction: true,
+                },
+                async span => {
+                  const response: Response = await handleCallbackErrors(
+                    () => originalFunction.apply(thisArg, args),
+                    error => {
+                      // Next.js throws errors when calling `redirect()`. We don't wanna report these.
+                      if (isRedirectNavigationError(error)) {
+                        // Don't do anything
+                      } else if (isNotFoundNavigationError(error) && span) {
+                        span.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
+                      } else {
+                        captureException(error, {
+                          mechanism: {
+                            handled: false,
+                          },
+                        });
+                      }
+                    },
+                  );
 
-                try {
-                  if (span && response.status) {
-                    setHttpStatus(span, response.status);
+                  try {
+                    if (span && response.status) {
+                      setHttpStatus(span, response.status);
+                    }
+                  } catch {
+                    // best effort - response may be undefined?
                   }
-                } catch {
-                  // best effort - response may be undefined?
-                }
 
-                return response;
-              },
-            );
-          } finally {
-            if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
-              // 1. Edge transport requires manual flushing
-              // 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
-              await flushQueue();
+                  return response;
+                },
+              );
+            } finally {
+              if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
+                // 1. Edge transport requires manual flushing
+                // 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
+                await flushQueue();
+              }
             }
-          }
+          });
         });
       });
     },