Skip to content

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

83 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Claude Code Proxy

🚀 Intelligent API proxy for Anthropic Claude with automatic failover and model mapping

Features

  • Automatic Failover: Primary Anthropic API with intelligent fallback to Claude Subscription and Z.AI
  • Quota Management: Automatic provider switching when weekly token limits are reached
  • Model Mapping: Automatically maps unsupported model names to compatible alternatives
  • Streaming Support: Full support for streaming responses
  • Request Cleaning: Sanitizes requests to ensure Anthropic API compatibility
  • TypeScript: Written in TypeScript for type safety and better development experience
  • Structured Logging: Color-coded, level-based logging for debugging
  • Configuration: Flexible configuration via environment variables or config object

Installation

# Clone the repository
git clone https://github.com/0xPuncker/claude-code-proxy.git
cd claude-code-proxy

# Install dependencies
npm install

# Build the project
npm run build

# Start the server
npm start

Quick Start

Using npm

# Clone the repository
git clone https://github.com/0xPuncker/claude-code-proxy.git
cd claude-code-proxy

# Install dependencies and build
npm install
npm run build

# Set your API keys
export ZAI_API_KEY="your-zai-api-key"
export ANTHROPIC_API_KEY="your-anthropic-api-key"

# Start the proxy (defaults to port 4181)
npm start

# Or use a custom port
PROXY_PORT=8080 npm start

Using Docker

Windows Quick Start (Recommended)

The proxy includes a PowerShell setup script that auto-detects your Windows user profile and Claude credentials:

# Clone the repository
git clone https://github.com/0xPuncker/claude-code-proxy.git
cd claude-code-proxy

# Run the automatic setup script
powershell -ExecutionPolicy Bypass -File scripts/setup-docker.ps1

# Start the containers
docker-compose --env-file .env.docker up -d

The setup script automatically:

  • Detects your Windows user profile directory
  • Converts Windows paths to Docker format
  • Configures Claude subscription credentials mount
  • Generates .env.docker with proper configuration

⚠️ Windows Limitation: Due to Docker bind mount permissions on Windows, the Claude subscription credentials file (~/.claude/.credentials.json) cannot be read from inside the container. The proxy will work fine with Z.AI as your primary provider. To enable a fallback provider, add your Anthropic API key to .env.docker.

Quick Start with .env File (Linux/Mac)

# Clone the repository
git clone https://github.com/0xPuncker/claude-code-proxy.git
cd claude-code-proxy

# Create environment file from Docker example
cp .env.docker.example .env.docker

# Edit .env.docker and add your API keys
# nano .env.docker or code .env.docker

# Build and run with Docker Compose using custom env file
docker-compose --env-file .env.docker up -d

# View logs
docker-compose --env-file .env.docker logs -f cc-proxy

# Stop the container
docker-compose --env-file .env.docker down

Docker Environment Files

The proxy supports multiple environment file patterns:

  • .env.docker.example: Comprehensive Docker environment template with all available configuration options
  • .env.example: Basic environment template for local development
  • .env.docker: Your custom Docker environment (not tracked in git)

Docker Commands

# Using default .env file
docker-compose up -d

# Using custom environment file
docker-compose --env-file .env.docker up -d

# Using specific environment file
docker-compose --env-file .env.production up -d

# Build the Docker image
docker-compose build

# Start the container
docker-compose up -d

# View logs for specific service
docker-compose logs -f cc-proxy
docker-compose logs -f cc-db
docker-compose logs -f cc-adminer

# View all logs
docker-compose logs -f

# Stop the container
docker-compose down

# Stop and remove volumes
docker-compose down -v

# Restart the container
docker-compose restart cc-proxy

# Remove containers and images
docker-compose down --rmi all -v

Environment Variables Reference

Key Docker environment variables (see .env.docker.example for complete list):

# Required
ZAI_API_KEY=your-zai-api-key-here
ANTHROPIC_API_KEY=your-anthropic-api-key-here

# Optional (with defaults)
PROXY_PORT=4181                    # Proxy server port
POSTGRES_VERSION=15                # PostgreSQL version
POSTGRES_DB=claude_proxy          # Database name
POSTGRES_USER=postgres            # Database user
POSTGRES_PASSWORD=postgres        # Database password
ADMINER_PORT=8080                  # Adminer UI port
LOG_LEVEL=info                     # Logging level
NODE_ENV=production                # Node environment
RESTART_POLICY=unless-stopped      # Container restart policy

