Claude Code Gateway — Alternative Access for Windows

🖥️ PowerShell Setup

Free-Claude-Code-Gateway is a TypeScript proxy that lets the Claude Code CLI and any Anthropic-compatible client operate against OpenAI-compatible providers such as Kimi, GLM, DeepSeek, and OpenRouter. It accepts Anthropic Messages API requests, converts them to OpenAI format, forwards them to your configured upstream endpoint, and translates responses back with full streaming and bidirectional tool-calling support. Model mappings resolve through exact matches, glob-based family rules, and configurable fallbacks, all editable at runtime from the built-in admin dashboard. Request history, configuration overrides, and routing rules persist across restarts, and every route is designed to run locally or in containers without an Anthropic API key.

✅ Before You Start

• PowerShell 5.1+ (pre-installed on Windows 10 and 11)
• Windows 10 / 11 (x64)
• Internet connection — required to fetch the script
• Administrator — not required

Features

• POST /v1/messages — Full Anthropic Messages API compatibility. Validates, maps, converts, and returns responses in the exact shape Claude Code expects, including streaming.
• POST /v1/chat/completions — OpenAI-compatible passthrough with server-side key injection, so downstream clients never handle upstream credentials.
• GET /v1/models — Enumerates available models from the configured upstream provider in real time.
• Bidirectional Format Translation — Anthropic tools / tool_use / tool_result ↔ OpenAI tools / tool_calls, plus full request and response body conversion in both directions.
• Full SSE Streaming — Emits message_start, content_block_*, message_delta, and message_stop events matching the Anthropic streaming contract.
• Smart Model Router — Glob-pattern family rules combined with exact mappings. Resolution order: exact match → family rule → passthrough → default.
• Auto-Map — Syncs the live provider model list, scores existing mappings against it, and suggests corrected provider IDs in bulk. Handles vendor-prefixed vs bare model name inconsistencies automatically.
• Intelligent Failover — Model fallback cascade across family rules and a default fallback, with a circuit breaker that trips on repeated upstream failures and recovers automatically in a half-open state.
• Stream Synthesis — When an upstream streaming endpoint fails but non-streaming works, the gateway fetches the full response and synthesizes a compliant stream so clients never crash.
• Admin Dashboard SPA — Real-time analytics, live request feed over SSE, per-request detail inspection, an interactive playground for testing the translation pipeline, and step-by-step diagnostics.
• Runtime Configuration — Update provider URL, API key, default model, rate limits, timeouts, and CORS from the dashboard with immediate effect and no restart.
• Persistent State — Request history, config overrides, and model mappings survive restarts via a lightweight file-based store. No database dependency.
• Credential Hygiene — API keys and authorization headers are redacted in all logs. Sensitive values are never written to disk or surfaced through admin endpoints.
• Optional Access Control — Bearer-token gating on proxy routes and HTTP Basic auth on admin routes, both toggled via environment configuration.
• Deployment Flexibility — Ships with container, process-manager, and reverse-proxy configurations for local, self-hosted, and production-style setups.

How it works

The gateway operates as a protocol translator sitting between Anthropic-compatible clients and OpenAI-compatible providers. Every incoming request hits the Express server, which validates the payload against the Anthropic Messages API schema before any upstream call is made.

Request translation. For POST /v1/messages, the gateway parses the Anthropic request body — model, messages, system, max_tokens, tools, tool_choice, and sampling parameters — and rewrites it into the OpenAI chat-completions shape. System prompts are hoisted into a leading system role message. Content blocks are flattened: text blocks pass through, tool_use blocks become tool_calls, and tool_result blocks become tool role messages. The mapped provider model ID is substituted for the incoming Claude model name.

Model resolution. Before translation, the router resolves the requested Claude model through a deterministic chain: exact mapping first, then glob-based family rules (Opus, Sonnet, Haiku, default wildcard), then pass-through when strict mode is off, and finally the configured fallback model. Mappings live in config/models.json and can be edited live from the Model Router view without a restart.

Streaming. When stream: true is present, the gateway opens an SSE connection to the upstream and re-emits the OpenAI delta stream as Anthropic events: message_start, then content_block_start, content_block_delta for each text or tool-call fragment, content_block_stop, message_delta carrying stop reason and usage, and message_stop. Chunk boundaries are buffered so partial JSON tool arguments are never emitted mid-fragment.

Tool calling. Anthropic tools definitions are converted to OpenAI function schemas with JSON Schema parameters preserved. On the return path, tool_calls arrays are reassembled from streamed fragments into discrete tool_use content blocks with parsed input objects. Stop reasons map between the two vocabularies (tool_use ↔ tool_calls, max_tokens, end_turn ↔ stop).

Resilience. Every upstream route runs behind a circuit breaker. Consecutive failures trip the breaker open and reroute traffic to the configured fallback model without waiting on timeouts. If an upstream accepts streaming requests but returns malformed deltas, the gateway retrieves the non-streaming response and synthesizes the expected SSE sequence so the client sees a valid stream. The breaker probes failed routes in a half-open state and restores them once healthy responses resume.

Observability. Each request is logged to .blueclaude-data/request-log.json with a bounded ring buffer, and the Live Requests view streams the same events over SSE. Authorization headers and provider keys are redacted at the logging boundary, so the persisted history never contains credentials. Runtime configuration changes made through the admin API are written to config-overrides.json and applied to the in-memory config on the next request.

Compatibility

The gateway targets the Anthropic Messages API surface, so any client that speaks that protocol can use it without modification. This includes the Claude Code CLI, VS Code extensions such as Cline and Roo Code, Continue.dev, Aider, and general OpenAI-style clients like LibreChat, Open WebUI, and LobeChat.

On the upstream side, compatibility is defined by the OpenAI-compatible chat completions contract. Any endpoint that implements POST /v1/chat/completions and GET /v1/models with bearer-token auth can serve as a provider. That covers hosted services including Kimi, GLM, DeepSeek, OpenRouter, Mistral, Fireworks AI, Cerebras, Groq, and Databricks, plus local runtimes such as LM Studio, Ollama, vLLM, and llama.cpp.

Model identity is resolved through the router rather than hardcoded, so Claude model names are mapped to provider model IDs via exact matches, glob-based family rules, pass-through, or the configured default. Streaming is supported end to end: the gateway translates Anthropic SSE events (message_start, content_block_*, message_delta, message_stop) to and from OpenAI-style chunks, and synthesizes a stream when an upstream only supports non-streaming responses. Tool calling is translated bidirectionally between Anthropic tools/tool_use/tool_result and OpenAI tools/tool_calls.

Runtime requirements are Node.js 20 or newer. The gateway itself is provider-agnostic and stateless with respect to the model backend — swapping providers requires only configuration changes, not code changes.

📸 Screenshot

Configuration

The gateway is driven by environment variables and a small set of runtime-configurable settings. Every value below can be supplied at process start via .env, overridden at runtime through the Admin Dashboard, and reloaded without a restart unless noted otherwise.

Environment Variables