air proxy — Multi-provider AI Gateway

Key features: high availability with resilient request handling, per-model pricing with token-level billing, streaming with SSE, tool/function calling, thinking/reasoning support, and a growing catalog of models. All models are prepaid — top up a balance to use them; see GET /v1/models for the live catalog and pricing.

Base URL (OpenAI-compatible): https://airpx.cc/v1 — Base URL (Anthropic-compatible): https://airpx.cc

No card, no invite — get started in about a minute: 1. Sign up at https://airpx.cc/signup with email + password. 2. Create an API key in the dashboard at https://airpx.cc/keys (keys start with sk-proxy-*). 3. Top up your prepaid balance at https://airpx.cc/billing — a balance is required before your first call (there is no free tier). 4. Set your base URL to https://airpx.cc/v1 (OpenAI) or https://airpx.cc (Anthropic) and send your first request:

curl https://airpx.cc/v1/chat/completions \
  -H "x-api-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

That's it. `gpt-5.4-mini` is just an example — see GET /v1/models for the full catalog and live pricing. Every request deducts from your prepaid balance; check or top up your balance at https://airpx.cc/billing.

Pass your proxy key (starts with sk-proxy-*) in either header: • x-api-key: YOUR_KEY • Authorization: Bearer YOUR_KEY Both headers are interchangeable. Use whichever your tool or SDK supports.

