diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 59ab696758c2..ce139e9e7787 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -921,6 +921,7 @@ jobs:
             'tanstack-router',
             'generic-ts3.8',
             'node-fastify',
+            'node-fastify-5',
             'node-hapi',
             'node-nestjs-basic',
             'node-nestjs-distributed-tracing',
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/.gitignore b/dev-packages/e2e-tests/test-applications/node-fastify-5/.gitignore
new file mode 100644
index 000000000000..1521c8b7652b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/.gitignore
@@ -0,0 +1 @@
+dist
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/.npmrc b/dev-packages/e2e-tests/test-applications/node-fastify-5/.npmrc
new file mode 100644
index 000000000000..070f80f05092
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/.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/node-fastify-5/package.json b/dev-packages/e2e-tests/test-applications/node-fastify-5/package.json
new file mode 100644
index 000000000000..4d1385df12b8
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/package.json
@@ -0,0 +1,31 @@
+{
+  "name": "node-fastify-5",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "start": "ts-node src/app.ts",
+    "test": "playwright test",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml",
+    "typecheck": "tsc",
+    "test:build": "pnpm install && pnpm run typecheck",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+    "@sentry/node": "latest || *",
+    "@sentry/types": "latest || *",
+    "@sentry/core": "latest || *",
+    "@sentry/utils": "latest || *",
+    "@sentry/opentelemetry": "latest || *",
+    "@types/node": "22.7.5",
+    "fastify": "5.0.0",
+    "typescript": "5.6.3",
+    "ts-node": "10.9.2"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.44.1",
+    "@sentry-internal/test-utils": "link:../../../test-utils"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/playwright.config.mjs b/dev-packages/e2e-tests/test-applications/node-fastify-5/playwright.config.mjs
new file mode 100644
index 000000000000..31f2b913b58b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/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/node-fastify-5/src/app.ts b/dev-packages/e2e-tests/test-applications/node-fastify-5/src/app.ts
new file mode 100644
index 000000000000..275dfa786ca3
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/src/app.ts
@@ -0,0 +1,153 @@
+import type * as S from '@sentry/node';
+const Sentry = require('@sentry/node') as typeof S;
+
+// We wrap console.warn to find out if a warning is incorrectly logged
+console.warn = new Proxy(console.warn, {
+  apply: function (target, thisArg, argumentsList) {
+    const msg = argumentsList[0];
+    if (typeof msg === 'string' && msg.startsWith('[Sentry]')) {
+      console.error(`Sentry warning was triggered: ${msg}`);
+      process.exit(1);
+    }
+
+    return target.apply(thisArg, argumentsList);
+  },
+});
+
+Sentry.init({
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  dsn: process.env.E2E_TEST_DSN,
+  integrations: [],
+  tracesSampleRate: 1,
+  tunnel: 'http://localhost:3031/', // proxy server
+  tracePropagationTargets: ['http://localhost:3030', '/external-allowed'],
+});
+
+import type * as H from 'http';
+import type * as F from 'fastify';
+
+// Make sure fastify is imported after Sentry is initialized
+const { fastify } = require('fastify') as typeof F;
+const http = require('http') as typeof H;
+
+const app = fastify();
+const port = 3030;
+const port2 = 3040;
+
+Sentry.setupFastifyErrorHandler(app);
+
+app.get('/test-success', function (_req, res) {
+  res.send({ version: 'v1' });
+});
+
+app.get<{ Params: { param: string } }>('/test-param/:param', function (req, res) {
+  res.send({ paramWas: req.params.param });
+});
+
+app.get<{ Params: { id: string } }>('/test-inbound-headers/:id', function (req, res) {
+  const headers = req.headers;
+
+  res.send({ headers, id: req.params.id });
+});
+
+app.get<{ Params: { id: string } }>('/test-outgoing-http/:id', async function (req, res) {
+  const id = req.params.id;
+  const data = await makeHttpRequest(`http://localhost:3030/test-inbound-headers/${id}`);
+
+  res.send(data);
+});
+
+app.get<{ Params: { id: string } }>('/test-outgoing-fetch/:id', async function (req, res) {
+  const id = req.params.id;
+  const response = await fetch(`http://localhost:3030/test-inbound-headers/${id}`);
+  const data = await response.json();
+
+  res.send(data);
+});
+
+app.get('/test-transaction', async function (req, res) {
+  Sentry.startSpan({ name: 'test-span' }, () => {
+    Sentry.startSpan({ name: 'child-span' }, () => {});
+  });
+
+  res.send({});
+});
+
+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<{ Params: { id: string } }>('/test-exception/:id', async function (req, res) {
+  throw new Error(`This is an exception with id ${req.params.id}`);
+});
+
+app.get('/test-outgoing-fetch-external-allowed', async function (req, res) {
+  const fetchResponse = await fetch(`http://localhost:${port2}/external-allowed`);
+  const data = await fetchResponse.json();
+
+  res.send(data);
+});
+
+app.get('/test-outgoing-fetch-external-disallowed', async function (req, res) {
+  const fetchResponse = await fetch(`http://localhost:${port2}/external-disallowed`);
+  const data = await fetchResponse.json();
+
+  res.send(data);
+});
+
+app.get('/test-outgoing-http-external-allowed', async function (req, res) {
+  const data = await makeHttpRequest(`http://localhost:${port2}/external-allowed`);
+  res.send(data);
+});
+
+app.get('/test-outgoing-http-external-disallowed', async function (req, res) {
+  const data = await makeHttpRequest(`http://localhost:${port2}/external-disallowed`);
+  res.send(data);
+});
+
+app.listen({ port: port });
+
+// A second app so we can test header propagation between external URLs
+const app2 = fastify();
+app2.get('/external-allowed', function (req, res) {
+  const headers = req.headers;
+
+  res.send({ headers, route: '/external-allowed' });
+});
+
+app2.get('/external-disallowed', function (req, res) {
+  const headers = req.headers;
+
+  res.send({ headers, route: '/external-disallowed' });
+});
+
+app2.listen({ port: port2 });
+
+function makeHttpRequest(url: string) {
+  return new Promise(resolve => {
+    const data: any[] = [];
+
+    http
+      .request(url, httpRes => {
+        httpRes.on('data', chunk => {
+          data.push(chunk);
+        });
+        httpRes.on('error', error => {
+          resolve({ error: error.message, url });
+        });
+        httpRes.on('end', () => {
+          try {
+            const json = JSON.parse(Buffer.concat(data).toString());
+            resolve(json);
+          } catch {
+            resolve({ data: Buffer.concat(data).toString(), url });
+          }
+        });
+      })
+      .end();
+  });
+}
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/start-event-proxy.mjs b/dev-packages/e2e-tests/test-applications/node-fastify-5/start-event-proxy.mjs
new file mode 100644
index 000000000000..0de44700dd11
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/start-event-proxy.mjs
@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'node-fastify-5',
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/errors.test.ts
new file mode 100644
index 000000000000..67b27a6c0e5e
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/errors.test.ts
@@ -0,0 +1,29 @@
+import { expect, test } from '@playwright/test';
+import { waitForError } from '@sentry-internal/test-utils';
+
+test('Sends correct error event', async ({ baseURL }) => {
+  const errorEventPromise = waitForError('node-fastify-5', 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.any(String),
+    span_id: expect.any(String),
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/propagation.test.ts b/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/propagation.test.ts
new file mode 100644
index 000000000000..050ce19c6a3c
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/propagation.test.ts
@@ -0,0 +1,356 @@
+import crypto from 'crypto';
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+import { SpanJSON } from '@sentry/types';
+
+test('Propagates trace for outgoing http requests', async ({ baseURL }) => {
+  const id = crypto.randomUUID();
+
+  const inboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-inbound-headers/${id}`
+    );
+  });
+
+  const outboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-http/${id}`
+    );
+  });
+
+  const response = await fetch(`${baseURL}/test-outgoing-http/${id}`);
+  const data = await response.json();
+
+  const inboundTransaction = await inboundTransactionPromise;
+  const outboundTransaction = await outboundTransactionPromise;
+
+  const traceId = outboundTransaction?.contexts?.trace?.trace_id;
+  const outgoingHttpSpan = outboundTransaction?.spans?.find(span => span.op === 'http.client') as SpanJSON | undefined;
+
+  expect(outgoingHttpSpan).toBeDefined();
+
+  const outgoingHttpSpanId = outgoingHttpSpan?.span_id;
+
+  expect(traceId).toEqual(expect.any(String));
+
+  // data is passed through from the inbound request, to verify we have the correct headers set
+  const inboundHeaderSentryTrace = data.headers?.['sentry-trace'];
+  const inboundHeaderBaggage = data.headers?.['baggage'];
+
+  expect(inboundHeaderSentryTrace).toEqual(`${traceId}-${outgoingHttpSpanId}-1`);
+  expect(inboundHeaderBaggage).toBeDefined();
+
+  const baggage = (inboundHeaderBaggage || '').split(',');
+  expect(baggage).toEqual(
+    expect.arrayContaining([
+      'sentry-environment=qa',
+      `sentry-trace_id=${traceId}`,
+      expect.stringMatching(/sentry-public_key=/),
+    ]),
+  );
+
+  expect(outboundTransaction.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-outgoing-http/${id}`,
+      'otel.kind': 'SERVER',
+      'http.response.status_code': 200,
+      'http.url': `http://localhost:3030/test-outgoing-http/${id}`,
+      'http.host': 'localhost:3030',
+      'net.host.name': 'localhost',
+      'http.method': 'GET',
+      'http.scheme': 'http',
+      'http.target': `/test-outgoing-http/${id}`,
+      '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-outgoing-http/:id',
+    },
+    op: 'http.server',
+    span_id: expect.any(String),
+    status: 'ok',
+    trace_id: traceId,
+    origin: 'auto.http.otel.http',
+  });
+
+  expect(inboundTransaction.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-inbound-headers/${id}`,
+      'otel.kind': 'SERVER',
+      'http.response.status_code': 200,
+      'http.url': `http://localhost:3030/test-inbound-headers/${id}`,
+      'http.host': 'localhost:3030',
+      'net.host.name': 'localhost',
+      'http.method': 'GET',
+      'http.scheme': 'http',
+      'http.target': `/test-inbound-headers/${id}`,
+      '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-inbound-headers/:id',
+    },
+    op: 'http.server',
+    parent_span_id: outgoingHttpSpanId,
+    span_id: expect.any(String),
+    status: 'ok',
+    trace_id: traceId,
+    origin: 'auto.http.otel.http',
+  });
+});
+
+test('Propagates trace for outgoing fetch requests', async ({ baseURL }) => {
+  const id = crypto.randomUUID();
+
+  const inboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-inbound-headers/${id}`
+    );
+  });
+
+  const outboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-fetch/${id}`
+    );
+  });
+
+  const response = await fetch(`${baseURL}/test-outgoing-fetch/${id}`);
+  const data = await response.json();
+
+  const inboundTransaction = await inboundTransactionPromise;
+  const outboundTransaction = await outboundTransactionPromise;
+
+  const traceId = outboundTransaction?.contexts?.trace?.trace_id;
+  const outgoingHttpSpan = outboundTransaction?.spans?.find(span => span.op === 'http.client') as SpanJSON | undefined;
+
+  expect(outgoingHttpSpan).toBeDefined();
+
+  const outgoingHttpSpanId = outgoingHttpSpan?.span_id;
+
+  expect(traceId).toEqual(expect.any(String));
+
+  // data is passed through from the inbound request, to verify we have the correct headers set
+  const inboundHeaderSentryTrace = data.headers?.['sentry-trace'];
+  const inboundHeaderBaggage = data.headers?.['baggage'];
+
+  expect(inboundHeaderSentryTrace).toEqual(`${traceId}-${outgoingHttpSpanId}-1`);
+  expect(inboundHeaderBaggage).toBeDefined();
+
+  const baggage = (inboundHeaderBaggage || '').split(',');
+  expect(baggage).toEqual(
+    expect.arrayContaining([
+      'sentry-environment=qa',
+      `sentry-trace_id=${traceId}`,
+      expect.stringMatching(/sentry-public_key=/),
+    ]),
+  );
+
+  expect(outboundTransaction.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-outgoing-fetch/${id}`,
+      'otel.kind': 'SERVER',
+      'http.response.status_code': 200,
+      'http.url': `http://localhost:3030/test-outgoing-fetch/${id}`,
+      'http.host': 'localhost:3030',
+      'net.host.name': 'localhost',
+      'http.method': 'GET',
+      'http.scheme': 'http',
+      'http.target': `/test-outgoing-fetch/${id}`,
+      '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-outgoing-fetch/:id',
+    },
+    op: 'http.server',
+    span_id: expect.any(String),
+    status: 'ok',
+    trace_id: traceId,
+    origin: 'auto.http.otel.http',
+  });
+
+  expect(inboundTransaction.contexts?.trace).toEqual({
+    data: expect.objectContaining({
+      'sentry.source': 'route',
+      'sentry.origin': 'auto.http.otel.http',
+      'sentry.op': 'http.server',
+      'sentry.sample_rate': 1,
+      url: `http://localhost:3030/test-inbound-headers/${id}`,
+      'otel.kind': 'SERVER',
+      'http.response.status_code': 200,
+      'http.url': `http://localhost:3030/test-inbound-headers/${id}`,
+      'http.host': 'localhost:3030',
+      'net.host.name': 'localhost',
+      'http.method': 'GET',
+      'http.scheme': 'http',
+      'http.target': `/test-inbound-headers/${id}`,
+      '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-inbound-headers/:id',
+    }),
+    op: 'http.server',
+    parent_span_id: outgoingHttpSpanId,
+    span_id: expect.any(String),
+    status: 'ok',
+    trace_id: traceId,
+    origin: 'auto.http.otel.http',
+  });
+});
+
+test('Propagates trace for outgoing external http requests', async ({ baseURL }) => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-http-external-allowed`
+    );
+  });
+
+  const response = await fetch(`${baseURL}/test-outgoing-http-external-allowed`);
+  const data = await response.json();
+
+  const inboundTransaction = await inboundTransactionPromise;
+
+  const traceId = inboundTransaction?.contexts?.trace?.trace_id;
+  const spanId = inboundTransaction?.spans?.find(span => span.op === 'http.client')?.span_id;
+
+  expect(traceId).toEqual(expect.any(String));
+  expect(spanId).toEqual(expect.any(String));
+
+  expect(data).toEqual({
+    route: '/external-allowed',
+    headers: expect.objectContaining({
+      'sentry-trace': `${traceId}-${spanId}-1`,
+      baggage: expect.any(String),
+    }),
+  });
+
+  const baggage = (data.headers.baggage || '').split(',');
+  expect(baggage).toEqual(
+    expect.arrayContaining([
+      'sentry-environment=qa',
+      `sentry-trace_id=${traceId}`,
+      expect.stringMatching(/sentry-public_key=/),
+    ]),
+  );
+});
+
+test('Does not propagate outgoing http requests not covered by tracePropagationTargets', async ({ baseURL }) => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-http-external-disallowed`
+    );
+  });
+
+  const response = await fetch(`${baseURL}/test-outgoing-http-external-disallowed`);
+  const data = await response.json();
+
+  const inboundTransaction = await inboundTransactionPromise;
+
+  const traceId = inboundTransaction?.contexts?.trace?.trace_id;
+  const spanId = inboundTransaction?.spans?.find(span => span.op === 'http.client')?.span_id;
+
+  expect(traceId).toEqual(expect.any(String));
+  expect(spanId).toEqual(expect.any(String));
+
+  expect(data.route).toBe('/external-disallowed');
+  expect(data.headers?.['sentry-trace']).toBeUndefined();
+  expect(data.headers?.baggage).toBeUndefined();
+});
+
+test('Propagates trace for outgoing external fetch requests', async ({ baseURL }) => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-fetch-external-allowed`
+    );
+  });
+
+  const response = await fetch(`${baseURL}/test-outgoing-fetch-external-allowed`);
+  const data = await response.json();
+
+  const inboundTransaction = await inboundTransactionPromise;
+
+  const traceId = inboundTransaction?.contexts?.trace?.trace_id;
+  const spanId = inboundTransaction?.spans?.find(span => span.op === 'http.client')?.span_id;
+
+  expect(traceId).toEqual(expect.any(String));
+  expect(spanId).toEqual(expect.any(String));
+
+  expect(data).toEqual({
+    route: '/external-allowed',
+    headers: expect.objectContaining({
+      'sentry-trace': `${traceId}-${spanId}-1`,
+      baggage: expect.any(String),
+    }),
+  });
+
+  const baggage = (data.headers.baggage || '').split(',');
+  expect(baggage).toEqual(
+    expect.arrayContaining([
+      'sentry-environment=qa',
+      `sentry-trace_id=${traceId}`,
+      expect.stringMatching(/sentry-public_key=/),
+    ]),
+  );
+});
+
+test('Does not propagate outgoing fetch requests not covered by tracePropagationTargets', async ({ baseURL }) => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-5', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-fetch-external-disallowed`
+    );
+  });
+
+  const response = await fetch(`${baseURL}/test-outgoing-fetch-external-disallowed`);
+  const data = await response.json();
+
+  const inboundTransaction = await inboundTransactionPromise;
+
+  const traceId = inboundTransaction?.contexts?.trace?.trace_id;
+  const spanId = inboundTransaction?.spans?.find(span => span.op === 'http.client')?.span_id;
+
+  expect(traceId).toEqual(expect.any(String));
+  expect(spanId).toEqual(expect.any(String));
+
+  expect(data.route).toBe('/external-disallowed');
+  expect(data.headers?.['sentry-trace']).toBeUndefined();
+  expect(data.headers?.baggage).toBeUndefined();
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/transactions.test.ts b/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/transactions.test.ts
new file mode 100644
index 000000000000..6ca2d19f3b32
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/tests/transactions.test.ts
@@ -0,0 +1,126 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+test('Sends an API route transaction', async ({ baseURL }) => {
+  const pageloadTransactionEventPromise = waitForTransaction('node-fastify-5', 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.any(String),
+    status: 'ok',
+    trace_id: expect.any(String),
+    origin: 'auto.http.otel.http',
+  });
+
+  expect(transactionEvent).toEqual(
+    expect.objectContaining({
+      transaction: 'GET /test-transaction',
+      type: 'transaction',
+      transaction_info: {
+        source: 'route',
+      },
+    }),
+  );
+
+  const spans = transactionEvent.spans || [];
+
+  expect(spans).toContainEqual({
+    data: {
+      'plugin.name': 'fastify -> sentry-fastify-error-handler',
+      'fastify.type': 'middleware',
+      'hook.name': 'onRequest',
+      'sentry.origin': 'auto.http.otel.fastify',
+      'sentry.op': 'middleware.fastify',
+    },
+    description: 'sentry-fastify-error-handler',
+    op: 'middleware.fastify',
+    parent_span_id: expect.any(String),
+    span_id: expect.any(String),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    origin: 'auto.http.otel.fastify',
+  });
+
+  expect(spans).toContainEqual({
+    data: {
+      'plugin.name': 'fastify -> sentry-fastify-error-handler',
+      'fastify.type': 'request_handler',
+      'http.route': '/test-transaction',
+      'sentry.op': 'request_handler.fastify',
+      'sentry.origin': 'auto.http.otel.fastify',
+    },
+    description: 'sentry-fastify-error-handler',
+    op: 'request_handler.fastify',
+    parent_span_id: expect.any(String),
+    span_id: expect.any(String),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    origin: 'auto.http.otel.fastify',
+  });
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'manual',
+    },
+    description: 'test-span',
+    parent_span_id: expect.any(String),
+    span_id: expect.any(String),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    origin: 'manual',
+  });
+
+  expect(spans).toContainEqual({
+    data: {
+      'sentry.origin': 'manual',
+    },
+    description: 'child-span',
+    parent_span_id: expect.any(String),
+    span_id: expect.any(String),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    origin: 'manual',
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-fastify-5/tsconfig.json b/dev-packages/e2e-tests/test-applications/node-fastify-5/tsconfig.json
new file mode 100644
index 000000000000..6b69bfaa593b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/node-fastify-5/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "types": ["node"],
+    "esModuleInterop": true,
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "strict": true,
+    "outDir": "dist"
+  },
+  "include": ["./src/*.ts"]
+}
diff --git a/packages/node/package.json b/packages/node/package.json
index 52559d93ed27..03362092b86a 100644
--- a/packages/node/package.json
+++ b/packages/node/package.json
@@ -73,7 +73,7 @@
     "@opentelemetry/instrumentation-connect": "0.39.0",
     "@opentelemetry/instrumentation-dataloader": "0.12.0",
     "@opentelemetry/instrumentation-express": "0.43.0",
