diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/.gitignore b/dev-packages/e2e-tests/test-applications/tsx-express/.gitignore
new file mode 100644
index 000000000000..1521c8b7652b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/.gitignore
@@ -0,0 +1 @@
+dist
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/.npmrc b/dev-packages/e2e-tests/test-applications/tsx-express/.npmrc
new file mode 100644
index 000000000000..070f80f05092
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/.npmrc
@@ -0,0 +1,2 @@
+@sentry:registry=http://127.0.0.1:4873
+@sentry-internal:registry=http://127.0.0.1:4873
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/instrument.mjs b/dev-packages/e2e-tests/test-applications/tsx-express/instrument.mjs
new file mode 100644
index 000000000000..7cb5f03691dc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/instrument.mjs
@@ -0,0 +1,13 @@
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  dsn: process.env.E2E_TEST_DSN,
+  includeLocalVariables: true,
+  debug: !!process.env.DEBUG,
+  tunnel: `http://localhost:3031/`, // proxy server
+  tracesSampleRate: 1,
+  _experiments: {
+    enableLogs: true,
+  },
+});
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/package.json b/dev-packages/e2e-tests/test-applications/tsx-express/package.json
new file mode 100644
index 000000000000..80dce608dbe5
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "tsx-express-app",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "start": "tsx --import ./instrument.mjs ./src/app.ts",
+    "test": "playwright test",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml",
+    "test:build": "pnpm install",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.10.2",
+    "@sentry/core": "latest || *",
+    "@sentry/node": "latest || *",
+    "@trpc/server": "10.45.2",
+    "@trpc/client": "10.45.2",
+    "@types/express": "^4.17.21",
+    "@types/node": "^18.19.1",
+    "express": "^4.21.2",
+    "typescript": "~5.0.0",
+    "zod": "~3.24.3"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.50.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "tsx": "^4.20.3"
+  },
+  "resolutions": {
+    "@types/qs": "6.9.17"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/playwright.config.mjs b/dev-packages/e2e-tests/test-applications/tsx-express/playwright.config.mjs
new file mode 100644
index 000000000000..31f2b913b58b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/playwright.config.mjs
@@ -0,0 +1,7 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const config = getPlaywrightConfig({
+  startCommand: `pnpm start`,
+});
+
+export default config;
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/src/app.ts b/dev-packages/e2e-tests/test-applications/tsx-express/src/app.ts
new file mode 100644
index 000000000000..a7b0f0bad8cc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/src/app.ts
@@ -0,0 +1,138 @@
+import * as Sentry from '@sentry/node';
+
+declare global {
+  namespace globalThis {
+    var transactionIds: string[];
+  }
+}
+
+import { TRPCError, initTRPC } from '@trpc/server';
+import * as trpcExpress from '@trpc/server/adapters/express';
+import express from 'express';
+import { z } from 'zod';
+import { mcpRouter } from './mcp';
+
+const app = express();
+const port = 3030;
+
+app.use(mcpRouter);
+
+app.get('/test-success', function (req, res) {
+  res.send({ version: 'v1' });
+});
+
+app.get('/test-log', function (req, res) {
+  Sentry.logger.debug('Accessed /test-log route');
+  res.send({ message: 'Log sent' });
+});
+
+app.get('/test-param/:param', function (req, res) {
+  res.send({ paramWas: req.params.param });
+});
+
+app.get('/test-transaction', function (req, res) {
+  Sentry.withActiveSpan(null, async () => {
+    Sentry.startSpan({ name: 'test-transaction', op: 'e2e-test' }, () => {
+      Sentry.startSpan({ name: 'test-span' }, () => undefined);
+    });
+
+    await Sentry.flush();
+
+    res.send({
+      transactionIds: global.transactionIds || [],
+    });
+  });
+});
+
+app.get('/test-error', async function (req, res) {
+  const exceptionId = Sentry.captureException(new Error('This is an error'));
+
+  await Sentry.flush(2000);
+
+  res.send({ exceptionId });
+});
+
+app.get('/test-exception/:id', function (req, _res) {
+  throw new Error(`This is an exception with id ${req.params.id}`);
+});
+
+app.get('/test-local-variables-uncaught', function (req, res) {
+  const randomVariableToRecord = Math.random();
+  throw new Error(`Uncaught Local Variable Error - ${JSON.stringify({ randomVariableToRecord })}`);
+});
+
+app.get('/test-local-variables-caught', function (req, res) {
+  const randomVariableToRecord = Math.random();
+
+  let exceptionId: string;
+  try {
+    throw new Error('Local Variable Error');
+  } catch (e) {
+    exceptionId = Sentry.captureException(e);
+  }
+
+  res.send({ exceptionId, randomVariableToRecord });
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+// @ts-ignore
+app.use(function onError(err, req, res, next) {
+  // The error id is attached to `res.sentry` to be returned
+  // and optionally displayed to the user for support.
+  res.statusCode = 500;
+  res.end(res.sentry + '\n');
+});
+
+app.listen(port, () => {
+  console.log(`Example app listening on port ${port}`);
+});
+
+Sentry.addEventProcessor(event => {
+  global.transactionIds = global.transactionIds || [];
+
+  if (event.type === 'transaction') {
+    const eventId = event.event_id;
+
+    if (eventId) {
+      global.transactionIds.push(eventId);
+    }
+  }
+
+  return event;
+});
+
+export const t = initTRPC.context<Context>().create();
+
+const procedure = t.procedure.use(Sentry.trpcMiddleware({ attachRpcInput: true }));
+
+export const appRouter = t.router({
+  getSomething: procedure.input(z.string()).query(opts => {
+    return { id: opts.input, name: 'Bilbo' };
+  }),
+  createSomething: procedure.mutation(async () => {
+    await new Promise(resolve => setTimeout(resolve, 400));
+    return { success: true };
+  }),
+  crashSomething: procedure
+    .input(z.object({ nested: z.object({ nested: z.object({ nested: z.string() }) }) }))
+    .mutation(() => {
+      throw new Error('I crashed in a trpc handler');
+    }),
+  unauthorized: procedure.mutation(() => {
+    throw new TRPCError({ code: 'UNAUTHORIZED', cause: new Error('Unauthorized') });
+  }),
+});
+
+export type AppRouter = typeof appRouter;
+
+const createContext = () => ({ someStaticValue: 'asdf' });
+type Context = Awaited<ReturnType<typeof createContext>>;
+
+app.use(
+  '/trpc',
+  trpcExpress.createExpressMiddleware({
+    router: appRouter,
+    createContext,
+  }),
+);
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/src/mcp.ts b/dev-packages/e2e-tests/test-applications/tsx-express/src/mcp.ts
new file mode 100644
index 000000000000..7565e08f7c85
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/src/mcp.ts
@@ -0,0 +1,64 @@
+import express from 'express';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { z } from 'zod';
+import { wrapMcpServerWithSentry } from '@sentry/core';
+
+const mcpRouter = express.Router();
+
+const server = wrapMcpServerWithSentry(
+  new McpServer({
+    name: 'Echo',
+    version: '1.0.0',
+  }),
+);
+
+server.resource('echo', new ResourceTemplate('echo://{message}', { list: undefined }), async (uri, { message }) => ({
+  contents: [
+    {
+      uri: uri.href,
+      text: `Resource echo: ${message}`,
+    },
+  ],
+}));
+
+server.tool('echo', { message: z.string() }, async ({ message }, rest) => {
+  return {
+    content: [{ type: 'text', text: `Tool echo: ${message}` }],
+  };
+});
+
+server.prompt('echo', { message: z.string() }, ({ message }, extra) => ({
+  messages: [
+    {
+      role: 'user',
+      content: {
+        type: 'text',
+        text: `Please process this message: ${message}`,
+      },
+    },
+  ],
+}));
+
+const transports: Record<string, SSEServerTransport> = {};
+
+mcpRouter.get('/sse', async (_, res) => {
+  const transport = new SSEServerTransport('/messages', res);
+  transports[transport.sessionId] = transport;
+  res.on('close', () => {
+    delete transports[transport.sessionId];
+  });
+  await server.connect(transport);
+});
+
+mcpRouter.post('/messages', async (req, res) => {
+  const sessionId = req.query.sessionId;
+  const transport = transports[sessionId as string];
+  if (transport) {
+    await transport.handlePostMessage(req, res);
+  } else {
+    res.status(400).send('No transport found for sessionId');
+  }
+});
+
+export { mcpRouter };
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/start-event-proxy.mjs b/dev-packages/e2e-tests/test-applications/tsx-express/start-event-proxy.mjs
new file mode 100644
index 000000000000..28093776d15c
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/start-event-proxy.mjs
@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'tsx-express',
+});
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/tsx-express/tests/errors.test.ts
new file mode 100644
index 000000000000..b6d59fbd0be9
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/tests/errors.test.ts
@@ -0,0 +1,42 @@
+import { expect, test } from '@playwright/test';
+import { waitForError } from '@sentry-internal/test-utils';
+
+test('Sends correct error event', async ({ baseURL }) => {
+  const errorEventPromise = waitForError('tsx-express', event => {
+    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception with id 123';
+  });
+
+  await fetch(`${baseURL}/test-exception/123`);
+
+  const errorEvent = await errorEventPromise;
+
+  expect(errorEvent.exception?.values).toHaveLength(1);
+  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception with id 123');
+
+  expect(errorEvent.request).toEqual({
+    method: 'GET',
+    cookies: {},
+    headers: expect.any(Object),
+    url: 'http://localhost:3030/test-exception/123',
+  });
+
+  expect(errorEvent.transaction).toEqual('GET /test-exception/:id');
+
+  expect(errorEvent.contexts?.trace).toEqual({
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+  });
+});
+
+test('Should record caught exceptions with local variable', async ({ baseURL }) => {
+  const errorEventPromise = waitForError('tsx-express', event => {
+    return event.transaction === 'GET /test-local-variables-caught';
+  });
+
+  await fetch(`${baseURL}/test-local-variables-caught`);
+
+  const errorEvent = await errorEventPromise;
+
+  const frames = errorEvent.exception?.values?.[0]?.stacktrace?.frames;
+  expect(frames?.[frames.length - 1]?.vars?.randomVariableToRecord).toBeDefined();
+});
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/tests/logs.test.ts b/dev-packages/e2e-tests/test-applications/tsx-express/tests/logs.test.ts
new file mode 100644
index 000000000000..be3a9694ac44
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/tests/logs.test.ts
@@ -0,0 +1,16 @@
+import { expect, test } from '@playwright/test';
+import { waitForEnvelopeItem } from '@sentry-internal/test-utils';
+import type { SerializedLog, SerializedLogContainer } from '@sentry/core';
+
+test('should send logs', async ({ baseURL }) => {
+  const logEnvelopePromise = waitForEnvelopeItem('tsx-express', envelope => {
+    return envelope[0].type === 'log' && (envelope[1] as SerializedLogContainer).items[0]?.level === 'debug';
+  });
+
+  await fetch(`${baseURL}/test-log`);
+
+  const logEnvelope = await logEnvelopePromise;
+  const log = (logEnvelope[1] as SerializedLogContainer).items[0];
+  expect(log?.level).toBe('debug');
+  expect(log?.body).toBe('Accessed /test-log route');
+});
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/tests/mcp.test.ts b/dev-packages/e2e-tests/test-applications/tsx-express/tests/mcp.test.ts
new file mode 100644
index 000000000000..995eba589cc7
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/tests/mcp.test.ts
@@ -0,0 +1,109 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+
+test('Should record transactions for mcp handlers', async ({ baseURL }) => {
+  const transport = new SSEClientTransport(new URL(`${baseURL}/sse`));
+
+  const client = new Client({
+    name: 'test-client',
+    version: '1.0.0',
+  });
+
+  await client.connect(transport);
+
+  await test.step('tool handler', async () => {
+    const postTransactionPromise = waitForTransaction('tsx-express', transactionEvent => {
+      return transactionEvent.transaction === 'POST /messages';
+    });
+    const toolTransactionPromise = waitForTransaction('tsx-express', transactionEvent => {
+      return transactionEvent.transaction === 'mcp-server/tool:echo';
+    });
+
+    const toolResult = await client.callTool({
+      name: 'echo',
+      arguments: {
+        message: 'foobar',
+      },
+    });
+
+    expect(toolResult).toMatchObject({
+      content: [
+        {
+          text: 'Tool echo: foobar',
+          type: 'text',
+        },
+      ],
+    });
+
+    const postTransaction = await postTransactionPromise;
+    expect(postTransaction).toBeDefined();
+
+    const toolTransaction = await toolTransactionPromise;
+    expect(toolTransaction).toBeDefined();
+
+    // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
+  });
+
+  await test.step('resource handler', async () => {
+    const postTransactionPromise = waitForTransaction('tsx-express', transactionEvent => {
+      return transactionEvent.transaction === 'POST /messages';
+    });
+    const resourceTransactionPromise = waitForTransaction('tsx-express', transactionEvent => {
+      return transactionEvent.transaction === 'mcp-server/resource:echo';
+    });
+
+    const resourceResult = await client.readResource({
+      uri: 'echo://foobar',
+    });
+
+    expect(resourceResult).toMatchObject({
+      contents: [{ text: 'Resource echo: foobar', uri: 'echo://foobar' }],
+    });
+
+    const postTransaction = await postTransactionPromise;
+    expect(postTransaction).toBeDefined();
+
+    const resourceTransaction = await resourceTransactionPromise;
+    expect(resourceTransaction).toBeDefined();
+
+    // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
+  });
+
+  await test.step('prompt handler', async () => {
+    const postTransactionPromise = waitForTransaction('tsx-express', transactionEvent => {
+      return transactionEvent.transaction === 'POST /messages';
+    });
+    const promptTransactionPromise = waitForTransaction('tsx-express', transactionEvent => {
+      return transactionEvent.transaction === 'mcp-server/prompt:echo';
+    });
+
+    const promptResult = await client.getPrompt({
+      name: 'echo',
+      arguments: {
+        message: 'foobar',
+      },
+    });
+
+    expect(promptResult).toMatchObject({
+      messages: [
+        {
+          content: {
+            text: 'Please process this message: foobar',
+            type: 'text',
+          },
+          role: 'user',
+        },
+      ],
+    });
+
+    const postTransaction = await postTransactionPromise;
+    expect(postTransaction).toBeDefined();
+
+    const promptTransaction = await promptTransactionPromise;
+    expect(promptTransaction).toBeDefined();
+
+    // TODO: When https://github.com/modelcontextprotocol/typescript-sdk/pull/358 is released check for trace id equality between the post transaction and the handler transaction
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/tests/transactions.test.ts b/dev-packages/e2e-tests/test-applications/tsx-express/tests/transactions.test.ts
new file mode 100644
index 000000000000..5415e3dacb5e
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/tests/transactions.test.ts
@@ -0,0 +1,199 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+test('Sends an API route transaction', async ({ baseURL }) => {
+  const pageloadTransactionEventPromise = waitForTransaction('tsx-express', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent?.transaction === 'GET /test-transaction'
+    );
+  });
+
+  await fetch(`${baseURL}/test-transaction`);
+
+  const transactionEvent = await pageloadTransactionEventPromise;
+
+  expect(transactionEvent.contexts?.trace).toEqual({
+    data: {
+      'sentry.source': 'route',
+      'sentry.origin': 'auto.http.otel.http',
+      'sentry.op': 'http.server',
+      'sentry.sample_rate': 1,
+      url: 'http://localhost:3030/test-transaction',
+      'otel.kind': 'SERVER',
+      'http.response.status_code': 200,
+      'http.url': 'http://localhost:3030/test-transaction',
+      'http.host': 'localhost:3030',
+      'net.host.name': 'localhost',
+      'http.method': 'GET',
+      'http.scheme': 'http',
+      'http.target': '/test-transaction',
+      'http.user_agent': 'node',
+      'http.flavor': '1.1',
+      'net.transport': 'ip_tcp',
+      'net.host.ip': expect.any(String),
+      'net.host.port': expect.any(Number),
+      'net.peer.ip': expect.any(String),
+      'net.peer.port': expect.any(Number),
+      'http.status_code': 200,
+      'http.status_text': 'OK',
+      'http.route': '/test-transaction',
+    },
+    op: 'http.server',
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    status: 'ok',
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+    origin: 'auto.http.otel.http',
+  });
+
+  expect(transactionEvent.contexts?.response).toEqual({
+    status_code: 200,
+  });
+
+  expect(transactionEvent).toEqual(
+    expect.objectContaining({
+      transaction: 'GET /test-transaction',
+      type: 'transaction',
+      transaction_info: {
+        source: 'route',
+      },
+    }),
+  );
+
+  const spans = transactionEvent.spans || [];
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'auto.http.otel.express',
+      'sentry.op': 'middleware.express',
+      'http.route': '/',
+      'express.name': 'query',
+      'express.type': 'middleware',
+    },
+    description: 'query',
+    op: 'middleware.express',
+    origin: 'auto.http.otel.express',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+  });
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'auto.http.otel.express',
+      'sentry.op': 'middleware.express',
+      'http.route': '/',
+      'express.name': 'expressInit',
+      'express.type': 'middleware',
+    },
+    description: 'expressInit',
+    op: 'middleware.express',
+    origin: 'auto.http.otel.express',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+  });
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'auto.http.otel.express',
+      'sentry.op': 'request_handler.express',
+      'http.route': '/test-transaction',
+      'express.name': '/test-transaction',
+      'express.type': 'request_handler',
+    },
+    description: '/test-transaction',
+    op: 'request_handler.express',
+    origin: 'auto.http.otel.express',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+  });
+});
+
+test('Sends an API route transaction for an errored route', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('tsx-express', transactionEvent => {
+    return (
+      transactionEvent.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.transaction === 'GET /test-exception/:id' &&
+      transactionEvent.request?.url === 'http://localhost:3030/test-exception/777'
+    );
+  });
+
+  await fetch(`${baseURL}/test-exception/777`);
+
+  const transactionEvent = await transactionEventPromise;
+
+  expect(transactionEvent.contexts?.trace?.op).toEqual('http.server');
+  expect(transactionEvent.transaction).toEqual('GET /test-exception/:id');
+  expect(transactionEvent.contexts?.trace?.status).toEqual('internal_error');
+  expect(transactionEvent.contexts?.trace?.data?.['http.status_code']).toEqual(500);
+
+  const spans = transactionEvent.spans || [];
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'auto.http.otel.express',
+      'sentry.op': 'middleware.express',
+      'http.route': '/',
+      'express.name': 'query',
+      'express.type': 'middleware',
+    },
+    description: 'query',
+    op: 'middleware.express',
+    origin: 'auto.http.otel.express',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+  });
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'auto.http.otel.express',
+      'sentry.op': 'middleware.express',
+      'http.route': '/',
+      'express.name': 'expressInit',
+      'express.type': 'middleware',
+    },
+    description: 'expressInit',
+    op: 'middleware.express',
+    origin: 'auto.http.otel.express',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+  });
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'auto.http.otel.express',
+      'sentry.op': 'request_handler.express',
+      'http.route': '/test-exception/:id',
+      'express.name': '/test-exception/:id',
+      'express.type': 'request_handler',
+    },
+    description: '/test-exception/:id',
+    op: 'request_handler.express',
+    origin: 'auto.http.otel.express',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/tsx-express/tests/trpc.test.ts b/dev-packages/e2e-tests/test-applications/tsx-express/tests/trpc.test.ts
new file mode 100644
index 000000000000..85ef5d6246da
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/tsx-express/tests/trpc.test.ts
@@ -0,0 +1,132 @@
+import { expect, test } from '@playwright/test';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
+import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
+import type { AppRouter } from '../src/app';
+
+test('Should record span for trpc query', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('tsx-express', transactionEvent => {
+    return (
+      transactionEvent.transaction === 'GET /trpc' &&
+      !!transactionEvent.spans?.find(span => span.description === 'trpc/getSomething')
+    );
+  });
+
+  const trpcClient = createTRPCProxyClient<AppRouter>({
+    links: [
+      httpBatchLink({
+        url: `${baseURL}/trpc`,
+      }),
+    ],
+  });
+
+  await trpcClient.getSomething.query('foobar');
+
+  await expect(transactionEventPromise).resolves.toBeDefined();
+  const transaction = await transactionEventPromise;
+
+  expect(transaction.spans).toContainEqual(
+    expect.objectContaining({
+      data: expect.objectContaining({
+        'sentry.op': 'rpc.server',
+        'sentry.origin': 'auto.rpc.trpc',
+      }),
+      description: `trpc/getSomething`,
+    }),
+  );
+});
+
+test('Should record transaction for trpc mutation', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('tsx-express', transactionEvent => {
+    return (
+      transactionEvent.transaction === 'POST /trpc' &&
+      !!transactionEvent.spans?.find(span => span.description === 'trpc/createSomething')
+    );
+  });
+
+  const trpcClient = createTRPCProxyClient<AppRouter>({
+    links: [
+      httpBatchLink({
+        url: `${baseURL}/trpc`,
+      }),
+    ],
+  });
+
+  await trpcClient.createSomething.mutate();
+
+  await expect(transactionEventPromise).resolves.toBeDefined();
+  const transaction = await transactionEventPromise;
+
+  expect(transaction.spans).toContainEqual(
+    expect.objectContaining({
+      data: expect.objectContaining({
+        'sentry.op': 'rpc.server',
+        'sentry.origin': 'auto.rpc.trpc',
+      }),
+      description: `trpc/createSomething`,
+    }),
+  );
+});
+
+test('Should record transaction and error for a crashing trpc handler', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('tsx-express', transactionEvent => {
+    return (
+      transactionEvent.transaction === 'POST /trpc' &&
+      !!transactionEvent.spans?.find(span => span.description === 'trpc/crashSomething')
+    );
+  });
+
+  const errorEventPromise = waitForError('tsx-express', errorEvent => {
+    return !!errorEvent?.exception?.values?.some(exception => exception.value?.includes('I crashed in a trpc handler'));
+  });
+
+  const trpcClient = createTRPCProxyClient<AppRouter>({
+    links: [
+      httpBatchLink({
+        url: `${baseURL}/trpc`,
+      }),
+    ],
+  });
+
+  await expect(trpcClient.crashSomething.mutate({ nested: { nested: { nested: 'foobar' } } })).rejects.toBeDefined();
+
+  await expect(transactionEventPromise).resolves.toBeDefined();
+  await expect(errorEventPromise).resolves.toBeDefined();
+
+  expect((await errorEventPromise).contexts?.trpc?.['procedure_type']).toBe('mutation');
+  expect((await errorEventPromise).contexts?.trpc?.['procedure_path']).toBe('crashSomething');
+
+  // Should record nested context
+  expect((await errorEventPromise).contexts?.trpc?.['input']).toEqual({
+    nested: {
+      nested: {
+        nested: 'foobar',
+      },
+    },
+  });
+});
+
+test('Should record transaction and error for a trpc handler that returns a status code', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('tsx-express', transactionEvent => {
+    return (
+      transactionEvent.transaction === 'POST /trpc' &&
+      !!transactionEvent.spans?.find(span => span.description === 'trpc/unauthorized')
+    );
+  });
+
+  const errorEventPromise = waitForError('tsx-express', errorEvent => {
+    return !!errorEvent?.exception?.values?.some(exception => exception.value?.includes('Unauthorized'));
+  });
+
+  const trpcClient = createTRPCProxyClient<AppRouter>({
+    links: [
+      httpBatchLink({
+        url: `${baseURL}/trpc`,
+      }),
+    ],
+  });
+
+  await expect(trpcClient.unauthorized.mutate()).rejects.toBeDefined();
+
+  await expect(transactionEventPromise).resolves.toBeDefined();
+  await expect(errorEventPromise).resolves.toBeDefined();
+});