Important: proxy keys (sk-proxy-*) are used for /v1/* endpoints only. They are NOT the same as dashboard login tokens.

curl https://airpx.cc/v1/chat/completions \
  -H "x-api-key: sk-proxy-abc123" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-5.4-mini", "messages": [{"role": "user", "content": "Hi"}]}'

The complete, always-current API reference is generated from the server itself — every endpoint, request/response schema, and parameter. Use the interactive Swagger UI to explore and try requests, or the raw OpenAPI spec to generate clients. These are the single source of truth; the list below is just a quick orientation.

Which endpoint should my client use? Pick by wire format — but note that ANY model works through ANY wire, because the gateway bridges between them:

• Anthropic /v1/messages — Claude Code and Anthropic SDKs.
• OpenAI /v1/chat/completions — aider, Cursor, Cline, Goose, most OpenAI-compatible tools.
• OpenAI /v1/responses — Codex CLI and other Responses-API clients.
• Gemini /v1beta/models/{model}:generateContent — Gemini CLI and native-Gemini clients.

This is the key differentiator: send a request in whatever wire your client speaks and reach any model in the catalog. Run Claude or GPT inside Gemini CLI, native Gemini inside Codex, or DeepSeek inside Claude Code — thinking, tools and streaming are translated across formats. Few gateways offer all four ingress protocols at once (Anthropic Messages + OpenAI chat + OpenAI Responses + native Gemini generateContent).

Main endpoints (see /v1/docs for full request/response schemas):

All endpoints accept JSON request bodies and return JSON responses. For streaming, set "stream": true and receive Server-Sent Events (SSE). See /v1/docs for the authoritative parameters and schemas.

Tool / function calling works on every model through every wire. Send OpenAI-style `tools` on /v1/chat/completions, or Anthropic `tools` with tool_use / tool_result blocks on /v1/messages — the gateway translates tool schemas and calls between formats, so tools work even when the model's native wire differs from your client's.

{
  "model": "gpt-5.5",
  "messages": [{"role": "user", "content": "Weather in Paris?"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Get current weather for a city",
      "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]
      }
    }
  }]
}

Coding tools (IDE / CLI) — add airpx as an OpenAI- or Anthropic-compatible backend, then use any public model id (e.g. claude-opus-4-8, claude-sonnet-4-6, gpt-5.5, gemini-3.5-flash, deepseek-v4-pro). Any model works in any agent regardless of the agent's wire format — the gateway bridges across Anthropic /v1/messages (Claude Code), OpenAI /v1/chat/completions (aider, Cursor, Cline, Goose), OpenAI /v1/responses (Codex), and Gemini /v1beta generateContent (Gemini CLI). So you can run native Gemini or Claude inside Codex, or GPT inside Gemini CLI — thinking, tools and streaming included.

export ANTHROPIC_BASE_URL=https://airpx.cc
export ANTHROPIC_AUTH_TOKEN=sk-proxy-…
export ANTHROPIC_MODEL=claude-opus-4-8
# ANTHROPIC_API_KEY also works (the gateway accepts both).

# Then just run:
claude

npm i -g @earendil-works/pi-coding-agent

API Key: sk-proxy-…
Base URL: https://airpx.cc/v1
Model: claude-opus-4-8

Base URL: https://airpx.cc/v1
API Key: sk-proxy-…
Model: claude-opus-4-8

export GOOSE_PROVIDER=openai
export GOOSE_MODEL=claude-opus-4-8
export OPENAI_HOST=https://airpx.cc
export OPENAI_BASE_PATH=v1/chat/completions
export OPENAI_API_KEY=sk-proxy-…

goose session

Base URL: https://airpx.cc/v1
API Key: sk-proxy-…
Model: claude-sonnet-4-6

export OPENAI_API_BASE=https://airpx.cc/v1
export OPENAI_API_KEY=sk-proxy-…

aider --model openai/claude-opus-4-8

npm install -g opencode-ai

model = "gpt-5.5"
model_provider = "airpx"

[model_providers.airpx]
name = "airpx"
base_url = "https://airpx.cc/v1"
wire_api = "responses"
env_key = "OPENAI_API_KEY"

# Codex requires a Responses-API model (e.g. gpt-5.5); wire_api must be "responses".

export GOOGLE_GEMINI_BASE_URL=https://airpx.cc
export GEMINI_API_KEY=sk-proxy-…

# Gemini CLI's gateway auth needs external-auth enabled once:
mkdir -p ~/.gemini
echo '{"security":{"auth":{"useExternal":true}}}' > ~/.gemini/settings.json

# Any model id works — not just Gemini ( --skip-trust for headless -p ):
gemini -m gemini-3.5-flash --skip-trust -p "What is 12 × 12?"
gemini -m claude-opus-4-8  --skip-trust -p "Refactor this function"
gemini -m gpt-5.5          --skip-trust -p "Explain async/await"

AI agents & chatbots — point any OpenClaw / Hermes-style agent at airpx via the OpenAI (/v1) or Anthropic-compatible path.

export OPENAI_BASE_URL=https://airpx.cc/v1
export OPENAI_API_KEY=sk-proxy-…
# model: gpt-5.5 · claude-opus-4-8 · gemini-3.5-flash · deepseek-v4-pro

The model catalog is available at GET /v1/models and returns all active models with their pricing, capabilities, and provider information.

All models are prepaid — billed per 1M tokens with separate rates for input, output, cache read, and cache write tokens. Live per-model pricing is in GET /v1/models (if a free tier is ever added, those models show $0 there). Check the live catalog and rates at GET /v1/models rather than a hardcoded list.

curl https://airpx.cc/v1/models \
  -H "x-api-key: YOUR_KEY"

airpx uses a prepaid balance model. You top up your balance in the dashboard, and each request deducts the cost based on actual token usage and the model's pricing.

Billing is calculated per request based on: • Input tokens × model input price (per 1M tokens) • Output tokens × model output price (per 1M tokens) • Cache read tokens × cache read price • Cache write tokens × cache write price Your balance is checked before each request. If insufficient, the request is rejected with an "Insufficient balance" error (HTTP 429) before it runs — top up at https://airpx.cc/billing.

All models are prepaid — every request deducts from your balance, so you must top up before your first call. You can top up from $1 by card, SBP, or crypto, and your balance never expires. Top up and check your balance at https://airpx.cc/billing. Live per-model pricing is in GET /v1/models.

Set "stream": true in your request body to receive incremental responses. The proxy streams directly from the upstream provider, preserving the original SSE format for both OpenAI and Anthropic protocols.

{
  "model": "gpt-5.4-mini",
  "stream": true,
  "messages": [{"role": "user", "content": "Hello!"}]
}

Thinking / reasoning is also supported. Use reasoning_effort (OpenAI style) or thinking: {type: "enabled", budget_tokens: N} (Anthropic style). Responses include reasoning_content or thinking blocks accordingly.

{
  "model": "claude-opus-4-8",
  "reasoning_effort": "high",
  "stream": true,
  "messages": [{"role": "user", "content": "Solve this step by step..."}]
}

Reasoning controls: OpenAI-style reasoning_effort accepts low | medium | high; Anthropic-style thinking takes {"type": "enabled", "budget_tokens": N}. The gateway maps between them, so a reasoning model responds to whichever your client sends. Per client: Pi uses --thinking off|low|medium|high, OpenCode uses --variant, and Claude Code / Codex pass their own thinking settings through automatically.

Add multiple of your own provider keys — OpenAI, Anthropic, Google, and others — from the dashboard. Requests routed through BYOK are billed directly by your provider; airpx keeps the OpenAI/Anthropic-compatible gateway in front.

For B2B teams, issue each employee one airpx key instead of sharing raw provider keys. You keep model access, limits, and usage visible per employee key. Your own provider keys are never shared with other users.

Billing: when a request is served by YOUR OWN provider key, it is NOT debited from your prepaid airpx balance — your provider bills you directly. Requests served from the shared airpx pool are billed from your airpx balance as before.

Spending caps: set a spending cap (in USD) per app-key over a period — day, week, or month. Manage caps on the BYOK page at https://airpx.cc/byok. The cap is a SOFT cap: it is measured as each request settles, so usage may briefly exceed the cap before new requests are blocked. BYOK spend counted toward a cap is an ESTIMATE at airpx pricing — your provider's real bill is authoritative.

Fallback control (allow_pool_fallback, default OFF): when OFF, once the cap is reached — or the provider key fails — new requests are PAUSED until the cap period resets. When ON, requests fall back to the shared airpx pool and bill your airpx balance, so if your airpx balance is $0 they will fail (top up at https://airpx.cc/billing).

Each user can hold a limited number of app-keys (default 5, configurable by the operator).

Spend visibility: the BYOK page shows a per-provider-key budget summary and an expandable spend breakdown per app-key (cap, spent, remaining, tokens, requests), with a day / week / month analytics window.

Self-service introspection: a client can GET /v1/key (alias /key/info) with its own app-key to read its own, non-secret status — name, spend_cap_usd, cap_period, usage_period (spent this period), remaining, reset_at, provider_key (a non-secret label of the linked provider key, never the raw key), allow_pool_fallback, and allowed_models. This is read-only and makes NO model call.

curl https://airpx.cc/v1/key \
  -H "Authorization: Bearer sk-proxy-YOUR_KEY"

The proxy returns standard HTTP status codes. The most common ones and how to resolve them are below.

Rate limits depend on your account tier and key configuration. If you hit a 429, check the message: a true rate limit clears after a short backoff, but an "Insufficient balance" message means you need to top up in the dashboard.