diff --git a/docs/router/framework/react/api/router.md b/docs/router/framework/react/api/router.md
index ad3a58f8512..e760a073788 100644
--- a/docs/router/framework/react/api/router.md
+++ b/docs/router/framework/react/api/router.md
@@ -32,6 +32,7 @@ title: Router API
   - [`<Link>`](../router/linkComponent.md)
   - [`<MatchRoute>`](../router/matchRouteComponent.md)
   - [`<Navigate>`](../router/navigateComponent.md)
+  - [`<NotFoundComponent>`](../router/notFoundComponentComponent.md)
   - [`<Outlet>`](../router/outletComponent.md)
 - Hooks
   - [`useAwaited`](../router/useAwaitedHook.md)
diff --git a/docs/router/framework/react/api/router/notFoundComponentComponent.md b/docs/router/framework/react/api/router/notFoundComponentComponent.md
new file mode 100644
index 00000000000..63b9f93ae05
--- /dev/null
+++ b/docs/router/framework/react/api/router/notFoundComponentComponent.md
@@ -0,0 +1,36 @@
+---
+id: notFoundComponentComponent
+title: NotFoundComponent component
+---
+
+The `NotFoundComponent` component is a component that renders when a not-found error occurs in a route.
+
+## NotFoundComponent props
+
+The `NotFoundComponent` component accepts the following props:
+
+### `props.data` prop
+
+- Type: `unknown`
+- Optional
+- Custom data that is passed to the `notFoundComponent` when the not-found error is handled
+- This data comes from the `data` property of the `NotFoundError` object
+
+### `props.isNotFound` prop
+
+- Type: `boolean`
+- Required
+- A boolean value indicating whether the current state is a not-found error state
+- This value is always `true`
+
+### `props.routeId` prop
+
+- Type: `RouteIds<RegisteredRouter['routeTree']>`
+- Required
+- The ID of the route that is attempting to handle the not-found error
+- Must be one of the valid route IDs from the router's route tree
+
+## NotFoundComponent returns
+
+- Returns appropriate UI for not-found error situations
+- Typically includes a "page not found" message along with links to go home or navigate to previous pages
diff --git a/examples/react/kitchen-sink/src/main.tsx b/examples/react/kitchen-sink/src/main.tsx
index e22afc9fc49..ce7687c6669 100644
--- a/examples/react/kitchen-sink/src/main.tsx
+++ b/examples/react/kitchen-sink/src/main.tsx
@@ -11,6 +11,7 @@ import {
   createRoute,
   createRouter,
   lazyRouteComponent,
+  notFound,
   redirect,
   retainSearchParams,
   useNavigate,
@@ -29,6 +30,7 @@ import {
   postInvoice,
 } from './mockTodos'
 import { useMutation } from './useMutation'
+import type { NotFoundRouteProps } from '@tanstack/react-router'
 import type { Invoice } from './mockTodos'
 import './styles.css'
 
@@ -36,6 +38,39 @@ import './styles.css'
 
 type UsersViewSortBy = 'name' | 'id' | 'email'
 
+type MissingUserData = {
+  userId: number
+}
+
+function isMissingUserData(data: unknown): data is MissingUserData {
+  return (
+    typeof data === 'object' &&
+    data !== null &&
+    typeof (data as { userId?: unknown }).userId === 'number'
+  )
+}
+
+function UsersNotFoundComponent({ data, routeId }: NotFoundRouteProps) {
+  const userId = isMissingUserData(data) ? data.userId : undefined
+
+  return (
+    <div className="p-4 space-y-2">
+      <h4 className="text-lg font-bold">User not found</h4>
+      <p>
+        {typeof userId === 'number'
+          ? `We couldn't find a user with ID ${userId}.`
+          : "We couldn't find the requested user."}
+      </p>
+      <p className="text-xs text-gray-500">
+        Rendered by the "{routeId}" route.
+      </p>
+      <p className="text-sm text-gray-500">
+        Pick another user from the list on the left to continue.
+      </p>
+    </div>
+  )
+}
+
 const rootRoute = createRootRouteWithContext<{
   auth: Auth
 }>()({
@@ -449,6 +484,7 @@ const usersLayoutRoute = createRoute({
     sortBy: usersView?.sortBy ?? 'name',
   }),
   loader: ({ deps }) => fetchUsers(deps),
+  notFoundComponent: UsersNotFoundComponent,
   component: UsersLayoutComponent,
 })
 
@@ -563,6 +599,18 @@ function UsersLayoutComponent() {
             </div>
           )
         })}
