Integration & Deployment

How to deploy your application to use Ingate. No infrastructure to manage. Just point your app at api.ingateai.com.

Overview

Ingate is fully managed cloud infrastructure. There is nothing to deploy, no containers to run, no databases to provision. Your only job is to point your application at the Ingate API endpoint.

bash
# This is the only URL you need
https://api.ingateai.com

Every request you send to api.ingateai.com is routed through Ingate's global infrastructure. Logging, budgets, guardrails, caching, and provider routing are handled automatically based on your organization's configuration. You write application code. Ingate handles everything between your app and the LLM providers.

No self-hosting

Ingate is cloud-only. There is no Docker image, no Helm chart, no self-hosted option. This page covers how to deploy your application to use Ingate, not how to deploy Ingate itself.

Environment Setup

Set your Ingate API key as an environment variable in whatever platform runs your application. The key authenticates every request to the Ingate proxy.

Vercel

Add the key in Project Settings → Environment Variables, or via the CLI:

bash
# Vercel CLI
vercel env add INGATE_API_KEY production
# Paste: sk-ingate-your-key-here

# Or set in vercel.json
# (Not recommended for secrets, use the dashboard or CLI instead)

AWS Lambda

Set the variable in your function configuration or SAM/CDK template:

bash
# AWS CLI
aws lambda update-function-configuration \
  --function-name my-function \
  --environment "Variables={INGATE_API_KEY=sk-ingate-your-key-here}"
yamltemplate.yaml (SAM)
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Environment:
        Variables:
          INGATE_API_KEY: !Ref IngateApiKeyParam

Docker

Pass the key at runtime. Never bake secrets into images:

bash
docker run -e INGATE_API_KEY=sk-ingate-your-key-here my-app

Railway / Render

Both platforms have a Variables section in the service dashboard. Add INGATE_API_KEY there. It's injected at runtime and encrypted at rest.

One key per environment

Create separate Ingate API keys for development, staging, and production. This gives you independent budgets, audit trails, and the ability to revoke a single environment without affecting others.

SDK Configuration

Point your existing OpenAI or Anthropic SDK at Ingate by changing the base URL. No proprietary SDK required. Ingate is a drop-in proxy.

Python

pythonapp.py
import openai

client = openai.OpenAI(
    base_url="https://api.ingateai.com/v1",
    api_key="sk-ingate-your-key-here",  # or os.environ["INGATE_API_KEY"]
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello from Ingate"}],
)
print(response.choices[0].message.content)
pythonanthropic_example.py
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.ingateai.com",
    api_key="sk-ingate-your-key-here",
)

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello from Ingate"}],
)
print(message.content[0].text)

TypeScript

tsapp.ts
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.ingateai.com/v1",
  apiKey: process.env.INGATE_API_KEY,
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello from Ingate" }],
});
console.log(response.choices[0].message.content);
tsanthropic_example.ts
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://api.ingateai.com",
  apiKey: process.env.INGATE_API_KEY,
});

const message = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello from Ingate" }],
});
console.log(message.content[0].text);

Provider auto-detection

Ingate detects the provider from the request path. /v1/chat/completions routes to OpenAI, /v1/messages routes to Anthropic. No extra headers needed.

Coding Agent Setup

Route your AI coding tools through Ingate by setting environment variables. Ingate auto-detects the provider from the request path, so you only need to change the base URL with no extra headers or configuration required.

Claude Code

bash
# Set in your shell profile (.bashrc, .zshrc, etc.)
export ANTHROPIC_BASE_URL=https://api.ingateai.com
export ANTHROPIC_API_KEY=sk-ingate-your-key-here

# Then launch Claude Code as normal
claude

Cursor

In Cursor settings, configure the API endpoint for your model provider:

bash
# For OpenAI models in Cursor
OPENAI_BASE_URL=https://api.ingateai.com
OPENAI_API_KEY=sk-ingate-your-key-here

# For Anthropic models in Cursor
ANTHROPIC_BASE_URL=https://api.ingateai.com
ANTHROPIC_API_KEY=sk-ingate-your-key-here

Aider

