diff --git a/packages/core/src/instrument/console.ts b/packages/core/src/instrument/console.ts
index e96de345d202..cecf1e5cad8a 100644
--- a/packages/core/src/instrument/console.ts
+++ b/packages/core/src/instrument/console.ts
@@ -32,8 +32,7 @@ function instrumentConsole(): void {
       originalConsoleMethods[level] = originalConsoleMethod;
 
       return function (...args: any[]): void {
-        const handlerData: HandlerDataConsole = { args, level };
-        triggerHandlers('console', handlerData);
+        triggerHandlers('console', { args, level } as HandlerDataConsole);
 
         const log = originalConsoleMethods[level];
         log?.apply(GLOBAL_OBJ.console, args);
diff --git a/packages/core/test/lib/instrument/console.test.ts b/packages/core/test/lib/instrument/console.test.ts
new file mode 100644
index 000000000000..2499a231712d
--- /dev/null
+++ b/packages/core/test/lib/instrument/console.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+import { addConsoleInstrumentationHandler } from '../../../src/instrument/console';
+import { GLOBAL_OBJ } from '../../../src/utils/worldwide';
+
+describe('addConsoleInstrumentationHandler', () => {
+  it.each(['log', 'warn', 'error', 'debug', 'info'] as const)(
+    'calls registered handler when console.%s is called',
+    level => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console[level]('test message');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['test message'], level }));
+    },
+  );
+
+  it('calls through to the underlying console method without throwing', () => {
+    addConsoleInstrumentationHandler(vi.fn());
+    expect(() => GLOBAL_OBJ.console.log('hello')).not.toThrow();
+  });
+});
diff --git a/packages/node-core/src/common-exports.ts b/packages/node-core/src/common-exports.ts
index 1c724d2c29f6..b2f1deee7f4a 100644
--- a/packages/node-core/src/common-exports.ts
+++ b/packages/node-core/src/common-exports.ts
@@ -27,6 +27,7 @@ export { systemErrorIntegration } from './integrations/systemError';
 export { childProcessIntegration } from './integrations/childProcess';
 export { createSentryWinstonTransport } from './integrations/winston';
 export { pinoIntegration } from './integrations/pino';
+export { consoleIntegration } from './integrations/console';
 
 // SDK utilities
 export { getSentryRelease, defaultStackParser } from './sdk/api';
