diff --git a/packages/core/src/integrations/mcp-server/handlers.ts b/packages/core/src/integrations/mcp-server/handlers.ts
--- a/packages/core/src/integrations/mcp-server/handlers.ts
+++ b/packages/core/src/integrations/mcp-server/handlers.ts
@@ -41,7 +41,13 @@
  * @returns Wrapped handler function
  */
 function createWrappedHandler(originalHandler: MCPHandler, methodName: keyof MCPServerInstance, handlerName: string) {
-  return function (this: unknown, ...handlerArgs: unknown[]): unknown {
+  // Check if handler is already wrapped to prevent double-wrapping
+  // when both legacy and new API methods exist and one delegates to the other
+  if ((originalHandler as { __sentry_wrapped__?: boolean }).__sentry_wrapped__) {
+    return originalHandler;
+  }
+
+  const wrappedHandler = function (this: unknown, ...handlerArgs: unknown[]): unknown {
     try {
       return createErrorCapturingHandler.call(this, originalHandler, methodName, handlerName, handlerArgs);
     } catch (error) {
@@ -49,6 +55,11 @@
       return originalHandler.apply(this, handlerArgs);
     }
   };
+
+  // Mark the handler as wrapped
+  (wrappedHandler as { __sentry_wrapped__?: boolean }).__sentry_wrapped__ = true;
+
+  return wrappedHandler;
 }
 
 /**

diff --git a/packages/core/test/lib/integrations/mcp-server/mcpServerWrapper.test.ts b/packages/core/test/lib/integrations/mcp-server/mcpServerWrapper.test.ts
--- a/packages/core/test/lib/integrations/mcp-server/mcpServerWrapper.test.ts
+++ b/packages/core/test/lib/integrations/mcp-server/mcpServerWrapper.test.ts
@@ -178,4 +178,45 @@
       }).not.toThrow();
     });
   });
+
+  describe('Double-wrapping prevention', () => {
+    it('should not double-wrap handlers when both tool() and registerTool() exist and one delegates to the other', () => {
+      // Create a mock server with both APIs where tool() delegates to registerTool()
+      const registeredHandlers = new Map<string, any>();
+      const mockServerWithBothApis = {
+        registerTool: vi.fn((name: string, ...args: any[]) => {
+          const handler = args[args.length - 1];
+          registeredHandlers.set(name, handler);
+        }),
+        tool: vi.fn(function (this: any, name: string, handler: any) {
+          // Simulate legacy tool() delegating to registerTool()
+          return this.registerTool(name, {}, handler);
+        }),
+        resource: vi.fn(),
+        prompt: vi.fn(),
+        connect: vi.fn().mockResolvedValue(undefined),
+        server: {
+          setRequestHandler: vi.fn(),
+        },
+      };
+
+      const wrapped = wrapMcpServerWithSentry(mockServerWithBothApis);
+
+      // Register a handler via the legacy tool() method
+      const originalHandler = vi.fn();
+      wrapped.tool('test-tool', originalHandler);
+
+      // Get the registered handler
+      const registeredHandler = registeredHandlers.get('test-tool');
+
+      // The handler should be wrapped (have the __sentry_wrapped__ marker)
+      expect((registeredHandler as any).__sentry_wrapped__).toBe(true);
+
+      // Verify that calling tool() only wraps once, not twice
+      // If double-wrapped, the handler would have nested wrappers
+      // We can verify this by checking that the registered handler is the wrapped version
+      // and not a double-wrapped version
+      expect(registeredHandler).not.toBe(originalHandler);
+    });
+  });
 });