CLIProxyAPI Plus

English | Chinese

This is the Plus version of CLIProxyAPI, adding support for third-party providers on top of the mainline project.

Note

Upstream reference (for baseline behavior/docs): https://github.com/luispater/CLIProxyAPI/blob/main/README.md

---

Important

This is a fork (read me first)

This repository is a fork/derivative build of CLIProxyAPI.

Motivation: make it easy to use your existing AI subscriptions (Claude Code, Codex, Gemini, Copilot, etc.) from any OpenAI-compatible client/SDK and from multiple coding CLIs — locally or hosted — without rewriting tooling.

What’s different from upstream (and why):

• More provider adapters & auth flows (Copilot, Grok, etc.) — so you can route requests through the subscription/provider you already pay for, using a consistent OpenAI-compatible API surface.
• Cursor Composer 2.5 (API key + SDK sidecar) — route composer-2.5 and related models through your Cursor subscription via CURSOR_API_KEY / cursor-api-key YAML. By default ("Cursor Composer Client-Tools"), the patched @cursor/sdk agent bridge (sidecars/cursor-bridge/cursor-agent-bridge.mjs) owns all Cursor I/O and every tool executes on the client through CLIProxy. Railway starts the bridge on CURSOR_AGENT_BRIDGE_PORT (default 9798) automatically when CURSOR_API_KEY is set; set CURSOR_DIRECT=1 only to opt into the gated legacy direct path.
• Chutes provider support (API key + dynamic model discovery) — optionally expose Chutes-hosted models via OpenAI-compatible endpoints using CHUTES_API_KEY / CHUTES_BASE_URL. Supports configurable retry logic with CHUTES_MAX_RETRIES (default: 4) and CHUTES_RETRY_BACKOFF (default: 5,15,30,60 seconds).
• Managed provider support (API key + dynamic model discovery) — define externally hosted providers with Anthropic, OpenAI Chat Completions, and/or OpenAI Responses upstream transports; expose protocol-pinned aliases; persist route health; and set per-provider transport/redaction policy.
• Passthru model routing (env + YAML) — declare arbitrary model IDs (e.g. glm-4.7) that are forwarded to external upstream APIs (OpenAI-compatible / Anthropic / Responses), with per-route API keys/headers; ideal for hosted deployments (Railway) via PASSTHRU_MODELS_JSON.
• Railway-first deployment path (scripts/railway_start.sh, docs/RAILWAY_GUIDE.md) — to make it dead simple to spin up a personal, always-on CLIProxyAPI instance you can call from anywhere.
  • Log in locally (interactive browser/device flows), then package credentials into AUTH_BUNDLE via scripts/auth_bundle.sh and restore them in a remote environment.
• Hosted-friendly credential transfer (AUTH_BUNDLE/AUTH_ZIP_URL) — avoids having to manually copy lots of files/secrets around when deploying.
• Compatibility emphasis (including Responses-style clients) — so tools expecting OpenAI-compatible endpoints “just work” with minimal configuration.
• One config, many tools — point Claude Code / Codex CLI / Gemini-compatible clients / IDE extensions at one base URL and let the proxy handle provider routing and account management.

If you only want the upstream behavior/features, compare against the original upstream repository and docs.

Recommended companion tools / related forks:

• Patch-22 (recommended): a tiny apply_patch safety net binary/script for when a model tries to run apply_patch as a shell command: github.com/jeffnash/patch-22.
• Letta Code (jeffnash fork): github.com/jeffnash/letta-code is wired up to route main model calls through a hosted jeffnash/CLIProxyAPI instance.
• Letta (jeffnash fork): github.com/jeffnash/letta includes scripts to deploy the Letta server to Railway and pairs well with this proxy.

---

All third-party provider support is maintained by community contributors; CLIProxyAPI does not provide technical support. Please contact the corresponding community maintainer if you need assistance.

A proxy server that provides OpenAI/Gemini/Claude/Codex/Grok compatible API interfaces for CLI.

It now also supports OpenAI Codex (GPT models) and Claude Code via OAuth.

The Plus release stays in lockstep with the mainline features.

Differences from the Mainline

This project is sponsored by Z.ai, supporting us with their GLM CODING PLAN.

GLM CODING PLAN is a subscription service designed for AI coding, starting at just $3/month. It provides access to their flagship GLM-4.7 model across 10+ popular AI coding tools (Claude Code, Cline, Roo Code, etc.), offering developers top-tier, fast, and stable coding experiences.