Docker Services

The docker-compose setup includes three services:

  • cc-proxy: Main proxy server (port 4181)
  • cc-db: PostgreSQL database (port 5432)
  • cc-adminer: Database management UI (port 8080)

Database Access

Via Adminer Web UI:

  • URL: http://127.0.0.1:8080
  • System: PostgreSQL
  • Server: cc-db
  • Username: postgres
  • Password: postgres
  • Database: claude_proxy

Via psql command:

docker-compose exec cc-db psql -U postgres -d claude_proxy

Database Backup/Restore:

# Backup
docker-compose exec cc-db pg_dump -U postgres claude_proxy > backup.sql

# Restore
docker-compose exec -T cc-db psql -U postgres claude_proxy < backup.sql

Usage

Basic Example

// Use the proxy with any Claude API client
const response = await fetch('http://127.0.0.1:4181/v1/messages', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': 'your-anthropic-api-key',
  },
  body: JSON.stringify({
    model: 'claude-sonnet-4-6',
    messages: [{ role: 'user', content: 'Hello, Claude!' }],
    max_tokens: 1024,
  }),
});

Configuration Options

import { ClaudeCodeProxy } from './src/index.js';

const proxy = new ClaudeCodeProxy({
  port: 4181,
  zai: {
    baseUrl: 'https://api.z.ai/api/anthropic',
    apiKey: process.env.ZAI_API_KEY || '',
  },
  anthropic: {
    baseUrl: 'https://api.anthropic.com',
    apiKey: process.env.ANTHROPIC_API_KEY || '',
  },
  modelFallbackMap: {
    'claude-sonnet-4-6': 'claude-sonnet-4-20250514',
    'claude-opus-4-6': 'claude-sonnet-4-20250514',
  },
  fallbackOnCodes: [429, 503, 502],
  logLevel: 'info', // 'debug' | 'info' | 'warn' | 'error' | 'silent'
});

proxy.start();

Environment Variables

  • PROXY_PORT: Port for the proxy server (default: 4181)
  • ZAI_API_KEY: API key for Z.AI service
  • ANTHROPIC_API_KEY: API key for Anthropic Claude API

Model Mapping

The proxy automatically maps newer model names to their compatible equivalents:

{
  "glm-5": "claude-sonnet-4-20250514",
  "glm-4.7": "claude-sonnet-4-20250514",
  "glm-4.6": "claude-sonnet-4-20250514",
  "glm-4.5": "claude-sonnet-4-20250514",
  "glm-4.5-air": "claude-haiku-4-5-20251001",
  "claude-sonnet-4-6": "claude-sonnet-4-20250514",
  "claude-opus-4-6": "claude-sonnet-4-20250514",
  "claude-haiku-4-5": "claude-haiku-4-5-20251001"
}

API Reference

ClaudeCodeProxy

Main proxy server class.

Constructor

new ClaudeCodeProxy(config?: Partial<ProxyConfig>)

Methods

  • start(): Start the proxy server
  • stop(): Stop the proxy server

ProxyConfig Interface

interface ProxyConfig {
  port: number;
  zai: {
    baseUrl: string;
    apiKey: string;
  };
  anthropic: {
    baseUrl: string;
    apiKey: string;
  };
  modelFallbackMap: Record<string, string>;
  fallbackOnCodes: number[];
  logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
}

How It Works

  1. Request Interception: The proxy receives requests destined for the Anthropic API
  2. Primary Attempt: Forwards requests to Anthropic API first (primary provider)
  3. Quota Tracking: Monitors weekly token usage and automatically switches when limit is reached
  4. Smart Fallback: Automatic fallback chain: Anthropic API → Claude Subscription → Z.AI
  5. Circuit Breaker: Monitors provider health and handles failures (429, 502, 503)
  6. Request Cleaning: Ensures all requests are Anthropic-compatible
  7. Model Mapping: Maps unsupported model names to compatible alternatives
  8. Response Proxying: Returns the response to the client transparently

Provider Priority

The proxy uses this priority order for automatic failover:

  1. Anthropic API (Primary) - Used first, subject to weekly quota limits
  2. Claude Subscription (Fallback) - Used when Anthropic API fails or quota exceeded
  3. Z.AI (Last Resort) - Used when both Anthropic and Subscription fail

