diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/server/api/cache-test.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/server/api/cache-test.ts
new file mode 100644
index 000000000000..b19530e18c96
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-3/server/api/cache-test.ts
@@ -0,0 +1,84 @@
+import { cachedFunction, defineCachedEventHandler, defineEventHandler, getQuery } from '#imports';
+
+// Test cachedFunction
+const getCachedUser = cachedFunction(
+  async (userId: string) => {
+    return {
+      id: userId,
+      name: `User ${userId}`,
+      email: `user${userId}@example.com`,
+      timestamp: Date.now(),
+    };
+  },
+  {
+    maxAge: 60,
+    name: 'getCachedUser',
+    getKey: (userId: string) => `user:${userId}`,
+  },
+);
+
+// Test cachedFunction with different options
+const getCachedData = cachedFunction(
+  async (key: string) => {
+    return {
+      key,
+      value: `cached-value-${key}`,
+      timestamp: Date.now(),
+    };
+  },
+  {
+    maxAge: 120,
+    name: 'getCachedData',
+    getKey: (key: string) => `data:${key}`,
+  },
+);
+
+// Test defineCachedEventHandler
+const cachedHandler = defineCachedEventHandler(
+  async event => {
+    return {
+      message: 'This response is cached',
+      timestamp: Date.now(),
+      path: event.path,
+    };
+  },
+  {
+    maxAge: 60,
+    name: 'cachedHandler',
+  },
+);
+
+export default defineEventHandler(async event => {
+  const results: Record<string, unknown> = {};
+  const testKey = String(getQuery(event).user ?? '');
+  const dataKey = String(getQuery(event).data ?? '');
+
+  // Test cachedFunction - first call (cache miss)
+  const user1 = await getCachedUser(testKey);
+  results.cachedUser1 = user1;
+
+  // Test cachedFunction - second call (cache hit)
+  const user2 = await getCachedUser(testKey);
+  results.cachedUser2 = user2;
+
+  // Test cachedFunction with different key (cache miss)
+  const user3 = await getCachedUser(`${testKey}456`);
+  results.cachedUser3 = user3;
+
+  // Test another cachedFunction
+  const data1 = await getCachedData(dataKey);
+  results.cachedData1 = data1;
+
+  // Test cachedFunction - cache hit
+  const data2 = await getCachedData(dataKey);
+  results.cachedData2 = data2;
+
+  // Test cachedEventHandler by calling it
+  const cachedResponse = await cachedHandler(event);
+  results.cachedResponse = cachedResponse;
+
+  return {
+    success: true,
+    results,
+  };
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/tests/cache.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/tests/cache.test.ts
new file mode 100644
index 000000000000..a1697136ef01
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-3/tests/cache.test.ts
@@ -0,0 +1,161 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/nuxt';
+
+test.describe('Cache Instrumentation', () => {
+  const SEMANTIC_ATTRIBUTE_CACHE_KEY = 'cache.key';
+  const SEMANTIC_ATTRIBUTE_CACHE_HIT = 'cache.hit';
+
+  test('instruments cachedFunction and cachedEventHandler calls and creates spans with correct attributes', async ({
+    request,
+  }) => {
+    const transactionPromise = waitForTransaction('nuxt-3', transactionEvent => {
+      return transactionEvent.transaction?.includes('GET /api/cache-test') ?? false;
+    });
+
+    const response = await request.get('/api/cache-test?user=123&data=test-key');
+    expect(response.status()).toBe(200);
+
+    const transaction = await transactionPromise;
+
+    // Helper to find spans by operation
+    const findSpansByOp = (op: string) => {
+      return transaction.spans?.filter(span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] === op) || [];
+    };
+
+    // Test that we have cache operations from cachedFunction and cachedEventHandler
+    const allCacheSpans = transaction.spans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] === 'auto.cache.nuxt',
+    );
+    expect(allCacheSpans?.length).toBeGreaterThan(0);
+
+    // Test getItem spans for cachedFunction - should have both cache miss and cache hit
+    const getItemSpans = findSpansByOp('cache.get_item');
+    expect(getItemSpans.length).toBeGreaterThan(0);
+
+    // Find cache miss (first call to getCachedUser('123'))
+    const cacheMissSpan = getItemSpans.find(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('user:123') &&
+        !span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT],
+    );
+    if (cacheMissSpan) {
+      expect(cacheMissSpan.data).toMatchObject({
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'cache.get_item',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.cache.nuxt',
+        [SEMANTIC_ATTRIBUTE_CACHE_HIT]: false,
+        'db.operation.name': 'getItem',
+        'db.collection.name': expect.stringMatching(/^(cache)?$/),
+      });
+    }
+
+    // Find cache hit (second call to getCachedUser('123'))
+    const cacheHitSpan = getItemSpans.find(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('user:123') &&
+        span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT],
+    );
+    if (cacheHitSpan) {
+      expect(cacheHitSpan.data).toMatchObject({
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'cache.get_item',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.cache.nuxt',
+        [SEMANTIC_ATTRIBUTE_CACHE_HIT]: true,
+        'db.operation.name': 'getItem',
+        'db.collection.name': expect.stringMatching(/^(cache)?$/),
+      });
+    }
+
+    // Test setItem spans for cachedFunction - when cache miss occurs, value is set
+    const setItemSpans = findSpansByOp('cache.set_item');
+    expect(setItemSpans.length).toBeGreaterThan(0);
+
+    const cacheSetSpan = setItemSpans.find(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('user:123'),
+    );
+    if (cacheSetSpan) {
+      expect(cacheSetSpan.data).toMatchObject({
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'cache.set_item',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.cache.nuxt',
+        'db.operation.name': 'setItem',
+        'db.collection.name': expect.stringMatching(/^(cache)?$/),
+      });
+    }
+
+    // Test that we have spans for different cached functions
+    const dataKeySpans = getItemSpans.filter(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('data:test-key'),
+    );
+    expect(dataKeySpans.length).toBeGreaterThan(0);
+
+    // Test that we have spans for cachedEventHandler
+    const cachedHandlerSpans = getItemSpans.filter(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('cachedHandler'),
+    );
+    expect(cachedHandlerSpans.length).toBeGreaterThan(0);
+
+    // Verify all cache spans have OK status
+    allCacheSpans?.forEach(span => {
+      expect(span.status).toBe('ok');
+    });
+
+    // Verify cache spans are properly nested under the transaction
+    allCacheSpans?.forEach(span => {
+      expect(span.parent_span_id).toBeDefined();
+    });
+  });
+
+  test('correctly tracks cache hits and misses for cachedFunction', async ({ request }) => {
+    // Use a unique key for this test to ensure fresh cache state
+    const uniqueUser = `test-${Date.now()}`;
+    const uniqueData = `data-${Date.now()}`;
+
+    const transactionPromise = waitForTransaction('nuxt-3', transactionEvent => {
+      return transactionEvent.transaction?.includes('GET /api/cache-test') ?? false;
+    });
+
+    await request.get(`/api/cache-test?user=${uniqueUser}&data=${uniqueData}`);
+    const transaction1 = await transactionPromise;
+
+    // Get all cache-related spans
+    const allCacheSpans = transaction1.spans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] === 'auto.cache.nuxt',
+    );
+
+    // We should have cache operations
+    expect(allCacheSpans?.length).toBeGreaterThan(0);
+
+    // Get all getItem operations
+    const allGetItemSpans = allCacheSpans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] === 'cache.get_item',
+    );
+
+    // Get all setItem operations
+    const allSetItemSpans = allCacheSpans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] === 'cache.set_item',
+    );
+
+    // We should have both get and set operations
+    expect(allGetItemSpans?.length).toBeGreaterThan(0);
+    expect(allSetItemSpans?.length).toBeGreaterThan(0);
+
+    // Check for cache misses (cache.hit = false)
+    const cacheMissSpans = allGetItemSpans?.filter(span => span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT] === false);
+
+    // Check for cache hits (cache.hit = true)
+    const cacheHitSpans = allGetItemSpans?.filter(span => span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT] === true);
+
+    // We should have at least one cache miss (first calls to getCachedUser and getCachedData)
+    expect(cacheMissSpans?.length).toBeGreaterThanOrEqual(1);
+
+    // We should have at least one cache hit (second calls to getCachedUser and getCachedData)
+    expect(cacheHitSpans?.length).toBeGreaterThanOrEqual(1);
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/cache-test.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/cache-test.ts
new file mode 100644
index 000000000000..0fb4ace46bd5
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/cache-test.ts
@@ -0,0 +1,84 @@
+import { cachedFunction, defineCachedEventHandler, defineEventHandler, getQuery } from '#imports';
+
+// Test cachedFunction
+const getCachedUser = cachedFunction(
+  async (userId: string) => {
+    return {
+      id: userId,
+      name: `User ${userId}`,
+      email: `user${userId}@example.com`,
+      timestamp: Date.now(),
+    };
+  },
+  {
+    maxAge: 60,
+    name: 'getCachedUser',
+    getKey: (userId: string) => `user:${userId}`,
+  },
+);
+
+// Test cachedFunction with different options
+const getCachedData = cachedFunction(
+  async (key: string) => {
+    return {
+      key,
+      value: `cached-value-${key}`,
+      timestamp: Date.now(),
+    };
+  },
+  {
+    maxAge: 120,
+    name: 'getCachedData',
+    getKey: (key: string) => `data:${key}`,
+  },
+);
+
+// Test defineCachedEventHandler
+const cachedHandler = defineCachedEventHandler(
+  async event => {
+    return {
+      message: 'This response is cached',
+      timestamp: Date.now(),
+      path: event.path,
+    };
+  },
+  {
+    maxAge: 60,
+    name: 'cachedHandler',
+  },
+);
+
+export default defineEventHandler(async event => {
+  const results: Record<string, unknown> = {};
+  const testKey = String(getQuery(event).user ?? '123');
+  const dataKey = String(getQuery(event).data ?? 'test-key');
+
+  // Test cachedFunction - first call (cache miss)
+  const user1 = await getCachedUser(testKey);
+  results.cachedUser1 = user1;
+
+  // Test cachedFunction - second call (cache hit)
+  const user2 = await getCachedUser(testKey);
+  results.cachedUser2 = user2;
+
+  // Test cachedFunction with different key (cache miss)
+  const user3 = await getCachedUser(`${testKey}456`);
+  results.cachedUser3 = user3;
+
+  // Test another cachedFunction
+  const data1 = await getCachedData(dataKey);
+  results.cachedData1 = data1;
+
+  // Test cachedFunction - cache hit
+  const data2 = await getCachedData(dataKey);
+  results.cachedData2 = data2;
+
+  // Test cachedEventHandler by calling it
+  const cachedResponse = await cachedHandler(event);
+  results.cachedResponse = cachedResponse;
+
+  return {
+    success: true,
+    results,
+  };
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/tests/cache.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/tests/cache.test.ts
new file mode 100644
index 000000000000..1295de002145
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/tests/cache.test.ts
@@ -0,0 +1,161 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/nuxt';
+
+test.describe('Cache Instrumentation', () => {
+  const SEMANTIC_ATTRIBUTE_CACHE_KEY = 'cache.key';
+  const SEMANTIC_ATTRIBUTE_CACHE_HIT = 'cache.hit';
+
+  test('instruments cachedFunction and cachedEventHandler calls and creates spans with correct attributes', async ({
+    request,
+  }) => {
+    const transactionPromise = waitForTransaction('nuxt-4', transactionEvent => {
+      return transactionEvent.transaction?.includes('GET /api/cache-test') ?? false;
+    });
+
+    const response = await request.get('/api/cache-test');
+    expect(response.status()).toBe(200);
+
+    const transaction = await transactionPromise;
+
+    // Helper to find spans by operation
+    const findSpansByOp = (op: string) => {
+      return transaction.spans?.filter(span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] === op) || [];
+    };
+
+    // Test that we have cache operations from cachedFunction and cachedEventHandler
+    const allCacheSpans = transaction.spans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] === 'auto.cache.nuxt',
+    );
+    expect(allCacheSpans?.length).toBeGreaterThan(0);
+
+    // Test getItem spans for cachedFunction - should have both cache miss and cache hit
+    const getItemSpans = findSpansByOp('cache.get_item');
+    expect(getItemSpans.length).toBeGreaterThan(0);
+
+    // Find cache miss (first call to getCachedUser('123'))
+    const cacheMissSpan = getItemSpans.find(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('user:123') &&
+        !span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT],
+    );
+    if (cacheMissSpan) {
+      expect(cacheMissSpan.data).toMatchObject({
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'cache.get_item',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.cache.nuxt',
+        [SEMANTIC_ATTRIBUTE_CACHE_HIT]: false,
+        'db.operation.name': 'getItem',
+        'db.collection.name': expect.stringMatching(/^(cache)?$/),
+      });
+    }
+
+    // Find cache hit (second call to getCachedUser('123'))
+    const cacheHitSpan = getItemSpans.find(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('user:123') &&
+        span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT],
+    );
+    if (cacheHitSpan) {
+      expect(cacheHitSpan.data).toMatchObject({
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'cache.get_item',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.cache.nuxt',
+        [SEMANTIC_ATTRIBUTE_CACHE_HIT]: true,
+        'db.operation.name': 'getItem',
+        'db.collection.name': expect.stringMatching(/^(cache)?$/),
+      });
+    }
+
+    // Test setItem spans for cachedFunction - when cache miss occurs, value is set
+    const setItemSpans = findSpansByOp('cache.set_item');
+    expect(setItemSpans.length).toBeGreaterThan(0);
+
+    const cacheSetSpan = setItemSpans.find(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('user:123'),
+    );
+    if (cacheSetSpan) {
+      expect(cacheSetSpan.data).toMatchObject({
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'cache.set_item',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.cache.nuxt',
+        'db.operation.name': 'setItem',
+        'db.collection.name': expect.stringMatching(/^(cache)?$/),
+      });
+    }
+
+    // Test that we have spans for different cached functions
+    const dataKeySpans = getItemSpans.filter(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('data:test-key'),
+    );
+    expect(dataKeySpans.length).toBeGreaterThan(0);
+
+    // Test that we have spans for cachedEventHandler
+    const cachedHandlerSpans = getItemSpans.filter(
+      span =>
+        typeof span.data?.[SEMANTIC_ATTRIBUTE_CACHE_KEY] === 'string' &&
+        span.data[SEMANTIC_ATTRIBUTE_CACHE_KEY].includes('cachedHandler'),
+    );
+    expect(cachedHandlerSpans.length).toBeGreaterThan(0);
+
+    // Verify all cache spans have OK status
+    allCacheSpans?.forEach(span => {
+      expect(span.status).toBe('ok');
+    });
+
+    // Verify cache spans are properly nested under the transaction
+    allCacheSpans?.forEach(span => {
+      expect(span.parent_span_id).toBeDefined();
+    });
+  });
+
+  test('correctly tracks cache hits and misses for cachedFunction', async ({ request }) => {
+    // Use a unique key for this test to ensure fresh cache state
+    const uniqueUser = `test-${Date.now()}`;
+    const uniqueData = `data-${Date.now()}`;
+
+    const transactionPromise = waitForTransaction('nuxt-4', transactionEvent => {
+      return transactionEvent.transaction?.includes('GET /api/cache-test') ?? false;
+    });
+
+    await request.get(`/api/cache-test?user=${uniqueUser}&data=${uniqueData}`);
+    const transaction1 = await transactionPromise;
+
+    // Get all cache-related spans
+    const allCacheSpans = transaction1.spans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] === 'auto.cache.nuxt',
+    );
+
+    // We should have cache operations
+    expect(allCacheSpans?.length).toBeGreaterThan(0);
+
+    // Get all getItem operations
+    const allGetItemSpans = allCacheSpans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] === 'cache.get_item',
+    );
+
+    // Get all setItem operations
+    const allSetItemSpans = allCacheSpans?.filter(
+      span => span.data?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] === 'cache.set_item',
+    );
+
+    // We should have both get and set operations
+    expect(allGetItemSpans?.length).toBeGreaterThan(0);
+    expect(allSetItemSpans?.length).toBeGreaterThan(0);
+
+    // Check for cache misses (cache.hit = false)
+    const cacheMissSpans = allGetItemSpans?.filter(span => span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT] === false);
+
+    // Check for cache hits (cache.hit = true)
+    const cacheHitSpans = allGetItemSpans?.filter(span => span.data?.[SEMANTIC_ATTRIBUTE_CACHE_HIT] === true);
+
+    // We should have at least one cache miss (first calls to getCachedUser and getCachedData)
+    expect(cacheMissSpans?.length).toBeGreaterThanOrEqual(1);
+
+    // We should have at least one cache hit (second calls to getCachedUser and getCachedData)
+    expect(cacheHitSpans?.length).toBeGreaterThanOrEqual(1);
+  });
+});
diff --git a/packages/nuxt/src/runtime/plugins/storage.server.ts b/packages/nuxt/src/runtime/plugins/storage.server.ts
index 05932394384d..710424d6995e 100644
--- a/packages/nuxt/src/runtime/plugins/storage.server.ts
+++ b/packages/nuxt/src/runtime/plugins/storage.server.ts
@@ -14,6 +14,7 @@ import {
 } from '@sentry/core';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { defineNitroPlugin, useStorage } from 'nitropack/runtime';