Get 10% OFF GLM CODING PLAN：https://z.ai/subscribe?ic=8JVLJQFSKB

---

	Thanks to PackyCode for sponsoring this project! PackyCode is a reliable and efficient API relay service provider, offering relay services for Claude Code, Codex, Gemini, and more. PackyCode provides special discounts for our software users: register using this link and enter the "cliproxyapi" promo code during recharge to get 10% off.
	Thanks to Cubence for sponsoring this project! Cubence is a reliable and efficient API relay service provider, offering relay services for Claude Code, Codex, Gemini, and more. Cubence provides special discounts for our software users: register using this link and enter the "CLIPROXYAPI" promo code during recharge to get 10% off.

Fork-Focused Quickstart

This fork is primarily optimized for:

• Using OAuth/subscription logins (Codex / Claude Code / Gemini / Copilot / etc.) behind an OpenAI-compatible base URL
• Hosting your own personal instance (especially on Railway) so you can call it from anywhere

Key docs:

• End-user Railway deployment: docs/RAILWAY_GUIDE.md
• Railway Copilot Electron shim: docs/RAILWAY_ELECTRON_SHIM.md
• Railway scripts reference: scripts/README_RAILWAY.md
• SDK usage (embed the proxy in Go): docs/sdk-usage.md
• SDK advanced: docs/sdk-advanced.md
• SDK access/auth: docs/sdk-access.md
• Credential watching: docs/sdk-watcher.md

Provider & config matrix (fork-specific):

