diff --git a/apps/web/src/app/api/openrouter/[...path]/route.ts b/apps/web/src/app/api/openrouter/[...path]/route.ts
index 200cd4c822..4d83617e9f 100644
--- a/apps/web/src/app/api/openrouter/[...path]/route.ts
+++ b/apps/web/src/app/api/openrouter/[...path]/route.ts
@@ -1103,7 +1103,10 @@ export async function POST(request: NextRequest): Promise<NextResponseType<unkno
       requestedModel: effectiveModelIdLowerCased,
       request: requestBodyParsed,
       response,
-      isUserByok: !!effectiveProviderContext.userByok,
+      userByokProviderIds:
+        effectiveProviderContext.userByok === null
+          ? null
+          : effectiveProviderContext.userByok.map(byok => byok.providerId),
     });
     if (errorResponse) {
       await logUnrewrittenResponse({
diff --git a/apps/web/src/components/organizations/byok/BYOKKeysManager.tsx b/apps/web/src/components/organizations/byok/BYOKKeysManager.tsx
index 00f677ab16..ed96468d5a 100644
--- a/apps/web/src/components/organizations/byok/BYOKKeysManager.tsx
+++ b/apps/web/src/components/organizations/byok/BYOKKeysManager.tsx
@@ -44,6 +44,7 @@ import {
   UserByokProviderIdSchema,
   VercelUserByokInferenceProviderIdSchema,
   AwsCredentialsSchema,
+  VertexCredentialsSchema,
   type VercelUserByokInferenceProviderId,
 } from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
 import { DIRECT_BYOK_PROVIDERS_META } from '@/lib/ai-gateway/providers/direct-byok/direct-byok-meta';
@@ -66,6 +67,7 @@ const VERCEL_BYOK_PROVIDER_NAMES = {
   moonshotai: 'Moonshot AI',
   novita: 'Novita',
   perplexity: 'Perplexity',
+  vertex: 'Google Vertex AI',
   xai: 'SpaceXAI',
   xiaomi: 'Xiaomi (pay as you go)',
   zai: 'Z.ai (pay as you go)',
@@ -151,7 +153,7 @@ type BYOKDialogState = {
   selectedProvider: string;
   apiKey: string;
   showApiKey: boolean;
-  awsCredentialError: string | null;
+  credentialError: string | null;
 };
 
 const INITIAL_BYOK_DIALOG_STATE: BYOKDialogState = {
@@ -160,7 +162,7 @@ const INITIAL_BYOK_DIALOG_STATE: BYOKDialogState = {
   selectedProvider: '',
   apiKey: '',
   showApiKey: false,
-  awsCredentialError: null,
+  credentialError: null,
 };
 
 function updateBYOKDialogState(state: BYOKDialogState, update: Partial<BYOKDialogState>) {
@@ -172,15 +174,15 @@ export function BYOKKeysManager({ organizationId }: BYOKKeysManagerProps) {
     updateBYOKDialogState,
     INITIAL_BYOK_DIALOG_STATE
   );
-  const { isDialogOpen, editingKeyId, selectedProvider, apiKey, showApiKey, awsCredentialError } =
+  const { isDialogOpen, editingKeyId, selectedProvider, apiKey, showApiKey, credentialError } =
     dialogState;
   const setIsDialogOpen = (isDialogOpen: boolean) => updateDialogState({ isDialogOpen });
   const setEditingKeyId = (editingKeyId: string | null) => updateDialogState({ editingKeyId });
   const setSelectedProvider = (selectedProvider: string) => updateDialogState({ selectedProvider });
   const setApiKey = (apiKey: string) => updateDialogState({ apiKey });
   const setShowApiKey = (showApiKey: boolean) => updateDialogState({ showApiKey });
-  const setAwsCredentialError = (awsCredentialError: string | null) =>
-    updateDialogState({ awsCredentialError });
+  const setCredentialError = (credentialError: string | null) =>
+    updateDialogState({ credentialError });
   const trpc = useTRPC();
   const queryClient = useQueryClient();
   const confirm = useConfirm();
@@ -274,17 +276,28 @@ export function BYOKKeysManager({ organizationId }: BYOKKeysManagerProps) {
     return keys?.some(k => k.provider_id === providerSlug) ?? false;
   };
 
-  const validateAwsCredentials = (value: string): string | null => {
+  const validateStructuredCredentials = (providerId: string, value: string): string | null => {
     if (!value) return null;
+    const schema =
+      providerId === VercelUserByokInferenceProviderIdSchema.enum.bedrock
+        ? AwsCredentialsSchema
+        : providerId === VercelUserByokInferenceProviderIdSchema.enum.vertex
+          ? VertexCredentialsSchema
+          : null;
+    if (!schema) return null;
     let parsed: unknown;
     try {
       parsed = JSON.parse(value);
     } catch {
-      return 'Invalid JSON — please enter a valid JSON object.';
+      return 'Invalid JSON. Enter a valid JSON object.';
     }
-    const result = AwsCredentialsSchema.safeParse(parsed);
+    const result = schema.safeParse(parsed);
     if (!result.success) {
-      return `Invalid AWS credentials:\n${z.prettifyError(result.error)}`;
+      const providerName =
+        providerId === VercelUserByokInferenceProviderIdSchema.enum.bedrock
+          ? 'AWS'
+          : 'Google Vertex';
+      return `Invalid ${providerName} credentials:\n${z.prettifyError(result.error)}`;
     }
     return null;
   };
@@ -295,15 +308,13 @@ export function BYOKKeysManager({ organizationId }: BYOKKeysManagerProps) {
     setSelectedProvider('');
     setApiKey('');
     setShowApiKey(false);
-    setAwsCredentialError(null);
+    setCredentialError(null);
   };
 
   const handleSave = () => {
-    if (selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.bedrock) {
-      const error = validateAwsCredentials(apiKey);
-      setAwsCredentialError(error);
-      if (error) return;
-    }
+    const error = validateStructuredCredentials(selectedProvider, apiKey);
+    setCredentialError(error);
+    if (error) return;
     if (editingKeyId) {
       updateMutation.mutate({
         ...(organizationId && { organizationId }),
@@ -526,7 +537,10 @@ export function BYOKKeysManager({ organizationId }: BYOKKeysManagerProps) {
                 <Label htmlFor="provider">Provider</Label>
                 <Select
                   value={selectedProvider}
-                  onValueChange={setSelectedProvider}
+                  onValueChange={providerId => {
+                    setSelectedProvider(providerId);
+                    setCredentialError(null);
+                  }}
                   disabled={!!editingKeyId}
                 >
                   <SelectTrigger id="provider">
@@ -568,26 +582,44 @@ export function BYOKKeysManager({ organizationId }: BYOKKeysManagerProps) {
                 <Label htmlFor="apiKey">
                   {selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.bedrock
                     ? 'AWS Credentials'
-                    : 'API Key'}
+                    : selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.vertex
+                      ? 'Google Vertex Credentials'
+                      : 'API Key'}
                 </Label>
-                {selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.bedrock ? (
+                {selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.bedrock ||
+                selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.vertex ? (
                   <>
                     <textarea
                       id="apiKey"
                       value={apiKey}
                       onChange={e => {
                         setApiKey(e.target.value);
-                        setAwsCredentialError(validateAwsCredentials(e.target.value));
+                        setCredentialError(null);
                       }}
-                      placeholder='{"accessKeyId": "...", "secretAccessKey": "...", "region": "us-east-1"}'
+                      onBlur={e =>
+                        setCredentialError(
+                          validateStructuredCredentials(selectedProvider, e.target.value)
+                        )
+                      }
+                      placeholder={
+                        selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.bedrock
+                          ? '{"accessKeyId": "...", "secretAccessKey": "...", "region": "us-east-1"}'
+                          : '{"project": "...", "location": "global", "googleCredentials": {"clientEmail": "...", "privateKey": "..."}}'
+                      }
                       className="border-input bg-background placeholder:text-muted-foreground focus-visible:ring-ring flex min-h-20 w-full rounded-md border px-3 py-2 text-sm focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:outline-none disabled:cursor-not-allowed disabled:opacity-50"
-                      rows={4}
-                      aria-label="AWS credentials"
+                      rows={6}
+                      aria-label={
+                        selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.bedrock
+                          ? 'AWS credentials'
+                          : 'Google Vertex credentials'
+                      }
+                      aria-invalid={credentialError ? true : undefined}
+                      aria-describedby={credentialError ? 'credential-error' : undefined}
                     />
-                    {awsCredentialError && (
-                      <Alert variant="destructive">
+                    {credentialError && (
+                      <Alert id="credential-error" variant="destructive">
                         <AlertDescription className="whitespace-break-spaces">
-                          {awsCredentialError}
+                          {credentialError}
                         </AlertDescription>
                       </Alert>
                     )}
@@ -630,6 +662,23 @@ export function BYOKKeysManager({ organizationId }: BYOKKeysManagerProps) {
                     </AlertDescription>
                   </Alert>
                 )}
+                {selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.vertex && (
+                  <Alert>
+                    <Info className="size-4" />
+                    <AlertDescription>
+                      <p>Enter your Google Cloud project, Vertex location, and service account:</p>
+                      <code className="mt-1 block text-xs break-all">
+                        {
+                          '{"project": "...", "location": "global", "googleCredentials": {"clientEmail": "...", "privateKey": "..."}}'
+                        }
+                      </code>
+                      <p className="mt-1">
+                        Enable the Vertex AI API and grant the service account permission to invoke
+                        the models you use. Claude models may also require access in Model Garden.
+                      </p>
+                    </AlertDescription>
+                  </Alert>
+                )}
                 {editingKeyId ? (
                   <Alert>
                     <Lock className="size-4" />
@@ -722,8 +771,7 @@ export function BYOKKeysManager({ organizationId }: BYOKKeysManagerProps) {
                 disabled={
                   !selectedProvider ||
                   !apiKey ||
-                  (selectedProvider === VercelUserByokInferenceProviderIdSchema.enum.bedrock &&
-                    !!awsCredentialError) ||
+                  !!credentialError ||
                   createMutation.isPending ||
                   updateMutation.isPending
                 }
diff --git a/apps/web/src/lib/ai-gateway/byok/index.ts b/apps/web/src/lib/ai-gateway/byok/index.ts
index dd7700b909..a420296bd0 100644
--- a/apps/web/src/lib/ai-gateway/byok/index.ts
+++ b/apps/web/src/lib/ai-gateway/byok/index.ts
@@ -6,7 +6,7 @@ import { decryptApiKey } from '@/lib/ai-gateway/byok/encryption';
 import { BYOK_ENCRYPTION_KEY } from '@/lib/config.server';
 import {
   UserByokProviderIdSchema,
-  VercelUserByokInferenceProviderIdSchema,
+  getVercelUserByokProviderIdForEndpoint,
   type UserByokProviderId,
 } from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
 import { isCodestralModel } from '@/lib/ai-gateway/providers/mistral';
@@ -22,10 +22,13 @@ export async function getModelUserByokProviders(modelId: string): Promise<UserBy
     console.error('[getModelUserByokProviders] no Vercel model metadata for model %s', modelId);
     return [];
   }
-  const providers: UserByokProviderId[] =
-    vercelModelMetadata[mapModelIdToVercel(modelId)]?.endpoints
-      .map(ep => VercelUserByokInferenceProviderIdSchema.safeParse(ep.provider_name ?? ep.tag).data)
-      .filter(providerId => providerId !== undefined) ?? [];
+  const providers: UserByokProviderId[] = [
+    ...new Set(
+      vercelModelMetadata[mapModelIdToVercel(modelId)]?.endpoints
+        .map(ep => getVercelUserByokProviderIdForEndpoint(ep.provider_name ?? ep.tag))
+        .filter(providerId => providerId !== undefined) ?? []
+    ),
+  ];
   if (providers.length === 0) {
     console.debug(`[getModelUserByokProviders] no user byok providers for ${modelId}`);
     return [];
diff --git a/apps/web/src/lib/ai-gateway/llm-proxy-helpers.test.ts b/apps/web/src/lib/ai-gateway/llm-proxy-helpers.test.ts
index 08ffc66d5b..64274da1c1 100644
--- a/apps/web/src/lib/ai-gateway/llm-proxy-helpers.test.ts
+++ b/apps/web/src/lib/ai-gateway/llm-proxy-helpers.test.ts
@@ -872,11 +872,77 @@ describe('makeErrorReadable', () => {
       requestedModel: 'anything',
       request,
       response,
-      isUserByok: false,
+      userByokProviderIds: null,
     });
     expect(result).toBeUndefined();
   });
 
+  it('explains a missing model for a Vertex user BYOK request', async () => {
+    const response = Response.json({ error: { message: 'AI_APICallError' } }, { status: 404 });
+
+    const result = await makeErrorReadable({
+      providerId: 'vercel',
+      requestedModel: 'anthropic/claude-sonnet-5',
+      request,
+      response,
+      userByokProviderIds: ['vertex'],
+    });
+
+    expect(result?.status).toBe(404);
+    await expect(result?.json()).resolves.toEqual({
+      error:
+        '[BYOK] Google Vertex AI could not find the requested model. The model might not be enabled for your Google Cloud project or selected Vertex location.',
+      error_type: 'byok_error',
+      message:
+        '[BYOK] Google Vertex AI could not find the requested model. The model might not be enabled for your Google Cloud project or selected Vertex location.',
+    });
+  });
+
+  it('does not label other user BYOK 404 responses as Vertex errors', async () => {
+    const response = Response.json({ error: { message: 'Model not found' } }, { status: 404 });
+
+    await expect(
+      makeErrorReadable({
+        providerId: 'vercel',
+        requestedModel: 'anthropic/claude-sonnet-5',
+        request,
+        response,
+        userByokProviderIds: ['anthropic'],
+      })
+    ).resolves.toBeUndefined();
+  });
+
+  it.each([
+    [401, []],
+    [402, ['anthropic']],
+    [403, []],
+    [429, ['anthropic']],
+  ] as const)('treats a non-null provider set as user BYOK for status %i', async (status, ids) => {
+    const result = await makeErrorReadable({
+      providerId: 'vercel',
+      requestedModel: 'anthropic/claude-sonnet-5',
+      request,
+      response: Response.json({}, { status }),
+      userByokProviderIds: [...ids],
+    });
+
+    expect(result).toBeDefined();
+    if (!result) throw new Error('Expected a readable BYOK error response');
+    expect((await result.json()).error_type).toBe('byok_error');
+  });
+
+  it('does not use generic BYOK errors for a null provider set', async () => {
+    await expect(
+      makeErrorReadable({
+        providerId: 'vercel',
+        requestedModel: 'anthropic/claude-sonnet-5',
+        request,
+        response: Response.json({}, { status: 401 }),
+        userByokProviderIds: null,
+      })
+    ).resolves.toBeUndefined();
+  });
+
   it('returns an actionable error when no allowed provider serves the model', async () => {
     const response = Response.json(
       {
@@ -895,7 +961,7 @@ describe('makeErrorReadable', () => {
       requestedModel: 'qwen/qwen3.7-plus',
       request,
       response,
-      isUserByok: false,
+      userByokProviderIds: null,
     });
 
     expect(result?.status).toBe(404);
@@ -927,7 +993,7 @@ describe('makeErrorReadable', () => {
       requestedModel: 'qwen/qwen3.7-plus',
       request,
       response,
-      isUserByok: false,
+      userByokProviderIds: null,
     });
 
     expect(result).toBeDefined();
@@ -955,7 +1021,7 @@ describe('makeErrorReadable', () => {
         requestedModel: 'anything',
         request,
         response,
-        isUserByok: false,
+        userByokProviderIds: null,
       })
     ).resolves.toBeUndefined();
   });
@@ -981,7 +1047,7 @@ describe('makeErrorReadable', () => {
           requestedModel: 'anything',
           request,
           response,
-          isUserByok: false,
+          userByokProviderIds: null,
         })
       ).resolves.toBeUndefined();
     }
@@ -998,7 +1064,7 @@ describe('makeErrorReadable', () => {
       requestedModel: 'kilo-internal/custom-endpoint',
       request,
       response,
-      isUserByok: false,
+      userByokProviderIds: null,
     });
 
     expect(result).toBeUndefined();
@@ -1015,7 +1081,7 @@ describe('makeErrorReadable', () => {
       requestedModel: 'experiment/test-model',
       request,
       response,
-      isUserByok: false,
+      userByokProviderIds: null,
     });
 
     expect(result).toBeDefined();
@@ -1038,7 +1104,7 @@ describe('makeErrorReadable', () => {
       requestedModel: 'stealth/claude-opus-4.7',
       request,
       response,
-      isUserByok: false,
+      userByokProviderIds: null,
     });
 
     expect(result).toBeDefined();
diff --git a/apps/web/src/lib/ai-gateway/llm-proxy-helpers.ts b/apps/web/src/lib/ai-gateway/llm-proxy-helpers.ts
index f886b4489c..3ac9529bb9 100644
--- a/apps/web/src/lib/ai-gateway/llm-proxy-helpers.ts
+++ b/apps/web/src/lib/ai-gateway/llm-proxy-helpers.ts
@@ -47,6 +47,7 @@ import { computeOpenRouterCostFields } from '@/lib/ai-gateway/processUsage.share
 import { persistExperimentAttribution } from '@/lib/ai-gateway/experiments/persist';
 import { ProxyErrorType } from '@/lib/proxy-error-types';
 import { getInferenceProvider } from '@/lib/ai-gateway/providers/kilo-exclusive-model';
+import type { UserByokProviderId } from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
 
 // FIM suffix markers for tracking purposes - used to wrap suffix in a fake system prompt format
 // This allows FIM requests to be tracked consistently with chat requests
@@ -203,6 +204,27 @@ function byokErrorMessage(status: number): string | undefined {
   return byokErrorMessages[status];
 }
 
+function vertexByokModelNotFoundResponse(
+  response: Response,
+  userByokProviderIds: UserByokProviderId[] | null
+) {
+  if (
+    userByokProviderIds === null ||
+    !userByokProviderIds.includes('vertex') ||
+    response.status !== 404
+  ) {
+    return undefined;
+  }
+
+  const error =
+    '[BYOK] Google Vertex AI could not find the requested model. The model might not be enabled for your Google Cloud project or selected Vertex location.';
+  warnExceptInTest(`Responding with ${response.status} ${error}`);
+  return NextResponse.json(
+    { error, error_type: ProxyErrorType.byok_error, message: error },
+    { status: response.status }
+  );
+}
+
 const noAllowedProvidersErrorSchema = z.object({
   message: z.literal('No allowed providers are available for the selected model.'),
   code: z.literal(404),
@@ -251,19 +273,22 @@ export async function makeErrorReadable({
   requestedModel,
   request,
   response,
-  isUserByok,
+  userByokProviderIds,
 }: {
   providerId: ProviderId;
   requestedModel: string;
   request: GatewayRequest;
   response: Response;
-  isUserByok: boolean;
+  userByokProviderIds: UserByokProviderId[] | null;
 }) {
   if (response.status < 400) {
     return undefined;
   }
 
-  if (isUserByok) {
+  const vertexByokResponse = vertexByokModelNotFoundResponse(response, userByokProviderIds);
+  if (vertexByokResponse) return vertexByokResponse;
+
+  if (userByokProviderIds !== null) {
     const byokMessage = byokErrorMessage(response.status);
     if (byokMessage) {
       warnExceptInTest(`Responding with ${response.status} ${byokMessage}`);
diff --git a/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.test.ts b/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.test.ts
index 539992af63..8968f16606 100644
--- a/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.test.ts
+++ b/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.test.ts
@@ -1,8 +1,12 @@
 import {
   DirectUserByokInferenceProviderIdSchema,
+  getVercelUserByokProviderIdForEndpoint,
+  normalizeVercelInferenceProviderIdForRouting,
   openRouterToVercelInferenceProviderId,
   OpenRouterInferenceProviderIdSchema,
   VercelInferenceProviderIdSchema,
+  VercelNonUserByokInferenceProviderIdSchema,
+  VercelUserByokInferenceProviderIdSchema,
 } from './inference-provider-id';
 
 describe('inference provider ids', () => {
@@ -14,7 +18,7 @@ describe('inference provider ids', () => {
     expect(overlappingProviderIds).toEqual([]);
   });
 
-  test('direct BYOK provider ids do not overlap with Vercel provider ids', () => {
+  test('direct BYOK provider ids do not overlap with known Vercel provider ids', () => {
     const overlappingProviderIds = DirectUserByokInferenceProviderIdSchema.options.filter(
       providerId => VercelInferenceProviderIdSchema.safeParse(providerId).success
     );
@@ -25,4 +29,22 @@ describe('inference provider ids', () => {
   test('maps the OpenRouter Claude AWS provider to its Vercel provider id', () => {
     expect(openRouterToVercelInferenceProviderId('claude-on-aws')).toBe('claudeaws');
   });
+
+  test('preserves provider ids that are not in the known provider registry', () => {
+    expect(openRouterToVercelInferenceProviderId('future-provider')).toBe('future-provider');
+    expect(normalizeVercelInferenceProviderIdForRouting('future-provider')).toBe('future-provider');
+  });
+
+  test('promotes Vertex to a user BYOK provider', () => {
+    expect(VercelUserByokInferenceProviderIdSchema.safeParse('vertex').success).toBe(true);
+    expect(VercelNonUserByokInferenceProviderIdSchema.safeParse('vertex').success).toBe(false);
+    expect(openRouterToVercelInferenceProviderId('google-vertex')).toBe('vertex');
+  });
+
+  test('uses the Vertex user key for Vertex Anthropic endpoints', () => {
+    expect(normalizeVercelInferenceProviderIdForRouting('vertexAnthropic')).toBe('vertex');
+    expect(getVercelUserByokProviderIdForEndpoint('vertexAnthropic')).toBe('vertex');
+    expect(getVercelUserByokProviderIdForEndpoint('vertex')).toBe('vertex');
+    expect(getVercelUserByokProviderIdForEndpoint('unsupported')).toBeUndefined();
+  });
 });
diff --git a/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.ts b/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.ts
index 454051a20e..85bcc5a1f2 100644
--- a/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.ts
+++ b/apps/web/src/lib/ai-gateway/providers/openrouter/inference-provider-id.ts
@@ -92,6 +92,7 @@ export const VercelUserByokInferenceProviderIdSchema = z.enum([
   'moonshotai',
   'novita',
   'perplexity',
+  'vertex',
   'xai',
   'xiaomi',
   'zai',
@@ -146,6 +147,7 @@ export const UserByokTestModels = {
   [VercelUserByokInferenceProviderIdSchema.enum.mistral]: 'mistral/mistral-medium-3.5',
   [VercelUserByokInferenceProviderIdSchema.enum.openai]: 'openai/gpt-5-nano',
   [VercelUserByokInferenceProviderIdSchema.enum.perplexity]: 'perplexity/sonar',
+  [VercelUserByokInferenceProviderIdSchema.enum.vertex]: 'google/gemini-2.5-flash-lite',
   [VercelUserByokInferenceProviderIdSchema.enum.xai]: 'xai/grok-4.1-fast-non-reasoning',
   [VercelUserByokInferenceProviderIdSchema.enum.xiaomi]: 'xiaomi/mimo-v2-flash',
   [VercelUserByokInferenceProviderIdSchema.enum.zai]: 'zai/glm-4.7-flash',
@@ -171,6 +173,8 @@ export const UserByokTestModels = {
   [DirectUserByokInferenceProviderIdSchema.enum['zai-coding']]: 'glm-4.7',
 } satisfies Record<UserByokProviderId, string>;
 
+// This is a registry of provider IDs referenced explicitly in our mappings, not
+// an exhaustive schema for the open-ended provider IDs returned by Vercel.
 export const VercelNonUserByokInferenceProviderIdSchema = z.enum([
   'alibaba',
   'arcee-ai',
@@ -203,7 +207,6 @@ export const VercelNonUserByokInferenceProviderIdSchema = z.enum([
   'stepfun',
   'streamlake',
   'togetherai',
-  'vertex',
   'vertexAnthropic',
   'voyage',
   'wafer',
@@ -225,7 +228,7 @@ const openRouterToVercelInferenceProviderMapping = {
   [OpenRouterInferenceProviderIdSchema.enum['google-ai-studio']]:
     VercelUserByokInferenceProviderIdSchema.enum.google,
   [OpenRouterInferenceProviderIdSchema.enum['google-vertex']]:
-    VercelNonUserByokInferenceProviderIdSchema.enum.vertex,
+    VercelUserByokInferenceProviderIdSchema.enum.vertex,
   [OpenRouterInferenceProviderIdSchema.enum.seed]:
     VercelNonUserByokInferenceProviderIdSchema.enum.bytedance,
   [OpenRouterInferenceProviderIdSchema.enum['z-ai']]:
@@ -242,11 +245,29 @@ export function normalizeInferenceProviderId(providerId: string | undefined) {
   return (slashIndex >= 0 ? providerId.slice(0, slashIndex) : providerId).toLowerCase();
 }
 
-export function openRouterToVercelInferenceProviderId(providerId: string) {
+export function openRouterToVercelInferenceProviderId(providerId: string): string {
   const normalizedProviderId = normalizeInferenceProviderId(providerId);
   return openRouterToVercelInferenceProviderMapping[normalizedProviderId] ?? normalizedProviderId;
 }
 
+export function getVercelUserByokProviderIdForEndpoint(
+  providerId: string | undefined
+): VercelUserByokInferenceProviderId | undefined {
+  return VercelUserByokInferenceProviderIdSchema.safeParse(
+    normalizeVercelInferenceProviderIdForRouting(providerId)
+  ).data;
+}
+
+export function normalizeVercelInferenceProviderIdForRouting(providerId: string): string;
+export function normalizeVercelInferenceProviderIdForRouting(
+  providerId: string | undefined
+): string | undefined;
+export function normalizeVercelInferenceProviderIdForRouting(providerId: string | undefined) {
+  return providerId === VercelNonUserByokInferenceProviderIdSchema.enum.vertexAnthropic
+    ? VercelUserByokInferenceProviderIdSchema.enum.vertex
+    : providerId;
+}
+
 const modelPrefixToVercelInferenceProviderMapping = {
   anthropic: VercelUserByokInferenceProviderIdSchema.enum.anthropic,
   google: VercelUserByokInferenceProviderIdSchema.enum.google,
@@ -273,3 +294,14 @@ export const AwsCredentialsSchema = z.object({
 });
 
 export type AwsCredentials = z.infer<typeof AwsCredentialsSchema>;
+
+export const VertexCredentialsSchema = z.object({
+  project: z.string().min(1),
+  location: z.string().min(1),
+  googleCredentials: z.object({
+    privateKey: z.string().min(1),
+    clientEmail: z.string().min(1),
+  }),
+});
+
+export type VertexCredentials = z.infer<typeof VertexCredentialsSchema>;
diff --git a/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.test.ts b/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.test.ts
index 8ba59ce97e..8c688142ab 100644
--- a/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.test.ts
+++ b/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.test.ts
@@ -99,4 +99,41 @@ describe('injectExtraProviderModels', () => {
     expect(modelTrains(nvidia, true)).toBe(true);
     expect(modelRetainsPrompts(nvidia, true)).toBe(true);
   });
+
+  test('injects offerings for providers outside the known provider registry', () => {
+    const model = nvidiaModel();
+    const providerModelData = [
+      {
+        provider: provider('nvidia', 'NVIDIA', {
+          training: true,
+          retainsPrompts: true,
+          canPublish: false,
+        }),
+        models: [model],
+      },
+      {
+        provider: provider('future-provider', 'Future Provider', {
+          training: false,
+          retainsPrompts: false,
+          canPublish: false,
+        }),
+        models: [] as OpenRouterModel[],
+      },
+    ];
+    const vercelModels: Record<string, StoredModel> = {
+      [MODEL_SLUG]: {
+        id: MODEL_SLUG,
+        name: model.name,
+        endpoints: [
+          { provider_name: 'nvidia' },
+          { provider_name: 'future-provider', context_length: 128_000 },
+        ],
+      },
+    };
+
+    injectExtraProviderModels(vercelModels, providerModelData);
+
+    expect(providerModelData[1]?.models[0]?.slug).toBe(MODEL_SLUG);
+    expect(providerModelData[1]?.models[0]?.context_length).toBe(128_000);
+  });
 });
diff --git a/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.ts b/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.ts
index 9da97ee6d2..332ad8e09a 100644
--- a/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.ts
+++ b/apps/web/src/lib/ai-gateway/providers/openrouter/inject-extra-provider-models.ts
@@ -1,7 +1,7 @@
 import { mapModelIdToVercel } from '@/lib/ai-gateway/providers/vercel/mapModelIdToVercel';
 import {
+  normalizeVercelInferenceProviderIdForRouting,
   openRouterToVercelInferenceProviderId,
-  VercelInferenceProviderIdSchema,
 } from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
 import type {
   OpenRouterModel,
@@ -25,20 +25,20 @@ export function injectExtraProviderModels(
 
     const vercelInferenceProviders = new Set(
       vercelModel.endpoints
-        .map(
-          endpoint =>
-            VercelInferenceProviderIdSchema.safeParse(endpoint.provider_name ?? endpoint.tag).data
+        .map(endpoint =>
+          normalizeVercelInferenceProviderIdForRouting(endpoint.provider_name ?? endpoint.tag)
         )
         .filter(p => p !== undefined)
     );
 
     for (const providerData of providerModelData) {
-      const vercelProviderId = VercelInferenceProviderIdSchema.safeParse(
-        openRouterToVercelInferenceProviderId(providerData.provider.slug)
-      ).data;
-      const endpoint = vercelModel.endpoints.find(e => e.provider_name === vercelProviderId);
+      const vercelProviderId = openRouterToVercelInferenceProviderId(providerData.provider.slug);
+      const endpoint = vercelModel.endpoints.find(
+        endpoint =>
+          normalizeVercelInferenceProviderIdForRouting(endpoint.provider_name ?? endpoint.tag) ===
+          vercelProviderId
+      );
       if (
-        vercelProviderId &&
         endpoint &&
         vercelInferenceProviders.has(vercelProviderId) &&
         !providerData.models.some(m => m.slug === model.slug)
diff --git a/apps/web/src/lib/ai-gateway/providers/openrouter/types.ts b/apps/web/src/lib/ai-gateway/providers/openrouter/types.ts
index 3121927cc9..b4851986cd 100644
--- a/apps/web/src/lib/ai-gateway/providers/openrouter/types.ts
+++ b/apps/web/src/lib/ai-gateway/providers/openrouter/types.ts
@@ -2,7 +2,10 @@ import type OpenAI from 'openai';
 import type { GatewayProviderOptions } from '@ai-sdk/gateway';
 import type { AnthropicProviderOptions } from '@ai-sdk/anthropic';
 import type { ReasoningDetailUnion } from '@/lib/ai-gateway/custom-llm/reasoning-details';
-import type { AwsCredentials } from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
+import type {
+  AwsCredentials,
+  VertexCredentials,
+} from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
 import type Anthropic from '@anthropic-ai/sdk';
 
 // Base types for OpenRouter API that don't depend on other lib files
@@ -21,7 +24,10 @@ export function isOpenRouterProviderConfig(value: unknown): value is OpenRouterP
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-export type VercelInferenceProviderConfig = { apiKey: string; baseURL?: string } | AwsCredentials;
+export type VercelInferenceProviderConfig =
+  | { apiKey: string; baseURL?: string }
+  | AwsCredentials
+  | VertexCredentials;
 
 export type VercelProviderConfig = {
   gateway?: GatewayProviderOptions & {
diff --git a/apps/web/src/lib/ai-gateway/providers/vercel/index.test.ts b/apps/web/src/lib/ai-gateway/providers/vercel/index.test.ts
index e9f98aef10..5c5b7dddfc 100644
--- a/apps/web/src/lib/ai-gateway/providers/vercel/index.test.ts
+++ b/apps/web/src/lib/ai-gateway/providers/vercel/index.test.ts
@@ -79,6 +79,16 @@ describe('hasCompatibleVercelInferenceProvider', () => {
     );
   });
 
+  it('accepts Google Vertex preferences for Vertex Anthropic endpoint metadata', () => {
+    expect(hasCompatibleVercelInferenceProvider(['google-vertex'], ['vertexAnthropic'])).toBe(true);
+  });
+
+  it('accepts providers outside the known provider registry', () => {
+    expect(hasCompatibleVercelInferenceProvider(['future-provider'], ['future-provider'])).toBe(
+      true
+    );
+  });
+
   it('rejects when none of the requested providers are available on Vercel', () => {
     expect(hasCompatibleVercelInferenceProvider(['google-vertex'], ['anthropic', 'bedrock'])).toBe(
       false
@@ -105,6 +115,15 @@ describe('getVercelInferenceProvidersExcludingIgnored', () => {
     ).toEqual(['anthropic', 'vertex']);
   });
 
+  it('excludes normalized Vertex Anthropic endpoints for Google Vertex ignores', () => {
+    expect(
+      getVercelInferenceProvidersExcludingIgnored(['google-vertex'], undefined, [
+        'anthropic',
+        'vertexAnthropic',
+      ])
+    ).toEqual(['anthropic']);
+  });
+
   it('intersects the available providers with only before excluding ignored providers', () => {
     expect(
       getVercelInferenceProvidersExcludingIgnored(
@@ -123,6 +142,16 @@ describe('getVercelInferenceProvidersExcludingIgnored', () => {
       ])
     ).toEqual([]);
   });
+
+  it('preserves and filters providers outside the known provider registry', () => {
+    expect(
+      getVercelInferenceProvidersExcludingIgnored(['future-provider'], undefined, [
+        'anthropic',
+        'future-provider',
+        'another-future-provider',
+      ])
+    ).toEqual(['anthropic', 'another-future-provider']);
+  });
 });
 
 describe('convertProviderOptions', () => {
@@ -145,6 +174,25 @@ describe('convertProviderOptions', () => {
     expect(providerOptions.gateway?.only).toEqual(['anthropic']);
     expect(provider?.only).toEqual(['anthropic', 'amazon-bedrock']);
   });
+
+  it('passes providers outside the known provider registry through unchanged', () => {
+    const request: GatewayRequest = {
+      kind: 'chat_completions',
+      body: {
+        model: 'future/model',
+        messages: [{ role: 'user', content: 'hello' }],
+        provider: {
+          only: ['future-provider'],
+          order: ['another-future-provider'],
+        },
+      },
+    };
+
+    expect(convertProviderOptions(request, null).gateway).toMatchObject({
+      only: ['future-provider'],
+      order: ['another-future-provider'],
+    });
+  });
 });
 
 describe('applyVercelSettings BYOK pinning', () => {
@@ -167,6 +215,14 @@ describe('applyVercelSettings BYOK pinning', () => {
     secretAccessKey: 'secret',
     region: 'us-east-1',
   });
+  const vertexCredentials = JSON.stringify({
+    project: 'example-project',
+    location: 'us-east5',
+    googleCredentials: {
+      privateKey: '-----BEGIN PRIVATE KEY-----\nsecret\n-----END PRIVATE KEY-----\n',
+      clientEmail: 'gateway@example-project.iam.gserviceaccount.com',
+    },
+  });
 
   it('drops a BYOK provider the caller ignored when another serving provider remains', async () => {
     const request = byokRequest(['anthropic']);
@@ -211,6 +267,38 @@ describe('applyVercelSettings BYOK pinning', () => {
     });
   });
 
+  it('uses one Vertex credential key for Anthropic models served by Vertex', async () => {
+    const request = byokRequest([]);
+
+    await applyVercelSettings('anthropic/claude-sonnet-4.5', request, [
+      { decryptedAPIKey: vertexCredentials, providerId: 'vertex' },
+    ]);
+
+    expect(request.body.providerOptions?.gateway?.byok).toEqual({
+      vertex: [
+        {
+          project: 'example-project',
+          location: 'us-east5',
+          googleCredentials: {
+            privateKey: '-----BEGIN PRIVATE KEY-----\nsecret\n-----END PRIVATE KEY-----\n',
+            clientEmail: 'gateway@example-project.iam.gserviceaccount.com',
+          },
+        },
+      ],
+    });
+    expect(request.body.providerOptions?.gateway?.only).toEqual(['vertex']);
+  });
+
+  it('rejects malformed Vertex credentials without including credential contents', async () => {
+    const request = byokRequest([]);
+
+    await expect(
+      applyVercelSettings('google/gemini-2.5-flash-lite', request, [
+        { decryptedAPIKey: '{"privateKey":"secret"}', providerId: 'vertex' },
+      ])
+    ).rejects.toThrow('Failed to parse Google Vertex credentials');
+  });
+
   it('does not add managed OpenAI credentials to user BYOK settings', async () => {
     process.env.OPENAI_API_KEY = 'openai-managed-key';
     const request = byokRequest([]);
diff --git a/apps/web/src/lib/ai-gateway/providers/vercel/index.ts b/apps/web/src/lib/ai-gateway/providers/vercel/index.ts
index 245968c286..3ef039f3f2 100644
--- a/apps/web/src/lib/ai-gateway/providers/vercel/index.ts
+++ b/apps/web/src/lib/ai-gateway/providers/vercel/index.ts
@@ -3,7 +3,9 @@ import type { VercelUserByokInferenceProviderId } from '@/lib/ai-gateway/provide
 import {
   DirectUserByokInferenceProviderIdSchema,
   AwsCredentialsSchema,
+  normalizeVercelInferenceProviderIdForRouting,
   openRouterToVercelInferenceProviderId,
+  VertexCredentialsSchema,
   VercelUserByokInferenceProviderIdSchema,
 } from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
 import type {
@@ -31,9 +33,12 @@ export function hasCompatibleVercelInferenceProvider(
     return true;
   }
 
-  return openRouterInferenceProviders.some(provider =>
-    vercelInferenceProviders.includes(openRouterToVercelInferenceProviderId(provider))
-  );
+  return openRouterInferenceProviders.some(provider => {
+    const vercelProviderId = openRouterToVercelInferenceProviderId(provider);
+    return vercelInferenceProviders
+      .map(providerId => normalizeVercelInferenceProviderIdForRouting(providerId))
+      .includes(vercelProviderId);
+  });
 }
 
 export function getVercelInferenceProvidersExcludingIgnored(
@@ -46,9 +51,13 @@ export function getVercelInferenceProvidersExcludingIgnored(
     ? new Set(onlyProviders.map(openRouterToVercelInferenceProviderId))
     : null;
 
-  return vercelInferenceProviders.filter(
-    provider => !ignored.has(provider) && (!only || only.has(provider))
-  );
+  return [
+    ...new Set(
+      vercelInferenceProviders
+        .map(providerId => normalizeVercelInferenceProviderIdForRouting(providerId))
+        .filter(provider => !ignored.has(provider) && (!only || only.has(provider)))
+    ),
+  ];
 }
 
 export function passesVercelRoutingPercentage(randomSeed: string, routingPercentage: number) {
@@ -146,7 +155,7 @@ export function convertProviderOptions(
   return {
     gateway: {
       only,
-      order: provider?.order?.map(p => openRouterToVercelInferenceProviderId(p)),
+      order: provider?.order?.map(openRouterToVercelInferenceProviderId),
       zeroDataRetention: provider?.zdr,
       disallowPromptTraining: provider?.data_collection === 'deny' || undefined,
       models: requestToMutate.body.models,
@@ -162,6 +171,14 @@ function parseAwsCredentials(input: string) {
   }
 }
 
+function parseVertexCredentials(input: string) {
+  try {
+    return VertexCredentialsSchema.parse(JSON.parse(input));
+  } catch {
+    throw new Error('Failed to parse Google Vertex credentials');
+  }
+}
+
 export function getAnthropicProviderOptionsForVercel(
   request: GatewayRequest
 ): AnthropicProviderOptions | undefined {
@@ -203,6 +220,8 @@ export function getVercelInferenceProviderConfigForUserByok(
 
   if (key === VercelUserByokInferenceProviderIdSchema.enum.bedrock) {
     list.push(parseAwsCredentials(provider.decryptedAPIKey));
+  } else if (key === VercelUserByokInferenceProviderIdSchema.enum.vertex) {
+    list.push(parseVertexCredentials(provider.decryptedAPIKey));
   } else {
     list.push({ apiKey: provider.decryptedAPIKey });
   }
@@ -248,8 +267,7 @@ export async function applyVercelSettings(
     const byokProviders =
       Object.keys(retainedByokProviders).length > 0 ? retainedByokProviders : allByokProviders;
 
-    // this is vercel specific BYOK configuration to force vercel gateway to use the BYOK API key
-    // for the user/org. If the key is invalid the request will faill - it will not fall back to bill our API key.
+    // Pass request-scoped credentials and restrict routing to the corresponding providers.
     requestToMutate.body.providerOptions = {
       gateway: {
         only: Object.keys(byokProviders),
diff --git a/apps/web/src/routers/byok-router.test.ts b/apps/web/src/routers/byok-router.test.ts
index 54cdc57469..43a50f62f0 100644
--- a/apps/web/src/routers/byok-router.test.ts
+++ b/apps/web/src/routers/byok-router.test.ts
@@ -15,6 +15,15 @@ import type { User, Organization } from '@kilocode/db/schema';
 import { encryptApiKey } from '@/lib/ai-gateway/byok/encryption';
 import { BYOK_ENCRYPTION_KEY } from '@/lib/config.server';
 
+const VERTEX_CREDENTIALS = JSON.stringify({
+  project: 'example-project',
+  location: 'us-east5',
+  googleCredentials: {
+    privateKey: '-----BEGIN PRIVATE KEY-----\nsecret\n-----END PRIVATE KEY-----\n',
+    clientEmail: 'gateway@example-project.iam.gserviceaccount.com',
+  },
+});
+
 describe('BYOK Router', () => {
   let ownerUser: User;
   let memberUser: User;
@@ -171,6 +180,30 @@ describe('BYOK Router', () => {
       expect(dbKey.encrypted_api_key).toHaveProperty('authTag');
     });
 
+    test('should create a Vertex BYOK credential', async () => {
+      const caller = await createCallerForUser(ownerUser.id);
+
+      const result = await caller.byok.create({
+        organizationId: organizationA.id,
+        provider_id: 'vertex',
+        api_key: VERTEX_CREDENTIALS,
+      });
+
+      expect(result.provider_id).toBe('vertex');
+    });
+
+    test('should reject malformed Vertex credentials', async () => {
+      const caller = await createCallerForUser(ownerUser.id);
+
+      await expect(
+        caller.byok.create({
+          organizationId: organizationA.id,
+          provider_id: 'vertex',
+          api_key: '{"privateKey":"secret"}',
+        })
+      ).rejects.toThrow('Invalid credentials for provider: vertex');
+    });
+
     test('should create audit log entry', async () => {
       const caller = await createCallerForUser(ownerUser.id);
 
@@ -277,6 +310,23 @@ describe('BYOK Router', () => {
       expect(dbKey.encrypted_api_key).toHaveProperty('data');
     });
 
+    test('should reject malformed Vertex credentials on update', async () => {
+      const caller = await createCallerForUser(ownerUser.id);
+      const created = await caller.byok.create({
+        organizationId: organizationA.id,
+        provider_id: 'vertex',
+        api_key: VERTEX_CREDENTIALS,
+      });
+
+      await expect(
+        caller.byok.update({
+          organizationId: organizationA.id,
+          id: created.id,
+          api_key: '{}',
+        })
+      ).rejects.toThrow('Invalid credentials for provider: vertex');
+    });
+
     test('should create audit log entry for update', async () => {
       const caller = await createCallerForUser(ownerUser.id);
 
diff --git a/apps/web/src/routers/byok-router.ts b/apps/web/src/routers/byok-router.ts
index ee2706ff3c..c3294fb7da 100644
--- a/apps/web/src/routers/byok-router.ts
+++ b/apps/web/src/routers/byok-router.ts
@@ -23,6 +23,7 @@ import {
 import {
   UserByokProviderIdSchema,
   UserByokTestModels,
+  getVercelUserByokProviderIdForEndpoint,
   VercelUserByokInferenceProviderIdSchema,
 } from '@/lib/ai-gateway/providers/openrouter/inference-provider-id';
 import {
@@ -47,6 +48,23 @@ const MANAGED_KEY_READ_ONLY_MESSAGE =
   'This key is managed by your coding plan and is read-only. Cancel the coding plan to remove it.';
 const logByokWarning = sentryLogger('byok-key-test', 'warning');
 
+function validateVercelUserByokCredential(providerId: string, credential: string) {
+  const parsedProviderId = VercelUserByokInferenceProviderIdSchema.safeParse(providerId);
+  if (!parsedProviderId.success) return;
+
+  try {
+    getVercelInferenceProviderConfigForUserByok({
+      providerId: parsedProviderId.data,
+      decryptedAPIKey: credential,
+    });
+  } catch {
+    throw new TRPCError({
+      code: 'BAD_REQUEST',
+      message: `Invalid credentials for provider: ${providerId}`,
+    });
+  }
+}
+
 function rejectManagedKeyMutation(managementSource: 'user' | 'coding_plan') {
   if (managementSource === 'coding_plan') {
     throw new TRPCError({
@@ -86,11 +104,10 @@ async function fetchSupportedModels(): Promise<Record<string, string[]>> {
     if (!vercelModel) continue;
     if (vercelModel.type !== 'language') continue;
     for (const endpoint of vercelModel.endpoints) {
-      const providerParsed = VercelUserByokInferenceProviderIdSchema.safeParse(
+      const providerId = getVercelUserByokProviderIdForEndpoint(
         endpoint.provider_name ?? endpoint.tag
       );
-      if (!providerParsed.success) continue;
-      const providerId = providerParsed.data;
+      if (!providerId) continue;
       if (!result[providerId]) result[providerId] = [];
       result[providerId].push(openRouterModel.name + ' (' + openRouterModel.id + ')');
     }
@@ -161,6 +178,8 @@ export const byokRouter = createTRPCRouter({
         await ensureOrganizationAccess(ctx, organizationId, ORGANIZATION_BILLING_ROLES);
       }
 
+      validateVercelUserByokCredential(provider_id, api_key);
+
       // Encrypt the API key
       const encrypted = encryptApiKey(api_key, BYOK_ENCRYPTION_KEY);
 
@@ -249,6 +268,7 @@ export const byokRouter = createTRPCRouter({
       }
 
       rejectManagedKeyMutation(existingKey.management_source);
+      validateVercelUserByokCredential(existingKey.provider_id, api_key);
 
       const encrypted = encryptApiKey(api_key, BYOK_ENCRYPTION_KEY);
       const [updatedKey] = await db