@@ -147,6 +147,7 @@ async function* handleRoute(options: {
   metadata: ServerConfigRouteTreeNodeMetadata;
   currentRoutePath: string;
   parentRoute: string;
+  baseHref: string;
   route: Route;
   compiler: Compiler;
   parentInjector: Injector;
@@ -160,6 +161,7 @@ async function* handleRoute(options: {
       metadata,
       currentRoutePath,
       parentRoute,
+      baseHref,
       route,
       compiler,
       parentInjector,
@@ -179,8 +181,9 @@ async function* handleRoute(options: {
     if (metadata.renderMode === RenderMode.Prerender) {
       for await (const result of handleSSGRoute(
         serverConfigRouteTree,
-        typeof redirectTo === 'string' ? redirectTo : undefined,
+        route,
         parentRoute,
+        baseHref,
         metadata,
         parentInjector,
         invokeGetPrerenderParams,
@@ -200,9 +203,18 @@ async function* handleRoute(options: {
             `Please use one of the following redirect response codes: ${[...VALID_REDIRECT_RESPONSE_CODES.values()].join(', ')}.`,
         };
       } else if (typeof redirectTo === 'string') {
+        // Reference the route parameters by their position in the URL (see `buildPathWithParams`).
+        const routeSegments = joinUrlParts(baseHref, currentRoutePath).split('/');
         parentRoutes.set(metadata.route, {
           ...metadata,
-          redirectTo: resolveRedirectTo(parentRoute, redirectTo),
+          redirectTo: resolveRedirectTo(
+            parentRoute,
+            replaceRedirectParams(
+              route,
+              redirectTo,
+              (parameter) => `*${routeSegments.lastIndexOf(parameter)}`,
+            ),
+          ),
           relativeRedirect: redirectTo[0] !== '/' ? true : undefined,
         });
       } else {
@@ -290,6 +302,7 @@ async function* traverseRoutesConfig(options: {
   compiler: Compiler;
   parentInjector: Injector;
   parentRoute: string;
+  baseHref: string;
   serverConfigRouteTree?: RouteTree<ServerConfigRouteTreeAdditionalMetadata>;
   invokeGetPrerenderParams: boolean;
   includePrerenderFallbackRoutes: boolean;
@@ -421,8 +434,9 @@ function appendPreloadToMetadata(
  * all parameterized paths, returning any errors encountered.
  *
  * @param serverConfigRouteTree - The tree representing the server's routing setup.
- * @param redirectTo - Optional path to redirect to, if specified.
+ * @param route - The route configuration.
  * @param parentRoute - The path of the parent route.
+ * @param baseHref - The base href of the application.
  * @param metadata - The metadata associated with the route tree node.
  * @param parentInjector - The dependency injection container for the parent route.
  * @param invokeGetPrerenderParams - A flag indicating whether to invoke the `getPrerenderParams` function.
@@ -431,8 +445,9 @@ function appendPreloadToMetadata(
  */
 async function* handleSSGRoute(
   serverConfigRouteTree: RouteTree<ServerConfigRouteTreeAdditionalMetadata> | undefined,
-  redirectTo: string | undefined,
+  route: Route,
   parentRoute: string,
+  baseHref: string,
   metadata: ServerConfigRouteTreeNodeMetadata,
   parentInjector: Injector,
   invokeGetPrerenderParams: boolean,
@@ -451,8 +466,18 @@ async function* handleSSGRoute(
     delete meta['getPrerenderParams'];
   }
 
+  const redirectTo = typeof route.redirectTo === 'string' ? route.redirectTo : undefined;
   if (redirectTo !== undefined) {
-    meta.redirectTo = resolveRedirectTo(parentRoute, redirectTo);
+    // Reference the route parameters by their position in the URL (see `buildPathWithParams`).
+    const routeSegments = joinUrlParts(baseHref, currentRoutePath).split('/');
+    meta.redirectTo = resolveRedirectTo(
+      parentRoute,
+      replaceRedirectParams(
+        route,
+        redirectTo,
+        (parameter) => `*${routeSegments.lastIndexOf(parameter)}`,
+      ),
+    );
     meta.relativeRedirect = redirectTo[0] !== '/' ? true : undefined;
   }
 
@@ -513,7 +538,11 @@ async function* handleSSGRoute(
               ? undefined
               : resolveRedirectTo(
                   parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, replacer),
-                  redirectTo,
+                  replaceRedirectParams(
+                    route,
+                    redirectTo,
+                    (parameter) => params[parameter.slice(1)],
+                  ),
                 ),
         };
       }
@@ -589,6 +618,48 @@ function resolveRedirectTo(parentRoute: string, redirectTo: string): string {
   return joinUrlParts(parentRoute.replace(URL_PARAMETER_GLOBAL_REGEXP, '*'), path);
 }
 
+/**
+ * Replaces the route parameters, such as `:id`, in the path of `redirectTo`.
+ *
+ * Like in the Angular router, only whole path segments starting with `:` are parameters, and only
+ * the parameters defined in the path of the redirecting route itself can be used.
+ *
+ * @param route - The redirecting route.
+ * @param redirectTo - The target path for redirection.
+ * @param resolve - A function that returns the replacement for a parameter, such as `:id`.
+ * @returns The redirect path with its route parameters replaced.
+ * @throws If `redirectTo` uses a parameter that is not defined in the path of the route.
+ */
+function replaceRedirectParams(
+  route: Route,
+  redirectTo: string,
+  resolve: (parameter: string) => string,
+): string {
+  if (route.matcher) {
+    // The parameters of a custom matcher are only known at runtime.
+    return redirectTo;
+  }
+
+  const routeSegments = route.path?.split('/') ?? [];
+  const [path] = redirectTo.split(/[?#]/, 1);
+  const resolvedPath = path
+    .split('/')
+    .map((segment) => {
+      if (segment[0] !== ':') {
+        return segment;
+      }
+
+      if (!routeSegments.includes(segment)) {
+        throw new Error(`Cannot redirect to '${redirectTo}'. Cannot find '${segment}'.`);
+      }
+
+      return resolve(segment);
+    })
+    .join('/');
+
+  return resolvedPath + redirectTo.slice(path.length);
+}
+
 /**
  * Builds a server configuration route tree from the given server routes configuration.
  *
@@ -742,6 +813,7 @@ export async function getRoutesFromAngularRouterConfig(
         compiler,
         parentInjector: injector,
         parentRoute: '',
+        baseHref,
         serverConfigRouteTree,
         invokeGetPrerenderParams,
         includePrerenderFallbackRoutes,
 
@@ -152,12 +152,18 @@ export function stripIndexHtmlFromURL(url: URL): URL {
   return url;
 }
 
+/**
+ * Matches a `*<n>` placeholder that makes up a whole path segment.
+ */
+const POSITIONAL_PLACEHOLDER_REGEXP = /^\*(\d+)$/;
+
 /**
  * Resolves `*` placeholders in a path template by mapping them to corresponding segments
  * from a base path. This is useful for constructing paths dynamically based on a given base path.
  *
  * The function processes the `toPath` string, replacing each `*` placeholder with
- * the corresponding segment from the `fromPath`. If the `toPath` contains no placeholders,
+ * the corresponding segment from the `fromPath`, and each `*<n>` placeholder with the
+ * segment at position `n` of the `fromPath`. If the `toPath` contains no placeholders,
  * it is returned as-is. Invalid `toPath` formats (not starting with `/`) will throw an error.
  *
  * @param toPath - A path template string that may contain `*` placeholders. Each `*` is replaced
@@ -176,6 +182,10 @@ export function stripIndexHtmlFromURL(url: URL): URL {
  * const resolvedPath = buildPathWithParams('/*\/details', '/123/abc');
  * console.log(resolvedPath); // Outputs: '/123/details'
  *
+ * // Example with a positional placeholder
+ * const positionalPath = buildPathWithParams('/user/*1', '/123/abc');
+ * console.log(positionalPath); // Outputs: '/user/123'
+ *
  * // Example with a static path
  * const staticPath = buildPathWithParams('/static/path', '/base/unused');
  * console.log(staticPath); // Outputs: '/static/path'
@@ -190,17 +200,20 @@ export function buildPathWithParams(toPath: string, fromPath: string): string {
     throw new Error(`Invalid fromPath: The string must start with a '/'. Received: '${fromPath}'`);
   }
 
-  if (!toPath.includes('/*')) {
+  const [path] = toPath.split(/[?#]/, 1);
+  if (!path.includes('/*')) {
     return toPath;
   }
 
   const fromPathParts = fromPath.split('/');
-  const toPathParts = toPath.split('/');
+  const toPathParts = path.split('/');
   const resolvedParts = toPathParts.map((part, index) =>
-    toPathParts[index] === '*' ? fromPathParts[index] : part,
+    part === '*'
+      ? fromPathParts[index]
+      : part.replace(POSITIONAL_PLACEHOLDER_REGEXP, (_, position) => fromPathParts[position]),
   );
 
-  return joinUrlParts(...resolvedParts);
+  return joinUrlParts(...resolvedParts) + toPath.slice(path.length);
 }
 
 const MATRIX_PARAMS_REGEX = /;[^/]+/g;
 
@@ -90,6 +90,8 @@ describe('AngularServerApp', () => {
         { path: 'redirect/absolute', redirectTo: '/home' },
         { path: 'redirect-with-query', redirectTo: 'home?param=value' },
         { path: 'redirect-nested/:param', children: [{ path: 'old', redirectTo: 'new' }] },
+        { path: 'redirect-param/:a/:b', redirectTo: '/home/:b/:a' },
+        { path: 'redirect-param-relative/:id', redirectTo: 'target/:id' },
         {
           path: 'redirect-to-function',
           redirectTo: () => 'home',
@@ -252,6 +254,20 @@ describe('AngularServerApp', () => {
         expect(response?.status).toBe(302);
       });
 
+      it('should resolve route parameters in absolute redirect targets', async () => {
+        const response = await app.handle(new Request('http://localhost/redirect-param/x/y'));
+        expect(response?.headers.get('location')).toBe('/home/y/x');
+        expect(response?.status).toBe(302);
+      });
+
+      it('should resolve route parameters in relative redirect targets', async () => {
+        const response = await app.handle(
+          new Request('http://localhost/redirect-param-relative/7?filter=test'),
+        );
+        expect(response?.headers.get('location')).toBe('/target/7?filter=test');
+        expect(response?.status).toBe(302);
+      });
+
       it('should handle request abortion gracefully', async () => {
         const controller = new AbortController();
         const request = new Request('http://localhost/home', { signal: controller.signal });
 
@@ -489,6 +489,38 @@ describe('extractRoutesAndCreateRouteTree', () => {
         { route: '/new', renderMode: RenderMode.Server },
       ]);
     });
+
+    it('should resolve route parameters of redirect targets of prerendered routes', async () => {
+      setAngularAppTestingManifest(
+        [
+          { path: 'user/:id', redirectTo: '/profile/:id' },
+          { path: 'profile/:id', component: DummyComponent },
+        ],
+        [
+          {
+            path: 'user/:id',
+            renderMode: RenderMode.Prerender,
+            async getPrerenderParams() {
+              return [{ id: '7' }];
+            },
+          },
+          { path: '**', renderMode: RenderMode.Server },
+        ],
+      );
+
+      const { routeTree, errors } = await extractRoutesAndCreateRouteTree({
+        url,
+        invokeGetPrerenderParams: true,
+        includePrerenderFallbackRoutes: true,
+      });
+
+      expect(errors).toHaveSize(0);
+      expect(routeTree.toObject()).toEqual([
+        { route: '/user/7', renderMode: RenderMode.Prerender, redirectTo: '/profile/7' },
+        { route: '/user/*', renderMode: RenderMode.Server, redirectTo: '/profile/*2' },
+        { route: '/profile/*', renderMode: RenderMode.Server },
+      ]);
+    });
   });
 
   it('should extract routes with a route level matcher', async () => {
@@ -652,6 +684,52 @@ describe('extractRoutesAndCreateRouteTree', () => {
     ]);
   });
 
+  it('should reference route parameters of redirect targets by their position', async () => {
+    setAngularAppTestingManifest(
+      [
+        {
+          path: ':lang',
+          children: [
+            { path: 'user/:id', redirectTo: 'profile/:id' },
+            { path: 'profile/:id', component: DummyComponent },
+          ],
+        },
+        { path: 'search/:term', redirectTo: '/find/:term' },
+      ],
+      [{ path: '**', renderMode: RenderMode.Server }],
+    );
+
+    const { routeTree, errors } = await extractRoutesAndCreateRouteTree({ url });
+    expect(errors).toHaveSize(0);
+    expect(routeTree.toObject()).toEqual([
+      { route: '/*', renderMode: RenderMode.Server },
+      {
+        route: '/*/user/*',
+        renderMode: RenderMode.Server,
+        redirectTo: '/*/profile/*3',
+        relativeRedirect: true,
+      },
+      { route: '/*/profile/*', renderMode: RenderMode.Server },
+      { route: '/search/*', renderMode: RenderMode.Server, redirectTo: '/find/*2' },
+    ]);
+  });
+
+  it('should error when a redirect target uses a parameter not defined by the route', async () => {
+    setAngularAppTestingManifest(
+      [
+        {
+          path: ':lang',
+          children: [{ path: 'user/:id', redirectTo: 'profile/:lang' }],
+        },
+      ],
+      [{ path: '**', renderMode: RenderMode.Server }],
+    );
+
+    const { errors } = await extractRoutesAndCreateRouteTree({ url });
+    expect(errors).toHaveSize(1);
+    expect(errors[0]).toContain(`Cannot redirect to 'profile/:lang'. Cannot find ':lang'.`);
+  });
+
   it('should resolve multi-segment relative redirects against the parent route', async () => {
     setAngularAppTestingManifest(
       [
 
@@ -184,6 +184,15 @@ describe('URL Utils', () => {
       expect(result.toString()).toBe('/base/path/details');
     });
 
+    it('should replace positional placeholders with the segments at those positions', () => {
+      expect(buildPathWithParams('/user/*2/*1', '/a/b')).toBe('/user/b/a');
+    });
+
+    it('should replace a positional placeholder followed by a query or fragment', () => {
+      expect(buildPathWithParams('/user/*1?returnTo=/a//b/', '/a')).toBe('/user/a?returnTo=/a//b/');
+      expect(buildPathWithParams('/user/*1#top', '/a')).toBe('/user/a#top');
+    });
+
     it('should throw an error if the toPath does not start with "/"', () => {
       const fromPath = '/base/path';
       const toPath = 'details';