Topic	Where	Notes
Provider login commands (Gemini / Claude / Codex / Copilot / Grok / Qwen / iFlow / Antigravity / Vertex)	docs/RAILWAY_GUIDE.md	See the “Local Authentication” table for exact --*-login flags.
Grok support	docs/RAILWAY_GUIDE.md	Uses --grok-login (SSO cookies flow).
Copilot support	docs/RAILWAY_GUIDE.md	Uses --copilot-login (device code flow).
Cursor Composer support	internal/config/config.go / scripts/README_RAILWAY.md	Env: CURSOR_API_KEY (also cursor-api-key in YAML). Sidecar: sidecars/cursor-bridge/cursor-agent-bridge.mjs (patched @cursor/sdk agent bridge, Railpack Node 22) on CURSOR_AGENT_BRIDGE_PORT (default 9798). Bridge tuning: CURSOR_AGENT_BRIDGE_URL, CURSOR_AGENT_STATE_ROOT; CURSOR_DIRECT=1 opts into the gated legacy direct path. Railway: set RAILPACK_PACKAGES=go@1.26 node@22. Models: composer-2.5, composer-2.5-fast, etc.
Claude Code → Cursor via proxy	scripts/claude-code-cursor.sh	source scripts/claude-code-cursor.sh on points Claude Code at CLIProxyAPI; local auth uses ignored (must match api-keys in config).
Railway env vars (auth transfer)	scripts/README_RAILWAY.md	AUTH_BUNDLE or AUTH_ZIP_URL, plus API_KEY_1, optional AUTH_DIR_NAME, FORCE_BUILD, optional CURSOR_API_KEY.
Copilot initiator behavior	internal/runtime/executor/copilot_headers.go	Default is X-Initiator: agent for Copilot requests. Trusted internal callers can override via request header force-copilot-initiator: user (used by Copilot Hot Takes).
Copilot config keys (YAML)	internal/config/config.go	Look under CopilotKey config + related fields for the authoritative schema (initiator flags + header profile selection).
Copilot header behavior	internal/runtime/executor/copilot_headers.go	Implementation for request header shaping / agent-call behavior + optional header profile emulation.
Copilot model registry	internal/registry/copilot_models.go	How Copilot models are enumerated/aliased.
Force Copilot routing	sdk/api/handlers/handlers.go / sdk/cliproxy/auth/conductor.go	Use copilot-<model> to explicitly route to Copilot even if the model isn't registered; bypasses client model support filtering.
Force Codex routing	sdk/api/handlers/handlers.go / sdk/cliproxy/auth/conductor.go	Use codex-<model> to explicitly route to Codex; sets forced_provider=true to bypass client model support filtering.
Force Kimi routing	sdk/api/handlers/handlers.go / sdk/cliproxy/auth/conductor.go	Use kimi-<model> to explicitly route to Kimi; sets forced_provider=true to bypass client model support filtering.
Force iFlow routing	sdk/api/handlers/handlers.go / sdk/cliproxy/auth/conductor.go	Use iflow-<model> to explicitly route to iFlow; sets forced_provider=true to bypass client model support filtering.
Copilot Hot Takes	internal/cmd/copilot_hot_takes.go / docs/RAILWAY_GUIDE.md	Optional background job controlled by COPILOT_HOT_TAKES_INTERVAL_MINS and COPILOT_HOT_TAKES_MODEL.
Grok config schema	internal/config/config.go	GrokKey and GrokConfig sections define available knobs.
Chutes support (env + YAML)	internal/config/config.go / docs/RAILWAY_GUIDE.md	Env vars: CHUTES_API_KEY, CHUTES_BASE_URL, CHUTES_MODELS, CHUTES_MODELS_EXCLUDE, CHUTES_PRIORITY, CHUTES_TEE_PREFERENCE, CHUTES_PROXY_URL, CHUTES_MAX_RETRIES. YAML: chutes section.
Force Chutes routing	sdk/api/handlers/handlers.go / sdk/cliproxy/auth/conductor.go	Use chutes-<model> to explicitly route to Chutes; sets forced_provider=true to bypass client model support filtering.
Chutes model aliasing + fallbacks	internal/registry/chutes_models.go	Generates chutes- aliases for explicit routing + contains conservative fallback models.
Chutes executor	internal/runtime/executor/chutes_executor.go	Implements OpenAI-compatible chat completions + streams, model fetch/cache, and token counting.
Chutes priority filtering	sdk/cliproxy/service.go / sdk/cliproxy/chutes_priority_hook.go	CHUTES_PRIORITY=fallback hides non-prefixed Chutes IDs when another provider has the same model ID; chutes- aliases remain routable.
Managed providers (env + YAML)	internal/config/config.go / docs/RAILWAY_GUIDE.md	Configure managed-providers in YAML or MANAGED_PROVIDERS_JSON in env. Each provider declares name, prefix, API key source, endpoint URLs/paths, model discovery, fallback models, priority, retry settings, route-health settings, and optional redaction policy.
Force managed-provider routing	sdk/api/handlers/handlers.go / sdk/cliproxy/auth/conductor.go	Use the configured prefix, such as example-<model>, to explicitly route to that provider; protocol-pinned forms include anthropic-example-<model>, openai-example-<model>, openai-responses-example-<model>, and openai-completions-example-<model>.
Managed-provider model aliasing + fallbacks	internal/registry/managed_provider_models.go	Generates configured-prefix aliases plus transport aliases for explicit routing and can publish configured fallback models when live discovery is unavailable.
Managed-provider executor + health routing	internal/runtime/executor/managed_provider_executor.go / internal/runtime/executor/managed_provider_health.go	Translates between client protocol and selected upstream protocol, falls back across transports before a response stream is returned, persists transport health, and probes alternate transports for auto-routing.
Provider-aware Secret DLP	internal/secretdlp / sdk/api/handlers/handlers.go	Redacts secrets after provider selection and before upstream execution, restores placeholders on the way back when SECRET_DLP_MODE=restore, supports encrypted file-backed mappings, and supports global, per-provider, and per-auth opt-in/out policy.
OAuth excluded models	internal/config/config.go	oauth-excluded-models config lets you disable models per provider.
OpenAI-compat upstreams	internal/config/config.go	openai-compatibility for routing to other OpenAI-compatible providers.
Routing behavior	internal/config/config.go	routing config controls credential selection/failover.

Copilot initiator (fork default)

This fork defaults Copilot requests to X-Initiator: agent.

Trusted internal callers can override the initiator with the request header:

• force-copilot-initiator: user|agent

This is used for opt-in background jobs (see Copilot Hot Takes in docs/RAILWAY_GUIDE.md).

Chutes config (quick explainer)

Chutes is an optional OpenAI-compatible upstream. You can route to it either explicitly (recommended) or by exposing non-prefixed IDs.

• Explicit routing: set model: "chutes-<model>" (works as long as Chutes is configured).
• Env vars:
  • CHUTES_API_KEY (required), CHUTES_BASE_URL (optional)
  • CHUTES_MODELS / CHUTES_MODELS_EXCLUDE (optional allow/block lists)
  • CHUTES_PRIORITY (fallback default hides non-prefixed IDs when another provider offers the same ID; primary exposes them)
  • CHUTES_TEE_PREFERENCE (prefer default), CHUTES_PROXY_URL (optional)
  • CHUTES_MAX_RETRIES (default 4; set 0 to disable) — retries intermittent 429s

Managed providers (quick explainer)