Automatic swap triggers:

  • Quota exceeded (e.g., 90% of weekly limit)
  • Rate limiting (HTTP 429)
  • Service unavailable (HTTP 502, 503)
  • Network errors
  • Consecutive failures

Logging

The proxy provides structured, color-coded logging:

[12:34:56] [INFO] → Z.AI POST /v1/messages
[12:34:57] [OK] ← Z.AI 200
[12:34:58] [INFO]   model remap: claude-sonnet-4-6 → claude-sonnet-4-20250514

Log levels:

  • DEBUG: Detailed information for debugging
  • INFO: General informational messages
  • WARN: Warning messages for fallbacks
  • ERROR: Error messages
  • SILENT: Disable all logging

Development

# Install dependencies
npm install

# Run in development mode with watch
npm run dev

# Run tests
npm test

# Run linter
npm run lint

# Format code
npm run format

# Using Makefile
make build          # Build TypeScript
make dev            # Run in development mode
make test           # Run tests
make docker-build   # Build Docker image
make docker-run     # Run Docker container
make docker-stop    # Stop Docker containers
make help           # Show all available commands

Architecture

graph TB
    Client[Client Application] -->|HTTP Request| Proxy[Claude Code Proxy]
    
    subgraph "Proxy Internal Processing"
        Proxy -->|1. Intercept| Request[Request Handler]
        Request -->|2. Clean| Cleaning[Request Cleaning]
        Cleaning -->|3. Map| Mapping[Model Mapping]
        Mapping -->|4. Check| CircuitBreaker{Circuit Breaker}
    end
    
    subgraph "Provider Priority Chain"
        CircuitBreaker -->|Primary| Anthropic[Anthropic API]
        CircuitBreaker -->|Fallback 1| Subscription[Claude Subscription]
        CircuitBreaker -->|Fallback 2| ZAI[Z.AI API]
    end
    
    subgraph "Health Monitoring"
        Health[Provider Health Monitor]
        Health -->|Track| Anthropic
        Health -->|Track| Subscription
        Health -->|Track| ZAI
    end
    
    subgraph "Quota Tracking"
        Quota[Usage Tracker]
        Quota -->|Weekly Limits| Database[(PostgreSQL)]
    end
    
    Anthropic -->|Response| Response[Response Handler]
    Subscription -->|Response| Response
    ZAI -->|Response| Response
    Response -->|Return| Client
    
    CircuitBreaker -.->|Monitor| Health
    Anthropic -.->|Token Usage| Quota
    Subscription -.->|Token Usage| Quota
    ZAI -.->|Token Usage| Quota
    
    style Proxy fill:#4A90E2,color:#fff
    style Anthropic fill:#50C878,color:#fff
    style Subscription fill:#FFB347,color:#000
    style ZAI fill:#FF6B6B,color:#fff
    style Health fill:#9B59B6,color:#fff
    style Quota fill:#3498DB,color:#fff
Loading

Flow Description

  1. Request Interception: Client sends HTTP request to proxy
  2. Request Processing:
    • Request cleaning (ensure Anthropic compatibility)
    • Model mapping (convert unsupported models)
    • Circuit breaker check (provider health)
  3. Provider Selection:
    • Primary: Anthropic API (subject to quota limits)
    • Fallback 1: Claude Subscription (if Anthropic fails/quota exceeded)
    • Fallback 2: Z.AI (if both above fail)
  4. Health Monitoring: Circuit breaker tracks provider health
  5. Quota Tracking: Usage tracker logs token consumption
  6. Response Return: Response sent back to client

Automatic Failover Triggers

  • Quota exceeded (e.g., 90% of weekly limit)
  • Rate limiting (HTTP 429)
  • Service unavailable (HTTP 502, 503)
  • Network errors
  • Consecutive failures (3 = degraded, 5 = unavailable)

Contributing

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

License

MIT License - see LICENSE file for details.

Support

For issues and questions, please use the GitHub issue tracker.

Acknowledgments

  • Built for the Anthropic Claude ecosystem
  • Inspired by the need for reliable API failover in production environments

About

Intelligent API proxy for Anthropic Claude with automatic failover and model mapping

Topics

Resources

Contributing

Stars

1 star

Watchers

0 watching

Forks

Releases

Used by

Contributors

Languages