AI Gateway Overview

Use popular AI models in your code, without needing to manage API keys or external accounts.

The AI Gateway service simplifies technical and operational concerns when using AI inference in your code, by removing the need to:

• Open an account with each provider you want to use.
• Maintain a separate credit balance with each provider.
• Copy the API key from each provider to your projects on Netlify.

By default, Netlify automatically sets the appropriate environment variables that AI client libraries typically use for configuration, in all Netlify compute contexts (e.g., Netlify Functions, Edge Functions, Preview Server, etc.).

These variables include:

• API keys for OpenAI, Anthropic, and Google Gemini.
• A custom base URL for each provider, to route requests via the AI Gateway service.

These variables are picked up by the official client libraries of these providers, so no extra configuration is necessary. Alternatively, if you make AI calls via a provider’s REST API, these values are easy to incorporate in your code.

When receiving a request from a client, the AI Gateway makes the call to the AI provider on your behalf. Then, it bills your Netlify account by converting the actual token usage in the request into credits, using your existing credit quota.

The AI Gateway does not store your prompts or model outputs. Learn more about Security and Privacy for AI features.

To opt-out of the AI Gateway, see Using the AI Gateway below.

When you develop server-side code with any web framework supported by Netlify (e.g., Astro; Tanstack Start; Next.js, Gatsby, Nuxt, etc.), your code is packaged in Netlify Functions and Edge Functions under the hood, as part of the build process.

Therefore, the above environment variables are available as when explicitly using Netlify compute primitives, without any further settings required.

For a quickstart, check out our Quickstart for AI Gateway.

The AI Gateway is available by default in all credit-based plans, unless:

1. You have disabled Netlify AI Features for your team, or:
2. You have set your own API keys for AI providers via environment variables. Netlify does not override these keys. You can add or remove your own keys at any point.

For full information on which environment variables are automatically set, and how to control this behavior, see here.

If you’re using any of the following libraries, no configuration is required:

1. OpenAI TypeScript and JavaScript API Library
2. Anthropic TypeScript API Library (for Claude models)
3. Google Gen AI SDK for TypeScript and JavaScript (for Google Gemini models)

async function callAnthropic() {
  const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
  const ANTHROPIC_BASE_URL = process.env.ANTHROPIC_BASE_URL;

  const response = await fetch(`${ANTHROPIC_BASE_URL}/v1/messages`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': ANTHROPIC_API_KEY,
      'anthropic-version': '2023-06-01',
      'user-agent': 'anthropic/' // Required temporarily
    },
    body: JSON.stringify({
      model: 'claude-sonnet-4-5-20250929',
      max_tokens: 1024,
      messages: [{ role: 'user', content: 'Hello!' }]
    })
  });
  return await response.json();
}

async function callOpenAI() {
  const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
  const OPENAI_BASE_URL = process.env.OPENAI_BASE_URL;

  const response = await fetch(`${OPENAI_BASE_URL}/v1/chat/completions`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${OPENAI_API_KEY}`
    },
    body: JSON.stringify({
      model: 'gpt-5',
      messages: [{ role: 'user', content: 'Hello!' }]
    })
  });
  return await response.json();
}

async function callGemini() {
  const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
  const GEMINI_BASE_URL = process.env.GOOGLE_GEMINI_BASE_URL;

  const response = await fetch(
    `${GEMINI_BASE_URL}/v1beta/models/gemini-2.5-pro:generateContent`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-goog-api-key': GEMINI_API_KEY,
        'user-agent': 'google-genai-sdk/' // Required temporarily
      },
      body: JSON.stringify({
        contents: [{
          parts: [{ text: 'Hello!' }]
        }]
      })
    }
  );
  return await response.json();
}

If you are using a client library that does not work out-of-the-box with the environment variables set for the AI Gateway, you need to manually pass the API key and base URL as arguments to the library.

This is similar to manually reading & passing variable values when using a provider’s REST API. See Using official REST APIs above for the relevant variable names.

If you have already set an API key or base URL at the project or team level, Netlify will never override it.

When a Netlify Function or Edge Function is initialized, the following environment variables are set to the appropriate values for the AI Gateway:

1. OPENAI_API_KEY and OPENAI_BASE_URL - unless any of these is already set by you at the project or team level.
2. ANTHROPIC_API_KEY and ANTHROPIC_BASE_URL - unless any of these is already set by you.
3. GEMINI_API_KEY and GOOGLE_GEMINI_BASE_URL- unless any of these is already set by you, or if either GOOGLE_API_KEY or GOOGLE_VERTEX_BASE_URL are set.

For each provider, the above check is done separately. Meaning, if you have only set OPENAI_API_KEY to your own API key, it will not be overridden (and neither would OPENAI_BASE_URL be set) - but the values for Anthropic and Google will be set.

AI_GATEWAY_API_KEY and AI_GATEWAY_BASE_URL environment variables are always injected into the AI Gateway-supported runtimes. If you want to mix different setups with your own keys and Netlify’s or you want to be explicit about using AI Gateway keys in your calls, use these env variables as they will never collide with other environment variables values.

To prevent any variables from being automatically set, you can disable AI Features.

The AI Gateway supports the following AI providers and models.

To understand pricing for AI Gateway, check out our Pricing for AI features docs.

The AI Gateway has two types of limits: Requests Per Minute (RPM) and Tokens Per Minute (TPM). Limits are per model and differ by your account plan.

The rate limit is scoped to your account. Meaning, requests made and tokens used for any project in your account are counted together towards your limits.

Enterprise customers have extended limits - contact your Account Manager to learn more.

For TPM, both input and output tokens are counted towards the limit.

However, cached input tokens are excluded for Anthropic models, and included for other providers.

The AI Gateway has the following limitations at this time:

1. Built-in tool usage (a.k.a server tools - tools that the provider manages and runs on their server, such as web search) is not currently supported.
   • Note: custom tools (a.k.a. client tools), which you run in your own code, are supported.
2. The context window (input prompt) is limited to 200k tokens.
3. Prompt caching:
   • Anthropic Claude: only the default 5-minute ephemeral cache duration is supported for Claude.
   • OpenAI: the AI Gateway sets a per-account prompt_cache_key.
   • Google Gemini: explicit context caching is not supported.
4. The AI Gateway does not pass through any request headers (and thus you cannot enable proprietary experimental features via headers).
5. Batch inference is not supported.
6. Priority processing (an OpenAI feature) is not supported.