Managed providers are optional externally hosted model providers with Claude/Anthropic-compatible and/or OpenAI-compatible endpoints. They can be configured in YAML under managed-providers or through MANAGED_PROVIDERS_JSON for hosted environments.

• Explicit routing: set model: "example-<model>" when the provider prefix is example-.
• Protocol aliases:
  • anthropic-example-<model> pins Anthropic/messages first, then falls back to OpenAI Responses, then OpenAI Chat Completions.
  • openai-responses-example-<model> pins OpenAI Responses first, then falls back to Chat Completions, then Anthropic/messages.
  • openai-completions-example-<model> pins OpenAI Chat Completions first, then falls back to Responses, then Anthropic/messages.
  • openai-example-<model> uses the best OpenAI transport, Responses or Chat Completions, then falls back to Anthropic/messages.
  • example-<model> or unprefixed published IDs use the best available transport across all configured transports.
• Endpoint independence: clients may call OpenAI Chat Completions, OpenAI Responses, or Anthropic Messages endpoints with any managed-provider alias. CLIProxyAPI translates the request into the selected upstream transport and translates the response/stream back to the client-requested protocol.
• Auto routing prefers the client-native format on ties, so Anthropic callers prefer Anthropic, Responses callers prefer Responses, and Chat Completions callers prefer Chat Completions when health scores are otherwise equal.
• Model discovery: enabled by default via the provider's /models endpoint; use fallback-models when discovery is unavailable or incomplete.
• Priority: fallback hides non-prefixed IDs when another provider registers the same model ID; prefixed aliases remain routable.
• Route health:
  • route-health.enabled is on by default and stores provider/model/transport health in managed_provider_health.json under auth-dir, or under RAILWAY_VOLUME_MOUNT_PATH when present.
  • Health state records success EWMA, latency EWMA, timeout counts, cooldowns, unsupported endpoint TTLs, probe timestamps, and safe error summaries.
  • Cooldowns are only set for availability signals: network failures, timeouts, HTTP 408, retryable 429/5xx, and explicit unsupported/not-implemented endpoint responses. Request-specific client errors such as 400/401/403 are recorded but do not poison transport health.
  • Protocol-pinned aliases are only demoted away from their primary transport when that transport is explicitly unsupported. Auto routes can demote cooled-down transports.
  • Background probes are per-provider limited by route-health.max-concurrent-probes, respect route-health.probe-interval, and quickly sample alternate transports for latency/reliability.
  • route-health.first-event-timeout is off by default. When set, streaming requests can fail over mid-bootstrap if the upstream accepts the connection but emits no meaningful SSE event before the timeout and another fallback transport remains. After CLIProxyAPI returns a downstream stream, later stream errors are emitted to the client rather than retried.
• Non-2xx managed-provider logs and health files store status, type/code, and tightly allowlisted messages rather than raw upstream bodies, so prompt/tool content echoed by providers is not persisted as health metadata.
• Hosted env format:

  [
    {
      "name": "example-provider",
      "prefix": "example-",
      "api-key-env": "EXAMPLE_PROVIDER_API_KEY",
      "base-url": "https://provider.example/v1",
      "claude-messages-path": "/messages",
      "openai-chat-path": "/chat/completions",
      "openai-responses-path": "/responses",
      "transport-mode": "auto",
      "default-transport": "claude",
      "route-health": {
        "enabled": true,
        "probe-enabled": true,
        "probe-interval": "15m",
        "probe-timeout": "8s",
        "first-event-timeout": "",
        "cooldown": "5m",
        "unsupported-ttl": "6h",
        "max-concurrent-probes": 2
      },
      "priority": "fallback",
      "fallback-models": ["model-a", "model-b"]
    }
  ]

Secret DLP (quick explainer)

Secret DLP can redact detected secrets after CLIProxyAPI has selected a provider and auth credential, before the payload is sent upstream. In restore mode, placeholders are restored in upstream responses before they are returned to the client.

• Enable with SECRET_DLP_ENABLED=true.
• Modes:
  • SECRET_DLP_MODE=restore redacts upstream payloads and restores placeholders in responses.
  • SECRET_DLP_MODE=redact sends placeholders upstream and leaves placeholders in responses.
  • SECRET_DLP_MODE=block rejects requests with findings.