-    "@opentelemetry/instrumentation-fastify": "0.39.0",
+    "@opentelemetry/instrumentation-fastify": "0.40.0",
     "@opentelemetry/instrumentation-fs": "0.15.0",
     "@opentelemetry/instrumentation-generic-pool": "0.39.0",
     "@opentelemetry/instrumentation-graphql": "0.43.0",
diff --git a/yarn.lock b/yarn.lock
index db64fa00fc6c..48991d296050 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7335,10 +7335,10 @@
     "@opentelemetry/instrumentation" "^0.53.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-fastify@0.39.0":
-  version "0.39.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-fastify/-/instrumentation-fastify-0.39.0.tgz#96a040e4944daf77c53a8fe5a128bc3b2568e4aa"
-  integrity sha512-SS9uSlKcsWZabhBp2szErkeuuBDgxOUlllwkS92dVaWRnMmwysPhcEgHKB8rUe3BHg/GnZC1eo1hbTZv4YhfoA==
+"@opentelemetry/instrumentation-fastify@0.40.0":
+  version "0.40.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-fastify/-/instrumentation-fastify-0.40.0.tgz#0c57608ac202337d56b53338f1fc9369d224306b"
+  integrity sha512-74qj4nG3zPtU7g2x4sm2T4R3/pBMyrYstTsqSZwdlhQk1SD4l8OSY9sPRX1qkhfxOuW3U4KZQAV/Cymb3fB6hg==
   dependencies:
     "@opentelemetry/core" "^1.8.0"
     "@opentelemetry/instrumentation" "^0.53.0"