Ai Gateway

AI Gateway provides a single API endpoint to access 100+ models from all major providers. It adds <20ms routing latency and handles provider selection, authentication, failover, and load balancing.

Packages

• ai@^6.0.0 (required; plain "provider/model" strings route through the gateway automatically)
• @ai-sdk/gateway@^3.0.0 (optional direct install for explicit gateway package usage)

Setup

Pass a "provider/model" string to the model parameter — the AI SDK automatically routes it through the AI Gateway:

import { generateText } from 'ai'

const result = await generateText({
  model: 'openai/gpt-5.4', // plain string — routes through AI Gateway automatically
  prompt: 'Hello!',
})

No gateway() wrapper or additional package needed. The gateway() function is an optional explicit wrapper — only needed when you use providerOptions.gateway for routing, failover, or tags:

import { gateway } from 'ai'

const result = await generateText({
  model: gateway('openai/gpt-5.4'),
  providerOptions: { gateway: { order: ['openai', 'azure-openai'] } },
})

Model Slug Rules (Critical)

• Always use provider/model format (for example openai/gpt-5.4).
• Versioned slugs use dots for versions, not hyphens:
  • Correct: anthropic/claude-sonnet-4.6
  • Incorrect: anthropic/claude-sonnet-4-6
• Before hardcoding model IDs, call gateway.getAvailableModels() and pick from the returned IDs.
• Default text models: openai/gpt-5.4 or anthropic/claude-sonnet-4.6.
• Do not default to outdated choices like openai/gpt-4o.

import { gateway } from 'ai'

const availableModels = await gateway.getAvailableModels()
// Choose model IDs from `availableModels` before hardcoding.

Authentication (OIDC — Default)

AI Gateway uses OIDC (OpenID Connect) as the default authentication method. No manual API keys needed.

Setup

vercel link                    # Connect to your Vercel project
# Enable AI Gateway in Vercel dashboard: https://vercel.com/{team}/{project}/settings → AI Gateway
vercel env pull .env.local     # Provisions VERCEL_OIDC_TOKEN automatically

How It Works

1. vercel env pull writes a VERCEL_OIDC_TOKEN to .env.local — a short-lived JWT (~24h)
2. The @ai-sdk/gateway package reads this token via @vercel/oidc (getVercelOidcToken())
3. No AI_GATEWAY_API_KEY or provider-specific keys (like ANTHROPIC_API_KEY) are needed
4. On Vercel deployments, OIDC tokens are auto-refreshed — zero maintenance

Local Development

For local dev, the OIDC token from vercel env pull is valid for ~24 hours. When it expires:

vercel env pull .env.local --yes   # Re-pull to get a fresh token

Alternative: Manual API Key

If you prefer a static key (e.g., for CI or non-Vercel environments):

# Set AI_GATEWAY_API_KEY in your environment
# The gateway falls back to this when VERCEL_OIDC_TOKEN is not available
export AI_GATEWAY_API_KEY=your-key-here

Auth Priority

The @ai-sdk/gateway package resolves authentication in this order:

1. AI_GATEWAY_API_KEY environment variable (if set)
2. VERCEL_OIDC_TOKEN via @vercel/oidc (default on Vercel and after vercel env pull)

Provider Routing

Configure how AI Gateway routes requests across providers:

const result = await generateText({
  model: gateway('anthropic/claude-sonnet-4.6'),
  prompt: 'Hello!',
  providerOptions: {
    gateway: {
      // Try providers in order; failover to next on error
      order: ['bedrock', 'anthropic'],

      // Restrict to specific providers only
      only: ['anthropic', 'vertex'],

      // Fallback models if primary model fails
      models: ['openai/gpt-5.4', 'google/gemini-3-flash'],

      // Track usage per end-user
      user: 'user-123',

      // Tag for cost attribution and filtering
      tags: ['feature:chat', 'env:production', 'team:growth'],
    },
  },
})

Routing Options

Cache-Control Headers

AI Gateway supports response caching to reduce latency and cost for repeated or similar requests:

const result = await generateText({
  model: gateway('openai/gpt-5.4'),
  prompt: 'What is the capital of France?',
  providerOptions: {
    gateway: {
      // Cache identical requests for 1 hour
      cacheControl: 'max-age=3600',
    },
  },
})

Caching strategies

When to use caching

• Static knowledge queries: FAQs, translations, factual lookups — cache aggressively
• User-specific conversations: Do not cache — each response depends on conversation history
• Embeddings: Cache embedding results for identical inputs to save cost
• Structured extraction: Cache when extracting structured data from identical documents

Cache key composition

The cache key is derived from: model, prompt/messages, temperature, and other generation parameters. Changing any parameter produces a new cache key.

Per-User Rate Limiting

Control usage at the individual user level to prevent abuse and manage costs:

const result = await generateText({
  model: gateway('openai/gpt-5.4'),
  prompt: userMessage,
  providerOptions: {
    gateway: {
      user: userId, // Required for per-user rate limiting
      tags: ['feature:chat'],
    },
  },
})