• Placeholders use the __CPA_DLP_v1_... shape. Detection/redaction events do not log raw secret values.
• Storage:
  • SECRET_DLP_STORE=memory keeps placeholder mappings in process memory.
  • SECRET_DLP_STORE=file persists encrypted mappings; set SECRET_DLP_MASTER_KEY, and optionally SECRET_DLP_FILE_DIR. If SECRET_DLP_FILE_DIR is empty on Railway, it defaults to $RAILWAY_VOLUME_MOUNT_PATH/secret_dlp.
  • SECRET_DLP_TTL_SECONDS controls mapping lifetime; SECRET_DLP_DRAIN_SECONDS controls shutdown drain time.
  • SECRET_DLP_STORE_FAIL_CLOSED=true makes store failures reject rather than degrade.
• Scanner controls:
  • SECRET_DLP_SCANNER=betterleaks is the default scanner.
  • SECRET_DLP_MAX_FINDINGS, SECRET_DLP_MIN_VALUE_LENGTH, SECRET_DLP_REDACT_THRESHOLD, and SECRET_DLP_BETTERLEAKS_CONFIDENCE tune detection.
  • SECRET_DLP_HIGH_ENTROPY=true opts into generic high-entropy matching; explicit credential shapes are detected without requiring this.
  • Built-in explicit detectors cover OpenAI-style sk- keys, known provider/API token prefixes and webhook URLs, bearer/basic auth, JWTs, DSNs with user info, AWS/Azure credentials, PEM/PGP/PuTTY/age private keys, Solana/ed25519/EVM keys, BIP39 mnemonics with checksum validation, GCP service-account JSON, and Ethereum keystore JSON.
• Payload coverage is route-aware for /v1/chat/completions, /v1/messages, /v1/responses, and /backend-api/codex/responses, including system/instruction text, message content, tool arguments, and tool results.
• Policy controls:
  • SECRET_DLP_DEFAULT_PROVIDER_POLICY=enabled|disabled sets the global provider default.
  • SECRET_DLP_PROVIDER_OVERRIDES=example-provider=disabled,other-provider=enabled overrides specific providers.
  • Each managed provider can set secret-redaction: enabled|disabled|inherit.
  • Selected auth records can carry secret_redaction; auth-level policy takes precedence over provider overrides and global defaults.
• Failure controls:
  • SECRET_DLP_FAIL_CLOSED=true rejects requests when scanner/redaction fails.
  • SECRET_DLP_LOG_EVENTS=true logs redaction lifecycle events without logging the raw secret.

If you want the baseline upstream documentation/behavior, start here: https://github.com/luispater/CLIProxyAPI/blob/main/README.md

If you want more details (and exact env vars), see docs/RAILWAY_GUIDE.md and scripts/README_RAILWAY.md.

---

Note: this fork’s docs intentionally focus on fork-specific behavior; the upstream README is the best reference for the baseline project.

---

Hosted instance goals:

• Log in locally once, then transfer credentials via scripts/auth_bundle.sh (AUTH_BUNDLE) to your host.
• Point your clients/tools at your hosted base URL and keep using the same API key.

Capabilities (Fork)

• OpenAI-compatible API endpoints for chat + tools (plus provider routing)
• OAuth/cookie login flows for multiple providers and multi-account load balancing
• Streaming + non-streaming responses, multimodal inputs (where supported)
• Compatibility targets: OpenAI-compatible clients/SDKs (including Responses-style clients) + coding CLIs

Getting Started

CLIProxyAPI Guides: https://help.router-for.me/

Management API

see MANAGEMENT_API.md

Who is with us?

Those projects are based on CLIProxyAPI:

vibeproxy

Native macOS menu bar app to use your Claude Code & ChatGPT subscriptions with AI coding tools - no API keys needed

Subtitle Translator

Browser-based tool to translate SRT subtitles using your Gemini subscription via CLIProxyAPI with automatic validation/error correction - no API keys needed

• Added GitHub Copilot support (OAuth login), provided by em4go
• Added Kiro (AWS CodeWhisperer) support (OAuth login), provided by fuko2935, Ravens2121

CCS (Claude Code Switch)

CLI wrapper for instant switching between multiple Claude accounts and alternative models (Gemini, Codex, Antigravity) via CLIProxyAPI OAuth - no API keys needed

ProxyPal

Native macOS GUI for managing CLIProxyAPI: configure providers, model mappings, and endpoints via OAuth - no API keys needed.

Note

If you developed a project based on CLIProxyAPI, please open a PR to add it to this list.

Sponsor

Thanks to PackyCode for sponsoring this project!

PackyCode is a reliable and efficient API relay service provider, offering relay services for Claude Code, Codex, Gemini, and more.