@@ -117,7 +118,6 @@ export {
   profiler,
   consoleLoggingIntegration,
   createConsolaReporter,
-  consoleIntegration,
   wrapMcpServerWithSentry,
   featureFlagsIntegration,
   spanStreamingIntegration,
diff --git a/packages/node-core/src/integrations/console.ts b/packages/node-core/src/integrations/console.ts
new file mode 100644
index 000000000000..27e4a5c6ae26
--- /dev/null
+++ b/packages/node-core/src/integrations/console.ts
@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+import type { ConsoleLevel, HandlerDataConsole, WrappedFunction } from '@sentry/core';
+import {
+  CONSOLE_LEVELS,
+  GLOBAL_OBJ,
+  consoleIntegration as coreConsoleIntegration,
+  defineIntegration,
+  fill,
+  markFunctionWrapped,
+  maybeInstrument,
+  originalConsoleMethods,
+  triggerHandlers,
+} from '@sentry/core';
+
+interface ConsoleIntegrationOptions {
+  levels: ConsoleLevel[];
+}
+
+/**
+ * Node-specific console integration that captures breadcrumbs and handles
+ * the AWS Lambda runtime replacing console methods after our patch.
+ *
+ * In Lambda, console methods are patched via `Object.defineProperty` so that
+ * external replacements (by the Lambda runtime) are absorbed as the delegate
+ * while our wrapper stays in place. Outside Lambda, this delegates entirely
+ * to the core `consoleIntegration` which uses the simpler `fill`-based patch.
+ */
+export const consoleIntegration = defineIntegration((options: Partial<ConsoleIntegrationOptions> = {}) => {
+  return {
+    name: 'Console',
+    setup(client) {
+      if (process.env.LAMBDA_TASK_ROOT) {
+        maybeInstrument('console', instrumentConsoleLambda);
+      }
+
+      // Delegate breadcrumb handling to the core console integration.
+      const core = coreConsoleIntegration(options);
+      core.setup?.(client);
+    },
+  };
+});
+
+function instrumentConsoleLambda(): void {
+  if (!('console' in GLOBAL_OBJ)) {
+    return;
+  }
+
+  CONSOLE_LEVELS.forEach(function (level: ConsoleLevel): void {
+    if (!(level in GLOBAL_OBJ.console)) {
+      return;
+    }
+
+    patchWithDefineProperty(level);
+  });
+}
+
+function patchWithDefineProperty(level: ConsoleLevel): void {
+  const nativeMethod = GLOBAL_OBJ.console[level] as (...args: unknown[]) => void;
+  originalConsoleMethods[level] = nativeMethod;
+
+  let consoleDelegate: Function = nativeMethod;
+  let isExecuting = false;
+
+  const wrapper = function (...args: any[]): void {
+    if (isExecuting) {
+      // Re-entrant call: a third party captured `wrapper` via the getter and calls it
+      // from inside their replacement (e.g. `const prev = console.log; console.log = (...a) => { prev(...a); }`).
+      // Calling `consoleDelegate` here would recurse, so fall back to the native method.
+      nativeMethod.apply(GLOBAL_OBJ.console, args);
+      return;
+    }
+    isExecuting = true;
+    try {
+      triggerHandlers('console', { args, level } as HandlerDataConsole);
+      consoleDelegate.apply(GLOBAL_OBJ.console, args);
+    } finally {
+      isExecuting = false;
+    }
+  };
+  markFunctionWrapped(wrapper as unknown as WrappedFunction, nativeMethod as unknown as WrappedFunction);
+
+  try {
+    let current: any = wrapper;
+
+    Object.defineProperty(GLOBAL_OBJ.console, level, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return current;
+      },
+      set(newValue) {
+        if (
+          typeof newValue === 'function' &&
+          newValue !== wrapper &&
+          newValue !== originalConsoleMethods[level] &&
+          !(newValue as WrappedFunction).__sentry_original__
+        ) {
+          consoleDelegate = newValue;
+          current = wrapper;
+        } else {
+          current = newValue;
+        }
+      },
+    });
+  } catch {
+    // Fall back to fill-based patching if defineProperty fails
+    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod: () => any): Function {
+      originalConsoleMethods[level] = originalConsoleMethod;
+
+      return function (...args: any[]): void {
+        triggerHandlers('console', { args, level } as HandlerDataConsole);
+
+        const log = originalConsoleMethods[level];
+        log?.apply(GLOBAL_OBJ.console, args);
+      };
+    });
+  }
+}
diff --git a/packages/node-core/src/light/sdk.ts b/packages/node-core/src/light/sdk.ts
index 77b62e9ab2f9..1d57da67a0ab 100644
--- a/packages/node-core/src/light/sdk.ts
+++ b/packages/node-core/src/light/sdk.ts
@@ -1,7 +1,6 @@
 import type { Integration, Options } from '@sentry/core';
 import {
   applySdkMetadata,
-  consoleIntegration,
   consoleSandbox,
   debug,
   envToBool,
@@ -25,6 +24,7 @@ import { onUncaughtExceptionIntegration } from '../integrations/onuncaughtexcept
 import { onUnhandledRejectionIntegration } from '../integrations/onunhandledrejection';
 import { processSessionIntegration } from '../integrations/processSession';
 import { INTEGRATION_NAME as SPOTLIGHT_INTEGRATION_NAME, spotlightIntegration } from '../integrations/spotlight';
+import { consoleIntegration } from '../integrations/console';
 import { systemErrorIntegration } from '../integrations/systemError';
 import { defaultStackParser, getSentryRelease } from '../sdk/api';
 import { makeNodeTransport } from '../transports';
diff --git a/packages/node-core/src/sdk/index.ts b/packages/node-core/src/sdk/index.ts
index 5ae840e6e976..52271ee62363 100644
--- a/packages/node-core/src/sdk/index.ts
+++ b/packages/node-core/src/sdk/index.ts
@@ -1,7 +1,6 @@
 import type { Integration, Options } from '@sentry/core';
 import {
   applySdkMetadata,
-  consoleIntegration,
   consoleSandbox,
   conversationIdIntegration,
   debug,
@@ -35,6 +34,7 @@ import { onUncaughtExceptionIntegration } from '../integrations/onuncaughtexcept
 import { onUnhandledRejectionIntegration } from '../integrations/onunhandledrejection';
 import { processSessionIntegration } from '../integrations/processSession';
 import { INTEGRATION_NAME as SPOTLIGHT_INTEGRATION_NAME, spotlightIntegration } from '../integrations/spotlight';
+import { consoleIntegration } from '../integrations/console';
 import { systemErrorIntegration } from '../integrations/systemError';
 import { makeNodeTransport } from '../transports';
 import type { NodeClientOptions, NodeOptions } from '../types';
diff --git a/packages/node-core/test/integrations/console.test.ts b/packages/node-core/test/integrations/console.test.ts
new file mode 100644
index 000000000000..849f9b9fe08b
--- /dev/null
+++ b/packages/node-core/test/integrations/console.test.ts
@@ -0,0 +1,203 @@
+// Set LAMBDA_TASK_ROOT before any imports so consoleIntegration uses patchWithDefineProperty
+process.env.LAMBDA_TASK_ROOT = '/var/task';
+
+import { afterAll, describe, expect, it, vi } from 'vitest';
+import type { WrappedFunction } from '@sentry/core';
+import {
+  addConsoleInstrumentationHandler,
+  consoleSandbox,
+  markFunctionWrapped,
+  originalConsoleMethods,
+  GLOBAL_OBJ,
+} from '@sentry/core';
+import { consoleIntegration } from '../../src/integrations/console';
+
+afterAll(() => {
+  delete process.env.LAMBDA_TASK_ROOT;
+});
+
+describe('consoleIntegration in Lambda (patchWithDefineProperty)', () => {
+  it('calls registered handler when console.log is called', () => {
+    const handler = vi.fn();
+    // Setup the integration so it calls maybeInstrument with the Lambda strategy
+    consoleIntegration().setup?.({ on: vi.fn() } as any);
+
+    addConsoleInstrumentationHandler(handler);
+
+    GLOBAL_OBJ.console.log('test');
+
+    expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['test'], level: 'log' }));
+  });
+
+  describe('external replacement (e.g. Lambda runtime overwriting console)', () => {
+    it('keeps firing the handler after console.log is replaced externally', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console.log = vi.fn();
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('after replacement');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['after replacement'], level: 'log' }));
+    });
+
+    it('calls the external replacement as the underlying method', () => {
+      addConsoleInstrumentationHandler(vi.fn());
+
+      const lambdaLogger = vi.fn();
+      GLOBAL_OBJ.console.log = lambdaLogger;
+
+      GLOBAL_OBJ.console.log('hello');
+
+      expect(lambdaLogger).toHaveBeenCalledWith('hello');
+    });
+
+    it('always delegates to the latest replacement', () => {
+      addConsoleInstrumentationHandler(vi.fn());
+
+      const first = vi.fn();
+      const second = vi.fn();
+
+      GLOBAL_OBJ.console.log = first;
+      GLOBAL_OBJ.console.log = second;
+
+      GLOBAL_OBJ.console.log('latest');
+
+      expect(first).not.toHaveBeenCalled();
+      expect(second).toHaveBeenCalledWith('latest');
+    });
+
+    it('does not mutate originalConsoleMethods (kept safe for consoleSandbox)', () => {
+      addConsoleInstrumentationHandler(vi.fn());
+
+      const nativeLog = originalConsoleMethods.log;
+      GLOBAL_OBJ.console.log = vi.fn();
+
+      expect(originalConsoleMethods.log).toBe(nativeLog);
+    });
+  });
+
+  describe('__sentry_original__ detection', () => {
+    it('accepts a function with __sentry_original__ without re-wrapping', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      const otherWrapper = vi.fn();
+      markFunctionWrapped(otherWrapper as unknown as WrappedFunction, vi.fn() as unknown as WrappedFunction);
+
+      GLOBAL_OBJ.console.log = otherWrapper;
+
+      expect(GLOBAL_OBJ.console.log).toBe(otherWrapper);
+    });
+
+    it('does not fire our handler when a __sentry_original__ wrapper is installed', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      const otherWrapper = vi.fn();
+      markFunctionWrapped(otherWrapper as unknown as WrappedFunction, vi.fn() as unknown as WrappedFunction);
+
+      GLOBAL_OBJ.console.log = otherWrapper;
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('via other wrapper');
+
+      expect(handler).not.toHaveBeenCalled();
+      expect(otherWrapper).toHaveBeenCalledWith('via other wrapper');
+    });
+
+    it('re-wraps a plain function without __sentry_original__', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console.log = vi.fn();
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('plain');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['plain'], level: 'log' }));
+    });
+  });
+
+  describe('consoleSandbox interaction', () => {
+    it('does not fire the handler inside consoleSandbox', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+      handler.mockClear();
+
+      consoleSandbox(() => {
+        GLOBAL_OBJ.console.log('sandbox message');
+      });
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('resumes firing the handler after consoleSandbox returns', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      consoleSandbox(() => {
+        GLOBAL_OBJ.console.log('inside sandbox');
+      });
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('after sandbox');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['after sandbox'], level: 'log' }));
+      expect(handler).not.toHaveBeenCalledWith(expect.objectContaining({ args: ['inside sandbox'], level: 'log' }));
+    });
+
+    it('does not fire the handler inside consoleSandbox after a Lambda-style replacement', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console.log = vi.fn();
+      handler.mockClear();
+
+      consoleSandbox(() => {
+        GLOBAL_OBJ.console.log('sandbox after lambda');
+      });
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('third-party capture-and-call wrapping', () => {
+    it('does not cause infinite recursion when a third party wraps console with the capture pattern', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+      handler.mockClear();
+
+      const prevLog = GLOBAL_OBJ.console.log;
+      const thirdPartyExtra = vi.fn();
+      GLOBAL_OBJ.console.log = (...args: any[]) => {
+        prevLog(...args);
+        thirdPartyExtra(...args);
+      };
+
+      expect(() => GLOBAL_OBJ.console.log('should not overflow')).not.toThrow();
+
+      expect(thirdPartyExtra).toHaveBeenCalledWith('should not overflow');
+      expect(handler).toHaveBeenCalledTimes(1);
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['should not overflow'], level: 'log' }));
+    });
+
+    it('consoleSandbox still bypasses the handler after third-party wrapping', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      const prevLog = GLOBAL_OBJ.console.log;
+      GLOBAL_OBJ.console.log = (...args: any[]) => {
+        prevLog(...args);
+      };
+      handler.mockClear();
+
+      consoleSandbox(() => {
+        GLOBAL_OBJ.console.log('should bypass');
+      });
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts
index ce9458079980..3bd5e1edba1c 100644
--- a/packages/node/src/index.ts
+++ b/packages/node/src/index.ts
@@ -137,7 +137,6 @@ export {
   profiler,
   consoleLoggingIntegration,
   createConsolaReporter,
-  consoleIntegration,
   wrapMcpServerWithSentry,
   featureFlagsIntegration,
   spanStreamingIntegration,
@@ -192,6 +191,7 @@ export {
   processSessionIntegration,
   nodeRuntimeMetricsIntegration,
   type NodeRuntimeMetricsOptions,
+  consoleIntegration,
   pinoIntegration,
   createSentryWinstonTransport,
   SentryContextManager,