bash
# Route Aider through Ingate
export OPENAI_API_BASE=https://api.ingateai.com/v1
export OPENAI_API_KEY=sk-ingate-your-key-here

aider --model gpt-4o

Pi / GSD

bash
# Set in your shell profile
export ANTHROPIC_BASE_URL=https://api.ingateai.com
export ANTHROPIC_API_KEY=sk-ingate-your-key-here

# Pi picks up the env vars automatically
pi

Auth passthrough mode

For subscription tools that manage their own API keys, Ingate supports auth passthrough. The tool's existing API key is forwarded to the provider, while Ingate still applies logging, budgets, and guardrails. Set X-Ingate-Key alongside the tool's native auth header to enable this.

Health & Status

Monitor Ingate availability from your application or infrastructure monitoring.

Health Endpoint

bash
# Returns 200 when healthy, 503 when degraded
curl https://api.ingateai.com/healthz
jsonResponse (healthy)
{
  "status": "ok",
  "timestamp": "2026-04-04T11:15:00Z"
}

Use this endpoint in your deployment health checks to verify Ingate connectivity before your application starts accepting traffic:

bash
# Startup check in your entrypoint script
until curl -sf https://api.ingateai.com/healthz > /dev/null; do
  echo "Waiting for Ingate..."
  sleep 2
done
echo "Ingate is reachable. Starting app."
exec node server.js

Status Page

Real-time uptime, incident history, and scheduled maintenance are published at:

bash
https://status.ingateai.com

Subscribe to the status page for email or webhook notifications on incidents and maintenance windows.

SLA & Infrastructure

PlanUptime SLASupportInfrastructure
FreeBest effortCommunityShared, single region
Enterprise99.9%Dedicated support + Slack channelMulti-region, automatic failover

Enterprise infrastructure runs across multiple regions with automatic failover. Requests are routed to the nearest healthy region. If a region goes down, traffic shifts to the next-closest region with no action required on your part.

Enterprise SLA

The 99.9% uptime SLA covers the Ingate proxy layer. Downstream provider outages (OpenAI, Anthropic, etc.) are excluded. Ingate's automatic failover and retry logic mitigates many provider-side issues transparently.

Migration from Direct API Calls

Switching from direct provider API calls to Ingate takes minutes. Here's the checklist:

Migration Checklist

  1. Create an Ingate account. sign up at api.ingateai.com and note your API key
  2. Change the base URL. point your SDK or HTTP client at https://api.ingateai.com instead of the provider's URL
  3. Swap the API key. replace your provider API key with your Ingate key (or use auth passthrough to keep both)
  4. Remove provider-specific headers. Ingate detects the provider from the request path, so X-Ingate-Provider is optional for standard OpenAI and Anthropic paths
  5. Test in staging. verify that requests succeed and responses match your expected format
  6. Deploy to production. roll out the base URL and key change
  7. Verify in the Ingate dashboard. confirm requests appear in the audit log with correct provider routing

Before & After

pythonbefore.py
# BEFORE: Direct OpenAI call
import openai

client = openai.OpenAI(
    api_key="sk-openai-your-key",
    # Uses default base_url: https://api.openai.com/v1
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)
pythonafter.py
# AFTER: Through Ingate (two lines changed)
import openai

client = openai.OpenAI(
    api_key="sk-ingate-your-key-here",            # Changed
    base_url="https://api.ingateai.com/v1",        # Added
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)
# Response format is identical, no code changes needed downstream

Zero response format changes

Ingate proxies responses exactly as the provider returns them. Your existing response parsing, streaming handlers, and error handling all work without modification.

Auth Passthrough (Gradual Migration)

If you want to keep using your own provider API key while gaining Ingate's logging and guardrails, use auth passthrough. Send both your provider key and your Ingate key:

bash
curl https://api.ingateai.com/v1/chat/completions \
  -H "Authorization: Bearer sk-openai-your-provider-key" \
  -H "X-Ingate-Key: sk-ingate-your-key-here" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "Hello"}]}'

In passthrough mode, Ingate forwards your provider key to the upstream API while still applying your organization's budgets, guardrails, and audit logging. This lets you migrate incrementally. Start with observability, then optionally switch to Ingate-managed provider keys later.

Previous
Configuration