PackyCode provides special discounts for our software users: register using this link and enter the "cliproxyapi" promo code during recharge to get 10% off.

---

	Thanks to AICodeMirror for sponsoring this project! AICodeMirror provides official high-stability relay services for Claude Code / Codex / Gemini, with enterprise-grade concurrency, fast invoicing, and 24/7 dedicated technical support. Claude Code / Codex / Gemini official channels at 38% / 2% / 9% of original price, with extra discounts on top-ups! AICodeMirror offers special benefits for CLIProxyAPI users: register via this link to enjoy 20% off your first top-up, and enterprise customers can get up to 25% off!
	Huge thanks to BmoPlus for sponsoring this project! BmoPlus is a highly reliable AI account provider built strictly for heavy AI users and developers. They offer rock-solid, ready-to-use accounts and official top-up services for ChatGPT Plus / ChatGPT Pro (Full Warranty) / Claude Pro / Super Grok / Gemini Pro. By registering and ordering through BmoPlus - Premium AI Accounts & Top-ups, users can unlock the mind-blowing rate of 10% of the official GPT subscription price (90% OFF)!
	Thanks to VisionCoder for supporting this project. VisionCoder Developer Platform is a reliable and efficient API relay service provider, offering access to mainstream AI models such as Claude Code, Codex, and Gemini. It helps developers and teams integrate AI capabilities more easily and improve productivity. Additionally, VisionCoder now offers retail channels for Claude Max 200 and GPT Pro 200 premium accounts, providing users with instant access to top-tier AI computing power and features.
	Thanks to APIKEY.FUN for sponsoring this project! APIKEY.FUN is a professional enterprise-grade AI relay platform dedicated to providing stable, efficient, and low-cost AI model API access for enterprises and individual developers. The platform supports popular mainstream models such as Claude, OpenAI, and Gemini, with prices as low as 7% of the official price. Register through this project's exclusive link to enjoy a special permanent 5% top-up discount.
	RunAPI is an efficient and stable API platform—an alternative to OpenRouter. A single API Key gives you access to 150+ leading models, including OpenAI, Claude, Gemini, DeepSeek, Grok, and more, at prices as low as 10% of the original (up to 90% off), with exceptional stability. It's seamlessly compatible with tools like Claude Code, OpenClaw, and others. RunAPI offers an exclusive perk for CPA users: register and contact an administrator to claim ¥7 in free credit.
	Thanks to Unity2.ai for sponsoring this project! Unity2.ai is a high-performance AI model API relay platform for individual developers, teams, and enterprises. It has long served leading domestic enterprises, handles more than 30 billion token calls per day, and supports high concurrency at the 5000 RPM level. It supports balance billing, first top-up bonuses, bundled subscriptions, enterprise invoicing, and dedicated integration support. Register through this link to receive a $2 balance, then join the official group to get another $10 balance, for up to $12 in free credit.
	Cat API is an AI model aggregation platform built for individual developers and teams, integrating leading large language models into a single simple, stable, and easy-to-use entry point. It provides an API fully compatible with OpenAI, Claude, and Gemini that plugs seamlessly into mainstream AI IDEs and coding tools such as Claude Code, Cursor, Windsurf, Cline, Roo Code, Continue, Codex, and Trae, and features dedicated CN2 high-speed routing for low-latency, highly reliable access. Sign up to claim 1$ in free credits.
	CyberPay was founded in 2021. We are committed to providing stable, efficient, and secure payment settlement solutions for AI industry merchants. Working with us helps your website platform solve Alipay and WeChat payment collection needs. We support business cooperation for selling GPT, Gemini, Claude, and Codex accounts, relay platforms, and other related services, helping merchants address payment collection challenges. Contact us to start your path to growth.
	Thanks to Claude API for sponsoring this project! Claude API is an official-channel API provider focused on Claude models. Built on Anthropic official keys and AWS Bedrock official channels, it provides a stable integration experience for Claude Code and Agent applications, supports the full Claude model family, and preserves official capabilities such as Tool Use and long context. The service is not reverse-engineered and does not downgrade model capabilities, making it suitable for heavy Claude Code users, Agent engineers, and enterprise technical teams. Register through the Exclusive link and contact customer support to claim free test credits. Invoicing and team onboarding are also supported.
	Thanks to Code0 for sponsoring this project! code0.ai is an AI coding workspace for developers and technical teams, bringing together mainstream Agent coding capabilities such as Claude Code and Codex. It supports common development scenarios including code generation, project understanding, debugging, code review, and documentation. It is suitable for independent developers, Agent engineers, open-source maintainers, and enterprise R&D teams, with invoicing and team onboarding supported. Register through the Exclusive link and contact customer support to claim free test credits and experience a more efficient AI coding workflow.