+import type { CacheEntry, ResponseCacheEntry } from 'nitropack/types';
 import type { Driver, Storage } from 'unstorage';
 // @ts-expect-error - This is a virtual module
 import { userStorageMounts } from '#sentry/storage-config.mjs';
@@ -42,6 +43,14 @@ export default defineNitroPlugin(async _nitroApp => {
 
   debug.log('[storage] Starting to instrument storage drivers...');
 
+  // Adds cache mount to handle Nitro's cache calls
+  // Nitro uses the mount to cache functions and event handlers
+  // https://nitro.build/guide/cache
+  userMounts.add('cache:');
+  // In production, unless the user configured a specific cache driver, Nitro will use the memory driver at root mount.
+  // Either way, we need to instrument the root mount as well.
+  userMounts.add('');
+
   // Get all mounted storage drivers
   const mounts = storage.getMounts();
   for (const mount of mounts) {
@@ -123,7 +132,7 @@ function createMethodWrapper(
           span.setStatus({ code: SPAN_STATUS_OK });
 
           if (CACHE_HIT_METHODS.has(methodName)) {
-            span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, !isEmptyValue(result));
+            span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, isCacheHit(args[0], result));
           }
 
           return result;
@@ -177,7 +186,7 @@ function normalizeMethodName(methodName: string): string {
 /**
  * Checks if the value is empty, used for cache hit detection.
  */
-function isEmptyValue(value: unknown): boolean {
+function isEmptyValue(value: unknown): value is null | undefined {
   return value === null || value === undefined;
 }
 
@@ -234,3 +243,72 @@ function normalizeKey(key: unknown, prefix: string): string {
 
   return `${prefix}${isEmptyValue(key) ? '' : String(key)}`;
 }
+
+const CACHED_FN_HANDLERS_RE = /^nitro:(functions|handlers):/i;
+
+/**
+ * Since Nitro's cache may not utilize the driver's TTL, it is possible that the value is present in the cache but won't be used by Nitro.
+ * The maxAge and expires values are serialized by Nitro in the cache entry. This means the value presence does not necessarily mean a cache hit.
+ * So in order to properly report cache hits for `defineCachedFunction` and `defineCachedEventHandler` we need to check the cached value ourselves.
+ * First we check if the key matches the `defineCachedFunction` or `defineCachedEventHandler` key patterns, and if so we check the cached value.
+ */
+function isCacheHit(key: string, value: unknown): boolean {
+  try {
+    const isEmpty = isEmptyValue(value);
+    // Empty value means no cache hit either way
+    // Or if key doesn't match the cached function or handler patterns, we can return the empty value check
+    if (isEmpty || !CACHED_FN_HANDLERS_RE.test(key)) {
+      return !isEmpty;
+    }
+
+    return validateCacheEntry(key, JSON.parse(String(value)) as CacheEntry);
+  } catch (error) {
+    // this is a best effort, so we return false if we can't validate the cache entry
+    return false;
+  }
+}
+
+/**
+ * Validates the cache entry.
+ */
+function validateCacheEntry(
+  key: string,
+  entry: CacheEntry | CacheEntry<ResponseCacheEntry & { status: number }>,
+): boolean {
+  if (isEmptyValue(entry.value)) {
+    return false;
+  }
+
+  // Date.now is used by Nitro internally, so safe to use here.
+  // https://github.com/nitrojs/nitro/blob/5508f71b77730e967fb131de817725f5aa7c4862/src/runtime/internal/cache.ts#L78
+  if (Date.now() > (entry.expires || 0)) {
+    return false;
+  }
+
+  /**
+   * Pulled from Nitro's cache entry validation
+   * https://github.com/nitrojs/nitro/blob/5508f71b77730e967fb131de817725f5aa7c4862/src/runtime/internal/cache.ts#L223-L241
+   */
+  if (isResponseCacheEntry(key, entry)) {
+    if (entry.value.status >= 400) {
+      return false;
+    }
+
+    if (entry.value.body === undefined) {
+      return false;
+    }
+
+    if (entry.value.headers.etag === 'undefined' || entry.value.headers['last-modified'] === 'undefined') {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Checks if the cache entry is a response cache entry.
+ */
+function isResponseCacheEntry(key: string, _: CacheEntry): _ is CacheEntry<ResponseCacheEntry & { status: number }> {
+  return key.startsWith('nitro:handlers:');
+}
diff --git a/packages/nuxt/src/server/sdk.ts b/packages/nuxt/src/server/sdk.ts
index dcd2f46caec9..edbd26b3d707 100644
--- a/packages/nuxt/src/server/sdk.ts
+++ b/packages/nuxt/src/server/sdk.ts
@@ -1,5 +1,5 @@
 import * as path from 'node:path';
-import type { Client, EventProcessor, Integration } from '@sentry/core';
+import type { Client, Event, EventProcessor, Integration } from '@sentry/core';
 import { applySdkMetadata, debug, flush, getGlobalScope, vercelWaitUntil } from '@sentry/core';
 import {
   type NodeOptions,
@@ -40,7 +40,7 @@ export function init(options: SentryNuxtServerOptions): Client | undefined {
 export function lowQualityTransactionsFilter(options: SentryNuxtServerOptions): EventProcessor {
   return Object.assign(
     (event => {
-      if (event.type !== 'transaction' || !event.transaction) {
+      if (event.type !== 'transaction' || !event.transaction || isCacheEvent(event)) {
         return event;
       }
 
@@ -111,3 +111,10 @@ async function flushSafelyWithTimeout(): Promise<void> {
     DEBUG_BUILD && debug.log('Error while flushing events:\n', e);
   }
 }
+
+/**
+ * Checks if the event is a cache event.
+ */
+function isCacheEvent(e: Event): boolean {
+  return e.contexts?.trace?.origin === 'auto.cache.nuxt';
+}