+        <div className="px-3 py-2 text-xs text-gray-500 bg-gray-100 dark:bg-gray-800/60">
+          Need to see how not-found errors look?{' '}
+          <Link
+            to={userRoute.to}
+            search={{
+              userId: 404,
+            }}
+            className="text-blue-700"
+          >
+            Try loading user 404
+          </Link>
+        </div>
       </div>
       <div className="flex-initial border-l">
         <Outlet />
@@ -610,7 +658,19 @@ const userRoute = createRoute({
   loaderDeps: ({ search: { userId } }) => ({
     userId,
   }),
-  loader: ({ deps: { userId } }) => fetchUserById(userId),
+  loader: async ({ deps: { userId } }) => {
+    const user = await fetchUserById(userId)
+
+    if (!user) {
+      throw notFound({
+        data: {
+          userId,
+        },
+      })
+    }
+
+    return user
+  },
   component: UserComponent,
 })
 
diff --git a/packages/react-router/src/renderRouteNotFound.tsx b/packages/react-router/src/renderRouteNotFound.tsx
index 26cf5b09288..86f31dfc220 100644
--- a/packages/react-router/src/renderRouteNotFound.tsx
+++ b/packages/react-router/src/renderRouteNotFound.tsx
@@ -10,7 +10,7 @@ export function renderRouteNotFound(
 ) {
   if (!route.options.notFoundComponent) {
     if (router.options.defaultNotFoundComponent) {
-      return <router.options.defaultNotFoundComponent data={data} />
+      return <router.options.defaultNotFoundComponent {...data} />
     }
 
     if (process.env.NODE_ENV === 'development') {
@@ -23,5 +23,5 @@ export function renderRouteNotFound(
     return <DefaultGlobalNotFound />
   }
 
-  return <route.options.notFoundComponent data={data} />
+  return <route.options.notFoundComponent {...data} />
 }
diff --git a/packages/react-router/tests/not-found.test.tsx b/packages/react-router/tests/not-found.test.tsx
index 9bcbdbd79c8..ce8bdf1207f 100644
--- a/packages/react-router/tests/not-found.test.tsx
+++ b/packages/react-router/tests/not-found.test.tsx
@@ -9,8 +9,9 @@ import {
   createRootRoute,
   createRoute,
   createRouter,
+  notFound,
 } from '../src'
-import type { RouterHistory } from '../src'
+import type { NotFoundRouteProps, RouterHistory } from '../src'
 
 let history: RouterHistory
 
@@ -123,3 +124,124 @@ test.each([
     expect(notFoundComponent).toBeInTheDocument()
   },
 )
+
+test('defaultNotFoundComponent and notFoundComponent receives data props via spread operator', async () => {
+  const isCustomData = (data: unknown): data is typeof customData => {
+    return 'message' in (data as typeof customData)
+  }
+
+  const customData = {
+    message: 'Custom not found message',
+  }
+
+  const DefaultNotFoundComponentWithProps = (props: NotFoundRouteProps) => (
+    <div data-testid="default-not-found-with-props">
+      <span data-testid="message">
+        {isCustomData(props.data) && <span>{props.data.message}</span>}
+      </span>
+    </div>
+  )
+
+  const rootRoute = createRootRoute({
+    component: () => (
+      <div data-testid="root-component">
+        <h1>Root Component</h1>
+        <div>
+          <Link
+            data-testid="default-not-found-route-link"
+            to="/default-not-found-route"
+          >
+            link to default not found route
+          </Link>
+          <Link data-testid="not-found-route-link" to="/not-found-route">
+            link to not found route
+          </Link>
+        </div>
+        <Outlet />
+      </div>
+    ),
+  })
+
+  const indexRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    component: () => (
+      <div data-testid="index-component">
+        <h2>Index Page</h2>
+      </div>
+    ),
+  })
+
+  const defaultNotFoundRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/default-not-found-route',
+    loader: () => {
+      throw notFound({ data: customData })
+    },
+    component: () => (
+      <div data-testid="default-not-found-route-component">
+        Should not render
+      </div>
+    ),
+  })
+
+  const notFoundRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/not-found-route',
+    loader: () => {
+      throw notFound({ data: customData })
+    },
+    component: () => (
+      <div data-testid="not-found-route-component">Should not render</div>
+    ),
+    notFoundComponent: (props) => (
+      <div data-testid="not-found-with-props">
+        <span data-testid="message">
+          {isCustomData(props.data) && <span>{props.data.message}</span>}
+        </span>
+      </div>
+    ),
+  })
+
+  const router = createRouter({
+    routeTree: rootRoute.addChildren([
+      indexRoute,
+      defaultNotFoundRoute,
+      notFoundRoute,
+    ]),
+    history,
+    defaultNotFoundComponent: DefaultNotFoundComponentWithProps,
+  })
+
+  render(<RouterProvider router={router} />)
+  await router.load()
+  await screen.findByTestId('root-component')
+
+  const defaultNotFoundRouteLink = screen.getByTestId(
+    'default-not-found-route-link',
+  )
+  defaultNotFoundRouteLink.click()
+
+  const defaultNotFoundComponent = await screen.findByTestId(
+    'default-not-found-with-props',
+    {},
+    { timeout: 1000 },
+  )
+  expect(defaultNotFoundComponent).toBeInTheDocument()
+
+  const defaultNotFoundComponentMessage = await screen.findByTestId('message')
+  expect(defaultNotFoundComponentMessage).toHaveTextContent(customData.message)
+
+  const notFoundRouteLink = screen.getByTestId('not-found-route-link')
+  notFoundRouteLink.click()
+
+  const notFoundComponent = await screen.findByTestId(
+    'not-found-with-props',
+    {},
+    { timeout: 1000 },
+  )
+  expect(notFoundComponent).toBeInTheDocument()
+
+  const errorMessageComponent = await screen.findByTestId('message')
+  expect(errorMessageComponent).toHaveTextContent(customData.message)
+})
diff --git a/packages/router-core/src/route.ts b/packages/router-core/src/route.ts
index 4b4e4404cc3..53d726ef05a 100644
--- a/packages/router-core/src/route.ts
+++ b/packages/router-core/src/route.ts
@@ -14,7 +14,7 @@ import type {
   RouteMatch,
 } from './Matches'
 import type { RootRouteId } from './root'