Overview

• OpenAI/Gemini/Claude/Grok compatible API endpoints for CLI models
• OpenAI Codex support (GPT models) via OAuth login
• Claude Code support via OAuth login
• Grok Build support via OAuth login
• Streaming, non-streaming, and WebSocket responses where supported
• Function calling/tools support
• Multimodal input support (text and images)
• Multiple accounts with round-robin load balancing (Gemini, OpenAI, Claude, Grok)
• Simple CLI authentication flows (Gemini, OpenAI, Claude, Grok)
• Generative Language API Key support
• AI Studio Build multi-account load balancing
• Claude Code multi-account load balancing
• OpenAI Codex multi-account load balancing
• Grok Build multi-account load balancing
• OpenAI-compatible upstream providers via config (e.g., OpenRouter)
• Reusable Go SDK for embedding the proxy (see docs/sdk-usage.md)

Getting Started

CLIProxyAPI Guides: https://help.router-for.me/

Management API

see MANAGEMENT_API.md

Usage Statistics

Since v6.10.0, CLIProxyAPI and CPAMC no longer ship built-in usage statistics. If you need usage statistics, use:

CPA Usage Keeper

Standalone persistence and visualization service for CLIProxyAPI, with periodic data sync, SQLite storage, aggregate APIs, and a built-in dashboard for usage and statistics.

CPA-Manager-Plus

Full CLIProxyAPI management center with request-level monitoring and cost estimates. CPA-Manager tracks collected requests by account, model, channel, latency, status, and token usage; estimates cost with editable model prices and one-click LiteLLM price sync; persists events in SQLite; and provides Codex account-pool operations with batch inspection, quota detection, unhealthy account discovery, cleanup suggestions, and one-click execution for day-to-day multi-account maintenance.

SDK Docs

• Usage: docs/sdk-usage.md
• Advanced (executors & translators): docs/sdk-advanced.md
• Access: docs/sdk-access.md
• Watcher: docs/sdk-watcher.md
• Custom Provider Example: examples/custom-provider

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Who is with us?

Those projects are based on CLIProxyAPI:

vibeproxy

Native macOS menu bar app to use your Claude Code & ChatGPT subscriptions with AI coding tools - no API keys needed

Subtitle Translator

A cross-platform desktop and web app to translate and validate SRT subtitles using your existing LLM subscriptions (Gemini, ChatGPT, Claude, etc.) via CLIProxyAPI - no API keys needed.

CCS (Claude Code Switch)

CLI wrapper for instant switching between multiple Claude accounts and alternative models (Gemini, Codex, Antigravity) via CLIProxyAPI OAuth - no API keys needed

Quotio

Native macOS menu bar app that unifies Claude, Gemini, OpenAI, and Antigravity subscriptions with real-time quota tracking and smart auto-failover for AI coding tools like Claude Code, OpenCode, and Droid - no API keys needed.

ProxyPilot

Windows-native CLIProxyAPI fork with TUI, system tray, and multi-provider OAuth for AI coding tools - no API keys needed.

Claude Proxy VSCode

VSCode extension for quick switching between Claude Code models, featuring integrated CLIProxyAPI as its backend with automatic background lifecycle management.

ZeroLimit

Windows desktop app built with Tauri + React for monitoring AI coding assistant quotas via CLIProxyAPI. Track usage across Gemini, Claude, OpenAI Codex, and Antigravity accounts with real-time dashboard, system tray integration, and one-click proxy control - no API keys needed.

CPA-XXX Panel

A lightweight web admin panel for CLIProxyAPI with health checks, resource monitoring, real-time logs, auto-update, request statistics and pricing display. Supports one-click installation and systemd service.

CLIProxyAPI Tray

A Windows tray application implemented using PowerShell scripts, without relying on any third-party libraries. The main features include: automatic creation of shortcuts, silent running, password management, channel switching (Main / Plus), and automatic downloading and updating.

霖君

霖君 is a cross-platform desktop application for managing AI programming assistants, supporting macOS, Windows, and Linux systems. Unified management of Claude Code, Gemini, OpenAI Codex, and other AI coding tools, with local proxy for multi-account quota tracking and one-click configuration.

CLIProxyAPI Dashboard

