Claude-coauthored proxy code could treat a crafted path as a new host and forward the application's Clerk secret key to that host.

+ */+export interface NextFrontendApiProxyOptions extends Omit<FrontendApiProxyOptions, 'proxyPath'> {+  /**+   * The path prefix for proxy requests. For App Router route handlers,+   * this is typically derived from the route path.+   */+  proxyPath?: string;+}++/**+ * Proxies a request to Clerk's Frontend API in Next.js App Router.+ *+ * This function handles forwarding requests from your application to Clerk's+ * Frontend API, enabling scenarios where direct communication with Clerk's API+ * is blocked or needs to go through your application server.+ *+ * @param request - The incoming Next.js request+ * @param options - Proxy configuration options+ * @returns A Response from Clerk's Frontend API+ *+ * @example+ * ```typescript+ * // app/api/__clerk/[[...path]]/route.ts+ * import { clerkFrontendApiProxy } from '@clerk/nextjs/server';+ *+ * export async function GET(request: Request) {+ *   return clerkFrontendApiProxy(request);+ * }+ *+ * export async function POST(request: Request) {+ *   return clerkFrontendApiProxy(request);+ * }+ * ```+ */+export async function clerkFrontendApiProxy(+  request: Request,

+/**+ * Route handler type for Next.js App Router+ */+type RouteHandler = (request: Request) => Promise<Response>;++/**+ * Collection of route handlers for all HTTP methods+ */+export interface FrontendApiProxyHandlers {+  GET: RouteHandler;+  POST: RouteHandler;+  PUT: RouteHandler;+  DELETE: RouteHandler;+  PATCH: RouteHandler;+}++/**+ * Creates route handlers for proxying Clerk Frontend API requests.+ *+ * This function returns an object with handlers for GET, POST, PUT, DELETE, and PATCH+ * methods that can be directly exported from a Next.js App Router route file.+ *+ * @param options - Proxy configuration options+ * @returns An object with route handlers for all HTTP methods+ *+ * @example+ * ```typescript+ * // app/api/__clerk/[[...path]]/route.ts+ * import { createFrontendApiProxyHandlers } from '@clerk/nextjs/server';+ *+ * export const { GET, POST, PUT, DELETE, PATCH } = createFrontendApiProxyHandlers();+ * ```

@@ -50,7 +51,12 @@ import { } from './nextErrors'; import type { AuthProtect } from './protect'; import { createProtect } from './protect';-import type { NextMiddlewareEvtParam, NextMiddlewareRequestParam, NextMiddlewareReturn } from './types';+import type {+  FrontendApiProxyOptions,+  NextMiddlewareEvtParam,+  NextMiddlewareRequestParam,+  NextMiddlewareReturn,+} from './types'; import {   assertKey,   decorateRequest,@@ -88,6 +94,12 @@ export interface ClerkMiddlewareOptions extends AuthenticateAnyRequestOptions {    * When set, automatically injects a Content-Security-Policy header(s) compatible with Clerk.    */   contentSecurityPolicy?: ContentSecurityPolicyOptions;++  /**+   * When set, enables the middleware to proxy Frontend API requests to Clerk.+   * This is useful when direct communication with Clerk's API is blocked.+   */+  frontendApiProxy?: FrontendApiProxyOptions; }