Rate limit configuration

Configure rate limits at https://vercel.com/{team}/{project}/settings → AI Gateway → Rate Limits:

• Requests per minute per user: Throttle individual users (e.g., 20 RPM)
• Tokens per day per user: Cap daily token consumption (e.g., 100K tokens/day)
• Concurrent requests per user: Limit parallel calls (e.g., 3 concurrent)

Handling rate limit responses

When a user exceeds their limit, the gateway returns HTTP 429:

import { generateText, APICallError } from 'ai'

try {
  const result = await generateText({
    model: gateway('openai/gpt-5.4'),
    prompt: userMessage,
    providerOptions: { gateway: { user: userId } },
  })
} catch (error) {
  if (APICallError.isInstance(error) && error.statusCode === 429) {
    const retryAfter = error.responseHeaders?.['retry-after']
    return new Response(
      JSON.stringify({ error: 'Rate limited', retryAfter }),
      { status: 429 }
    )
  }
  throw error
}

Budget Alerts and Cost Controls

Tagging for cost attribution

Use tags to track spend by feature, team, and environment:

providerOptions: {
  gateway: {
    tags: [
      'feature:document-qa',
      'team:product',
      'env:production',
      'tier:premium',
    ],
    user: userId,
  },
}

Setting up budget alerts

In the Vercel dashboard at https://vercel.com/{team}/{project}/settings → AI Gateway:

1. Navigate to AI Gateway → Usage & Budgets
2. Set monthly budget thresholds (e.g., $500/month warning, $1000/month hard limit)
3. Configure alert channels (email, Slack webhook, Vercel integration)
4. Optionally set per-tag budgets for granular control

Budget isolation best practice

Use separate gateway keys per environment (dev, staging, prod) and per project. This keeps dashboards clean and budgets isolated:

• Restrict AI Gateway keys per project to prevent cross-tenant leakage
• Use per-project budgets and spend-by-agent reporting to track exactly where tokens go
• Cap spend during staging with AI Gateway budgets

Pre-flight cost controls

The AI Gateway dashboard provides observability (traces, token counts, spend tracking) but no programmatic metrics API. Build your own cost guardrails by estimating token counts and rejecting expensive requests before they execute:

import { generateText } from 'ai'

function estimateTokens(text: string): number {
  return Math.ceil(text.length / 4) // rough estimate
}

async function callWithBudget(prompt: string, maxTokens: number) {
  const estimated = estimateTokens(prompt)
  if (estimated > maxTokens) {
    throw new Error(`Prompt too large: ~${estimated} tokens exceeds ${maxTokens} limit`)
  }
  return generateText({ model: 'openai/gpt-5.4', prompt })
}

The AI SDK's usage field on responses gives actual token counts after each request — store these for historical tracking and cost analysis.

Hard spending limits

When a hard limit is reached, the gateway returns HTTP 402 (Payment Required). Handle this gracefully:

if (APICallError.isInstance(error) && error.statusCode === 402) {
  // Budget exceeded — degrade gracefully
  return fallbackResponse()
}

Cost optimization patterns

• Use cheaper models for classification/routing, expensive models for generation
• Cache embeddings and static queries (see Cache-Control above)
• Set per-user daily token caps to prevent runaway usage
• Monitor cost-per-feature with tags to identify optimization targets

Audit Logging

AI Gateway logs every request for compliance and debugging:

What's logged

• Timestamp, model, provider used
• Input/output token counts
• Latency (routing + provider)
• User ID and tags
• HTTP status code
• Failover chain (which providers were tried)

Accessing logs

• Vercel Dashboard at https://vercel.com/{team}/{project}/ai → Logs — filter by model, user, tag, status, date range
• Vercel API: Query logs programmatically:

curl -H "Authorization: Bearer $VERCEL_TOKEN" \
  "https://api.vercel.com/v1/ai-gateway/logs?projectId=$PROJECT_ID&limit=100"

• Log Drains: Forward AI Gateway logs to Datadog, Splunk, or other providers via Vercel Log Drains (configure at https://vercel.com/dashboard/{team}/~/settings/log-drains) for long-term retention and custom analysis

Compliance considerations

• AI Gateway does not log prompt or completion content by default
• Enable content logging in project settings if required for compliance
• Logs are retained per your Vercel plan's retention policy
• Use user field consistently to support audit trails

Error Handling Patterns

Provider unavailable

When a provider is down, the gateway automatically fails over if you configured order or models:

const result = await generateText({
  model: gateway('anthropic/claude-sonnet-4.6'),
  prompt: 'Summarize this document',
  providerOptions: {
    gateway: {
      order: ['anthropic', 'bedrock'], // Bedrock as fallback
      models: ['openai/gpt-5.4'],   // Final fallback model
    },
  },
})

Quota exceeded at provider

If your provider API key hits its quota, the gateway tries the next provider in the order list. Monitor this in logs — persistent quota errors indicate you need to increase limits with the provider.

Invalid model identifier

// Bad — model doesn't exist