A modern web-based management dashboard for CLIProxyAPI built with Next.js, React, and PostgreSQL. Features real-time log streaming, structured configuration editing, API key management, OAuth provider integration for Claude/Gemini/Codex, usage analytics, container management, and config sync with OpenCode via companion plugin - no manual YAML editing needed.

All API Hub

Browser extension for one-stop management of New API-compatible relay site accounts, featuring balance and usage dashboards, auto check-in, one-click key export to common apps, in-page API availability testing, and channel/model sync and redirection. It integrates with CLIProxyAPI through the Management API for one-click provider import and config sync.

Shadow AI

Shadow AI is an AI assistant tool designed specifically for restricted environments. It provides a stealthy operation mode without windows or traces, and enables cross-device AI Q&A interaction and control via the local area network ( LAN). Essentially, it is an automated collaboration layer of "screen/audio capture + AI inference + low-friction delivery", helping users to immersively use AI assistants across applications on controlled devices or in restricted environments.

ProxyPal

Cross-platform desktop app (macOS, Windows, Linux) wrapping CLIProxyAPI with a native GUI. Connects Claude, ChatGPT, Gemini, GitHub Copilot, and custom OpenAI-compatible endpoints with usage analytics, request monitoring, and auto-configuration for popular coding tools - no API keys needed.

CLIProxyAPI Quota Inspector

Ready-to-use cross-platform quota inspector for CLIProxyAPI, supporting per-account codex 5h/7d quota windows, plan-based sorting, status coloring, and multi-account summary analytics.

CLIProxy Pool Watch

Native macOS SwiftUI app for monitoring ChatGPT/Codex account quotas in CLIProxyAPI pools. Displays account availability, Plus-base capacity, 5-hour and weekly quota bars, plan weights, and restore forecasts through the Management API.

Panopticon

Multi-agent orchestration for AI coding assistants. Runs CLIProxyAPI as a local sidecar so its agents can drive GPT models through a ChatGPT subscription, pointing Claude Code at an Anthropic-compatible endpoint with no OpenAI API key required.

Tunnel Agent

Windows desktop UI that manages CLIProxyAPI and Perplexity WebUI Scraper from a single interface, inspired by Quotio and VibeProxy. Connect OAuth providers (Claude, Gemini, Codex, Kimi, Antigravity), custom API keys, and Perplexity session accounts, then point any coding agent at the local endpoint.

Quotio Desktop

Cross-platform (Tauri) port of Quotio for Windows, macOS and Linux. Manages a pool of AI accounts (Codex, Claude Code, GitHub Copilot, Gemini, Antigravity, Kiro, Cursor, Trae, GLM) through CLIProxyAPI, with per-account 5-hour/weekly quota bars, Codex rate-limit reset credits with one-click reset, smart scheduling, usage statistics, and multi-instance Codex — no API keys needed.

Universal Chat Provider

VS Code extension that brings your Claude, ChatGPT/Codex, Antigravity, Grok, and Kimi subscriptions into GitHub Copilot Chat as native language models — and can power your Git commit messages, chat titles, and summaries too. Runs CLIProxyAPI in a fully managed background lifecycle (download, verify, supervise) shared across all windows, so it's zero-setup. No API keys needed, just OAuth.

Note

If you developed a project based on CLIProxyAPI, please open a PR to add it to this list.

All third-party provider support is maintained by community contributors; CLIProxyAPI does not provide technical support. Please contact the corresponding community maintainer if you need assistance.

If you need to submit any non-third-party provider changes, please open them against the mainline repository.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

OmniRoute

Never stop coding. Smart routing to FREE & low-cost AI models with automatic fallback.

OmniRoute is an AI gateway for multi-provider LLMs: an OpenAI-compatible endpoint with smart routing, load balancing, retries, and fallbacks. Add policies, rate limits, caching, and observability for reliable, cost-aware inference.

Playful Proxy API Panel (PPAP)

A public CLIProxyAPI-compatible fork and bundled management panel. It keeps upstream-style usage while restoring built-in usage statistics, adding cache hit rate, first-byte latency, TPS tracking, and Docker-oriented self-hosted installation docs.

Codex Switch

This is a tool built with Tauri 2 + Vue 3 for managing multiple OpenAI Codex desktop accounts. Switch between saved ChatGPT/Codex certification profiles, check 5-hour and weekly quota usage in real time, verify token health, view active account details, and import or save auth.json files without manual copying.

Note

If you have developed a port of CLIProxyAPI or a project inspired by it, please open a PR to add it to this list.

License

This project is licensed under the MIT License - see the LICENSE file for details.