+        const isEnabled = typeof enabled === 'function' ? enabled(requestUrl) : enabled;++        if (isEnabled && matchProxyPath(request, { proxyPath })) {+          return clerkFrontendApiProxy(request, {+            proxyPath,+            publishableKey,+            secretKey,+          });+        }+      }+       const signInUrl = resolvedParams.signInUrl || SIGN_IN_URL;       const signUpUrl = resolvedParams.signUpUrl || SIGN_UP_URL; @@ -368,9 +399,22 @@ export const createAuthenticateRequestOptions = (   clerkRequest: ClerkRequest,   options: ClerkMiddlewareOptions, ): Parameters<AuthenticateRequest>[1] => {

+    if (isEnabled) {+      const derivedProxyUrl = `${requestUrl.origin}${proxyPath}`;+      resolvedOptions = { ...options, proxyUrl: derivedProxyUrl };+    }+  }+   return {-    ...options,-    ...handleMultiDomainAndProxy(clerkRequest, options),+    ...resolvedOptions,+    ...handleMultiDomainAndProxy(clerkRequest, resolvedOptions),     // TODO: Leaving the acceptsToken as 'any' opens up the possibility of     // an economic attack. We should revisit this and only verify a token     // when auth() or auth.protect() is invoked.

 export type ExpressRequestWithAuth = ExpressRequest & {   auth: (options?: PendingSessionOptions) => SignedInAuthObject | SignedOutAuthObject; }; +/**+ * Options for configuring Frontend API proxy in clerkMiddleware+ */+export interface FrontendApiProxyOptions {+  /**+   * Enable proxy handling. Can be:+   * - `true` - enable for all domains+   * - `false` - disable for all domains+   * - A function: (url: URL) => boolean - enable based on the request URL+   */+  enabled: boolean | ShouldProxyFn;+  /**+   * The path prefix for proxy requests.+   *+   * @default '/__clerk'+   */+  path?: string;+}+ export type ClerkMiddlewareOptions = AuthenticateRequestOptions & {   debug?: boolean;   clerkClient?: ClerkClient;@@ -18,6 +38,24 @@ export type ClerkMiddlewareOptions = AuthenticateRequestOptions & {    * @default true    */   enableHandshake?: boolean;+  /**+   * Configure Frontend API proxy handling. When set, requests to the proxy path+   * will skip authentication, and the proxyUrl will be automatically derived+   * for handshake redirects.+   *+   * @example+   * // Enable with defaults (path: '/__clerk')+   * clerkMiddleware({ frontendApiProxy: { enabled: true } })+   *+   * @example+   * // Custom path+   * clerkMiddleware({ frontendApiProxy: { enabled: true, path: '/my-proxy' } })+   *+   * @example+   * // Disable proxy handling+   * clerkMiddleware({ frontendApiProxy: { enabled: false } })+   */+  frontendApiProxy?: FrontendApiProxyOptions; };  type ClerkClient = ReturnType<typeof createClerkClient>;

-  // Derive the FAPI URL and construct the target URL+  // Derive the FAPI URL and construct the target URL.+  // Use string concatenation instead of `new URL(path, base)` to avoid+  // protocol-relative resolution (e.g., "//evil.com" resolving to a different host).   const fapiBaseUrl = fapiUrlFromPublishableKey(publishableKey);+  const fapiHost = new URL(fapiBaseUrl).host;   const targetPath = requestUrl.pathname.slice(proxyPath.length) || '/';-  const targetUrl = new URL(targetPath, fapiBaseUrl);+  const targetUrl = new URL(`${fapiBaseUrl}${targetPath}`);   targetUrl.search = requestUrl.search; +  if (targetUrl.host !== fapiHost) {+    return createErrorResponse('proxy_request_failed', 'Resolved target does not match the expected host', 400);+  }+

-  const fapiHost = new URL(fapiBaseUrl).host;

-        responseHeaders.set(key, value);+        if (lower === 'set-cookie') {+          responseHeaders.append(key, value);+        } else {+          responseHeaders.set(key, value);+        }       }     }); 

+    it('does not follow protocol-relative paths', async () => {+      const mockResponse = new Response('{}', { status: 200 });+      mockFetch.mockResolvedValueOnce(mockResponse);

+      // String concatenation keeps the host as FAPI, not evil.com+      const fetchedUrl = new URL(mockFetch.mock.calls[0][0] as string);+      expect(fetchedUrl.host).toBe('frontend-api.clerk.dev');+    });+     it('forwards GET request to FAPI with correct headers', async () => {       const mockResponse = new Response(JSON.stringify({ client: {} }), {         status: 200,@@ -525,6 +541,33 @@ describe('proxy', () => {       expect(response.headers.get('Content-Type')).toBe('application/javascript');     });

+        status: 200,+        headers,+      });+      mockFetch.mockResolvedValue(mockResponse);

       const mockResponse = new Response(null, {         status: 302,