-import type { ParseRoute, RouteById, RoutePaths } from './routeInfo'
+import type { ParseRoute, RouteById, RouteIds, RoutePaths } from './routeInfo'
 import type { AnyRouter, Register, RegisteredRouter, SSROption } from './router'
 import type { BuildLocationFn, NavigateFn } from './RouterProvider'
 import type {
@@ -1488,9 +1488,11 @@ export type ErrorComponentProps<TError = Error> = {
   info?: { componentStack: string }
   reset: () => void
 }
+
 export type NotFoundRouteProps = {
-  // TODO: Make sure this is `| null | undefined` (this is for global not-founds)
-  data: unknown
+  data?: unknown
+  isNotFound: boolean
+  routeId: RouteIds<RegisteredRouter['routeTree']>
 }
 
 export class BaseRoute<
diff --git a/packages/router-core/tests/load.test-d.ts b/packages/router-core/tests/load.test-d.ts
new file mode 100644
index 00000000000..d356698cf47
--- /dev/null
+++ b/packages/router-core/tests/load.test-d.ts
@@ -0,0 +1,138 @@
+import { describe, expectTypeOf, test } from 'vitest'
+import type { NotFoundRouteProps, RegisteredRouter, RouteIds } from '../src'
+
+describe('NotFoundRouteProps', () => {
+  test('should have correct basic property types', () => {
+    expectTypeOf<NotFoundRouteProps['data']>().toEqualTypeOf<
+      unknown | undefined
+    >()
+    expectTypeOf<NotFoundRouteProps['isNotFound']>().toEqualTypeOf<boolean>()
+    expectTypeOf<NotFoundRouteProps['routeId']>().toEqualTypeOf<
+      RouteIds<RegisteredRouter['routeTree']>
+    >()
+  })
+
+  test('should have data as optional property', () => {
+    expectTypeOf<NotFoundRouteProps>().toMatchTypeOf<{
+      data?: unknown
+      isNotFound: boolean
+      routeId: RouteIds<RegisteredRouter['routeTree']>
+    }>()
+  })
+
+  test('should have isNotFound as required property', () => {
+    expectTypeOf<Pick<NotFoundRouteProps, 'isNotFound'>>().toEqualTypeOf<{
+      isNotFound: boolean
+    }>()
+  })
+
+  test('should have routeId as required property', () => {
+    expectTypeOf<Pick<NotFoundRouteProps, 'routeId'>>().toEqualTypeOf<{
+      routeId: RouteIds<RegisteredRouter['routeTree']>
+    }>()
+  })
+
+  test('should be assignable with minimal required properties', () => {
+    const props: NotFoundRouteProps = {
+      isNotFound: true,
+      routeId: '/' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+    expectTypeOf(props).toMatchTypeOf<NotFoundRouteProps>()
+  })
+
+  test('should be assignable with all properties', () => {
+    const props: NotFoundRouteProps = {
+      data: { message: 'Not found' },
+      isNotFound: true,
+      routeId: '/' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+    expectTypeOf(props).toMatchTypeOf<NotFoundRouteProps>()
+  })
+
+  test('should accept any data type', () => {
+    const propsWithString: NotFoundRouteProps = {
+      data: 'string data',
+      isNotFound: true,
+      routeId: '/' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+    expectTypeOf(propsWithString).toMatchTypeOf<NotFoundRouteProps>()
+
+    const propsWithObject: NotFoundRouteProps = {
+      data: { userId: 123, message: 'User not found' },
+      isNotFound: true,
+      routeId: '/users' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+    expectTypeOf(propsWithObject).toMatchTypeOf<NotFoundRouteProps>()
+
+    const propsWithArray: NotFoundRouteProps = {
+      data: [1, 2, 3],
+      isNotFound: true,
+      routeId: '/' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+    expectTypeOf(propsWithArray).toMatchTypeOf<NotFoundRouteProps>()
+  })
+
+  test('should accept undefined data', () => {
+    const props: NotFoundRouteProps = {
+      data: undefined,
+      isNotFound: true,
+      routeId: '/' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+    expectTypeOf(props).toMatchTypeOf<NotFoundRouteProps>()
+  })
+
+  test('notFoundComponent should accept NotFoundRouteProps', () => {
+    type NotFoundComponent = (props: NotFoundRouteProps) => any
+
+    const component: NotFoundComponent = (props) => {
+      expectTypeOf(props.data).toEqualTypeOf<unknown | undefined>()
+      expectTypeOf(props.isNotFound).toEqualTypeOf<boolean>()
+      expectTypeOf(props.routeId).toEqualTypeOf<
+        RouteIds<RegisteredRouter['routeTree']>
+      >()
+      return null
+    }
+
+    expectTypeOf(component).toMatchTypeOf<NotFoundComponent>()
+  })
+
+  test('defaultNotFoundComponent should accept NotFoundRouteProps', () => {
+    type DefaultNotFoundComponent = (props: NotFoundRouteProps) => any
+
+    const component: DefaultNotFoundComponent = (props) => {
+      expectTypeOf(props).toMatchTypeOf<NotFoundRouteProps>()
+      return null
+    }
+
+    expectTypeOf(component).toMatchTypeOf<DefaultNotFoundComponent>()
+  })
+
+  test('should be spreadable as component props', () => {
+    const notFoundData = {
+      data: { message: 'Custom error' },
+      isNotFound: true as const,
+      routeId: '/' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+
+    type SpreadProps = typeof notFoundData
+    expectTypeOf<SpreadProps>().toMatchTypeOf<NotFoundRouteProps>()
+
+    const component = (props: NotFoundRouteProps) => {
+      expectTypeOf(props).toMatchTypeOf<NotFoundRouteProps>()
+      return null
+    }
+
+    expectTypeOf(component).parameter(0).toMatchTypeOf<NotFoundRouteProps>()
+  })
+
+  test('should maintain type safety with spread', () => {
+    const data: NotFoundRouteProps = {
+      data: { userId: 123 },
+      isNotFound: true,
+      routeId: '/users' as RouteIds<RegisteredRouter['routeTree']>,
+    }
+
+    const spreadData = { ...data }
+    expectTypeOf(spreadData).toMatchTypeOf<NotFoundRouteProps>()
+  })
+})
diff --git a/packages/solid-router/src/Match.tsx b/packages/solid-router/src/Match.tsx
index ae62c408ecf..0e6afc46715 100644
--- a/packages/solid-router/src/Match.tsx
+++ b/packages/solid-router/src/Match.tsx
@@ -308,7 +308,14 @@ export const MatchInner = (props: { matchId: string }): any => {
         {(_) => {
           invariant(isNotFound(match().error), 'Expected a notFound error')
 
-          return renderRouteNotFound(router, route(), match().error)
+          // Use Show with keyed to ensure re-render when routeId changes
+          return (
+            <Solid.Show when={matchState()!.routeId} keyed>
+              {(_routeId) =>
+                renderRouteNotFound(router, route(), match().error)
+              }
+            </Solid.Show>
+          )
         }}
       </Solid.Match>
       <Solid.Match when={match().status === 'redirected'}>
diff --git a/packages/solid-router/src/renderRouteNotFound.tsx b/packages/solid-router/src/renderRouteNotFound.tsx
index b7421d863c0..4603e6c0a31 100644
--- a/packages/solid-router/src/renderRouteNotFound.tsx
+++ b/packages/solid-router/src/renderRouteNotFound.tsx
@@ -9,7 +9,7 @@ export function renderRouteNotFound(
 ) {
   if (!route.options.notFoundComponent) {
     if (router.options.defaultNotFoundComponent) {
-      return <router.options.defaultNotFoundComponent data={data} />
+      return <router.options.defaultNotFoundComponent {...data} />
     }
 
     if (process.env.NODE_ENV === 'development') {
@@ -22,5 +22,5 @@ export function renderRouteNotFound(
     return <DefaultGlobalNotFound />
   }
 
-  return <route.options.notFoundComponent data={data} />
+  return <route.options.notFoundComponent {...data} />
 }
diff --git a/packages/solid-router/tests/not-found.test.tsx b/packages/solid-router/tests/not-found.test.tsx
index 355235e3f2a..38a3e639444 100644
--- a/packages/solid-router/tests/not-found.test.tsx
+++ b/packages/solid-router/tests/not-found.test.tsx
@@ -9,8 +9,9 @@ import {
   createRootRoute,
   createRoute,
   createRouter,
+  notFound,
 } from '../src'
-import type { RouterHistory } from '../src'
+import type { NotFoundRouteProps, RouterHistory } from '../src'
 
 let history: RouterHistory
 
@@ -123,3 +124,124 @@ test.each([
     expect(notFoundComponent).toBeInTheDocument()
   },
 )
+
+test('defaultNotFoundComponent and notFoundComponent receives data props via spread operator', async () => {
+  const isCustomData = (data: unknown): data is typeof customData => {
+    return 'message' in (data as typeof customData)
+  }
+
+  const customData = {
+    message: 'Custom not found message',
+  }
+
+  const DefaultNotFoundComponentWithProps = (props: NotFoundRouteProps) => (
+    <div data-testid="default-not-found-with-props">
+      <span data-testid="message">
+        {isCustomData(props.data) && <span>{props.data.message}</span>}
+      </span>
+    </div>
+  )
+
+  const rootRoute = createRootRoute({
+    component: () => (
+      <div data-testid="root-component">
+        <h1>Root Component</h1>
+        <div>
+          <Link
+            data-testid="default-not-found-route-link"
+            to="/default-not-found-route"
+          >
+            link to default not found route
+          </Link>
+          <Link data-testid="not-found-route-link" to="/not-found-route">
+            link to not found route
+          </Link>
+        </div>
+        <Outlet />
+      </div>
+    ),
+  })
+
+  const indexRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    component: () => (
+      <div data-testid="index-component">
+        <h2>Index Page</h2>
+      </div>
+    ),
+  })
+
+  const defaultNotFoundRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/default-not-found-route',
+    loader: () => {
+      throw notFound({ data: customData })
+    },
+    component: () => (
+      <div data-testid="default-not-found-route-component">
+        Should not render
+      </div>
+    ),
+  })
+
+  const notFoundRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/not-found-route',
+    loader: () => {
+      throw notFound({ data: customData })
+    },
+    component: () => (
+      <div data-testid="not-found-route-component">Should not render</div>
+    ),
+    notFoundComponent: (props) => (
+      <div data-testid="not-found-with-props">
+        <span data-testid="message">
+          {isCustomData(props.data) && <span>{props.data.message}</span>}
+        </span>
+      </div>
+    ),
+  })
+
+  const router = createRouter({
+    routeTree: rootRoute.addChildren([
+      indexRoute,
+      defaultNotFoundRoute,
+      notFoundRoute,
+    ]),
+    history,
+    defaultNotFoundComponent: DefaultNotFoundComponentWithProps,
+  })
+
+  render(() => <RouterProvider router={router} />)
+  await router.load()
+  await screen.findByTestId('root-component')
+
+  const defaultNotFoundRouteLink = screen.getByTestId(
+    'default-not-found-route-link',
+  )
+  defaultNotFoundRouteLink.click()
+
+  const defaultNotFoundComponent = await screen.findByTestId(
+    'default-not-found-with-props',
+    {},
+    { timeout: 1000 },
+  )
+  expect(defaultNotFoundComponent).toBeInTheDocument()
+
+  const defaultNotFoundComponentMessage = await screen.findByTestId('message')
+  expect(defaultNotFoundComponentMessage).toHaveTextContent(customData.message)
+
+  const notFoundRouteLink = screen.getByTestId('not-found-route-link')
+  notFoundRouteLink.click()
+
+  const notFoundComponent = await screen.findByTestId(
+    'not-found-with-props',
+    {},
+    { timeout: 1000 },
+  )
+  expect(notFoundComponent).toBeInTheDocument()
+
+  const errorMessageComponent = await screen.findByTestId('message')
+  expect(errorMessageComponent).toHaveTextContent(customData.message)
+})