Copilot API Proxy

Warning

This is a reverse-engineered proxy of GitHub Copilot API. It is not supported by GitHub, and may break unexpectedly. Use at your own risk.

Warning

GitHub Security Notice:
Excessive automated or scripted use of Copilot (including rapid or bulk requests, such as via automated tools) may trigger GitHub's abuse-detection systems.
You may receive a warning from GitHub Security, and further anomalous activity could result in temporary suspension of your Copilot access.

GitHub prohibits use of their servers for excessive automated bulk activity or any activity that places undue burden on their infrastructure.

Please review:

• GitHub Acceptable Use Policies
• GitHub Copilot Terms

Use this proxy responsibly to avoid account restrictions.

---

Note: If you are using opencode, you do not need this project. Opencode supports GitHub Copilot provider out of the box.

---

Project Overview

A reverse-engineered proxy that exposes GitHub Copilot and ChatGPT Plus/Pro Codex-style OAuth access behind OpenAI-compatible and Anthropic-compatible APIs. This allows you to point tools such as Claude Code and other OpenAI/Anthropic-compatible clients at a single local proxy while choosing which upstream backend to use.

Features

• Multiple Backends: Supports GitHub Copilot and an OpenAI OAuth backend (--backend copilot|openai-oauth) for single-user local development.
• OpenAI & Anthropic Compatibility: Exposes the selected backend as an OpenAI-compatible (/v1/chat/completions, /v1/models, /v1/embeddings, /v1/responses) and Anthropic-compatible (/v1/messages) API where supported.
• Claude Code Integration: Easily configure and launch Claude Code to use Copilot as its backend with a simple command-line flag (--claude-code).
• Usage Dashboard: A built-in web UI at /dashboard with persistent telemetry by default, backend filtering, recent events, and model/token history.
• Rate Limit Control: Manage API usage with rate-limiting options (--rate-limit) and a waiting mechanism (--wait) to prevent errors from rapid requests.
• Manual Request Approval: Manually approve or deny each API request for fine-grained control over usage (--manual).
• Opt-In Exchange Capture: Persist proxied request and response exchanges to JSONL for debugging or audit purposes (--capture, --capture-path).
• Ephemeral Telemetry Mode: Keep dashboard telemetry in memory for a single run with --ephemeral when you do not want persistent local history.
• Runtime Logging Controls: Set runtime verbosity explicitly with --log-level, while keeping --verbose as a shortcut.
• Token Visibility: Option to display GitHub and Copilot tokens during authentication and refresh for debugging (--show-token).
• Flexible Authentication: Authenticate interactively or provide a GitHub token directly, suitable for CI/CD environments.
• Support for Different Account Types: Works with individual, business, and enterprise GitHub Copilot plans.

Demo

copilot-api-demo.mp4

Prerequisites

• Bun (>= 1.2.x)
• One of:
  • GitHub account with Copilot subscription (individual, business, or enterprise)
  • ChatGPT Plus/Pro account for --backend openai-oauth

Installation

To install dependencies, run:

bun install

Using with Docker

Build image

docker build -t copilot-api .

Run the container

# Create a directory on your host to persist the GitHub token and related data
mkdir -p ./copilot-data

# Run the container with a bind mount to persist the token
# This ensures your authentication survives container restarts

docker run -p 4141:4141 -v $(pwd)/copilot-data:/root/.local/share/copilot-api copilot-api

Note: The GitHub token and related data will be stored in copilot-data on your host. This is mapped to /root/.local/share/copilot-api inside the container, ensuring persistence across restarts.

Docker with Environment Variables

You can pass the GitHub token directly to the container using environment variables:

# Build with GitHub token
docker build --build-arg GH_TOKEN=your_github_token_here -t copilot-api .

# Run with GitHub token
docker run -p 4141:4141 -e GH_TOKEN=your_github_token_here copilot-api

# Run with additional options
docker run -p 4141:4141 -e GH_TOKEN=your_token copilot-api start --verbose --port 4141

Docker Compose Example

version: "3.8"
services:
  copilot-api:
    build: .
    ports:
      - "4141:4141"
    environment:
      - GH_TOKEN=your_github_token_here
    restart: unless-stopped

The Docker image includes:

• Multi-stage build for optimized image size
• Non-root user for enhanced security
• Health check for container monitoring
• Pinned base image version for reproducible builds

Using with npx

You can run the project directly using npx:

npx copilot-api@latest start

With options:

npx copilot-api@latest start --port 8080

For authentication only:

npx copilot-api@latest auth

To start against the OpenAI OAuth backend:

npx copilot-api@latest auth --backend openai-oauth
npx copilot-api@latest start --backend openai-oauth

Command Structure

Copilot API now uses a subcommand structure with these main commands:

• start: Start the Copilot API server. This command will also handle authentication if needed.
• auth: Run GitHub authentication flow without starting the server. This is typically used if you need to generate a token for use with the --github-token option, especially in non-interactive environments.
• check-usage: Show your current GitHub Copilot usage and quota information directly in the terminal (no server required).
• debug: Display diagnostic information including version, runtime details, file paths, and authentication status. Useful for troubleshooting and support.

Command Line Options

Start Command Options

The following command line options are available for the start command:

Option	Description	Default	Alias
--port	Port to listen on	4141	-p
--idle-timeout	HTTP idle timeout in seconds for Bun. Must be 0-255; use 0 to disable it	255	none
--verbose	Enable verbose logging	false	-v
--log-level	Set runtime log verbosity explicitly (silent, error, warn, info, debug, trace)	none	none
--backend	Select the upstream backend (copilot, openai-oauth)	copilot	none
--account-type	Account type to use (individual, business, enterprise)	individual	-a
--manual	Enable manual request approval	false	none
--rate-limit	Rate limit in seconds between requests	none	-r
--wait	Wait instead of error when rate limit is hit	false	-w
--github-token	Provide GitHub token directly (must be generated using the auth subcommand)	none	-g
--claude-code	Generate a command to launch Claude Code with Copilot API config	false	-c
--ephemeral	Keep dashboard telemetry only in memory for this run; conflicts with --capture	false	none
--capture	Persist proxied request and response exchanges to disk	false	none
--capture-path	Path to the JSONL file used for exchange capture	auto	none
--show-token	Show GitHub and Copilot tokens on fetch and refresh	false	none
--proxy-env	Initialize proxy from environment variables	false	none

Auth Command Options

Option	Description	Default	Alias
--backend	Select the auth backend (copilot, openai-oauth)	copilot	none
--verbose	Enable verbose logging	false	-v
--show-token	Show fetched token material during auth/refresh debugging	false	none

Debug Command Options

Option	Description	Default	Alias
--json	Output debug info as JSON	false	none

API Endpoints

The server exposes several endpoints to interact with the Copilot API. It provides OpenAI-compatible endpoints and now also includes support for Anthropic-compatible endpoints, allowing for greater flexibility with different tools and services.

OpenAI Compatible Endpoints

These endpoints mimic the OpenAI API structure.

Endpoint	Method	Description
POST /v1/chat/completions	POST	Creates a model response for the given chat conversation.
GET /v1/models	GET	Lists the currently available models.
POST /v1/embeddings	POST	Creates an embedding vector representing the input text.
POST /v1/responses	POST	Creates a model response via the OpenAI Responses API.

Anthropic Compatible Endpoints

These endpoints are designed to be compatible with the Anthropic Messages API.

Endpoint	Method	Description
POST /v1/messages	POST	Creates a model response for a given conversation.
POST /v1/messages/count_tokens	POST	Calculates the number of tokens for a given set of messages.

Usage Monitoring Endpoints

New endpoints for monitoring your Copilot usage and quotas.

Endpoint	Method	Description
GET /usage	GET	Get detailed Copilot usage statistics and quota information.
GET /token	GET	Get the current Copilot token being used by the API.

Dashboard UI

Endpoint	Method	Description
GET /dashboard	GET	Open the built-in activity dashboard with backend filtering and live events.

Backend Notes

• --backend copilot keeps the existing GitHub Copilot behavior, including /usage, /token, and embeddings support.
• --backend openai-oauth uses a ChatGPT Plus/Pro OAuth token and routes traffic through the OpenAI Codex-style Responses backend.
• In openai-oauth mode, /v1/chat/completions and /v1/messages are compatibility layers over the Responses backend.
• In openai-oauth mode, /usage, /token, and /v1/embeddings return 501 Not Implemented.
• The dashboard stays unified across all backends and is available at http://localhost:<port>/dashboard.

Example Usage

Using with npx:

# Basic usage with start command
npx copilot-api@latest start

# Run on custom port with verbose logging
npx copilot-api@latest start --port 8080 --verbose

# Use with a business plan GitHub account
npx copilot-api@latest start --account-type business

# Use with an enterprise plan GitHub account
npx copilot-api@latest start --account-type enterprise

# Enable manual approval for each request
npx copilot-api@latest start --manual

# Set rate limit to 30 seconds between requests
npx copilot-api@latest start --rate-limit 30

# Wait instead of error when rate limit is hit
npx copilot-api@latest start --rate-limit 30 --wait

# Disable the HTTP idle timeout for very long-running streaming requests
npx copilot-api@latest start --idle-timeout 0

# Provide GitHub token directly
npx copilot-api@latest start --github-token ghp_YOUR_TOKEN_HERE

# Persist proxied exchanges to the default capture file
npx copilot-api@latest start --capture

# Persist proxied exchanges to a specific JSONL file
npx copilot-api@latest start --capture --capture-path ./captures/session.jsonl

# Keep dashboard telemetry only for this run
npx copilot-api@latest start --ephemeral

# Run only the auth flow
npx copilot-api@latest auth

# Run auth flow with verbose logging
npx copilot-api@latest auth --verbose

# Show your Copilot usage/quota in the terminal (no server needed)
npx copilot-api@latest check-usage

# Display debug information for troubleshooting
npx copilot-api@latest debug

# Display debug information in JSON format
npx copilot-api@latest debug --json

# Initialize proxy from environment variables (HTTP_PROXY, HTTPS_PROXY, etc.)
npx copilot-api@latest start --proxy-env

Using the Dashboard

After starting the server, a URL to the built-in dashboard will be displayed in your console. Open that local URL in your browser to inspect recent traffic, model/token history, backend filters, and live events.

1. Start the server. For example:

   npx copilot-api@latest start

2. Open the local dashboard URL printed by the server, such as:

   http://localhost:4141/dashboard
   

Exchange Capture

When --capture is enabled, the proxy appends one JSON object per proxied exchange to a JSONL file. Captures include the request body, the final response body, request metadata, token usage, and correlation fields such as request IDs when available.

Dashboard telemetry is persisted to ~/.local/share/copilot-api/dashboard.sqlite by default even when --capture is disabled. Existing capture files are backfilled into that SQLite store when persistent telemetry is enabled.

Use --ephemeral to keep dashboard telemetry only in memory for the current process. In ephemeral mode, the dashboard does not persist history across restarts and does not backfill from existing capture files. --ephemeral cannot be combined with --capture.

By default, capture files are written under:

~/.local/share/copilot-api/captures/YYYY-MM-DD.jsonl

Use --capture-path to write to a specific JSONL file instead. Sensitive values such as authorization headers and token-like fields are redacted before they are written to disk.

When using the default daily capture path, the current day remains an appendable .jsonl file and older daily capture files are automatically compressed to .jsonl.gz.

The dashboard provides a user-friendly interface to view your Copilot usage data:

• API Endpoint URL: The dashboard is pre-configured to fetch data from your local server endpoint via the URL query parameter. You can change this URL to point to any other compatible API endpoint.
• Fetch Data: Click the "Fetch" button to load or refresh the usage data. The dashboard will automatically fetch data on load.
• Usage Quotas: View a summary of your usage quotas for different services like Chat and Completions, displayed with progress bars for a quick overview.
• Detailed Information: See the full JSON response from the API for a detailed breakdown of all available usage statistics.
• URL-based Configuration: You can also specify the API endpoint directly in the URL using a query parameter. This is useful for bookmarks or sharing links. For example: https://ericc-ch.github.io/copilot-api?endpoint=http://your-api-server/usage

Using with Claude Code

This proxy can be used to power Claude Code, an experimental conversational AI assistant for developers from Anthropic.

There are two ways to configure Claude Code to use this proxy:

Interactive Setup with --claude-code flag

To get started, run the start command with the --claude-code flag:

npx copilot-api@latest start --claude-code

You will be prompted to select a primary model and a "small, fast" model for background tasks. After selecting the models, a command will be copied to your clipboard. This command sets the necessary environment variables for Claude Code to use the proxy.

Paste and run this command in a new terminal to launch Claude Code.

Manual Configuration with settings.json

Alternatively, you can configure Claude Code by creating a .claude/settings.json file in your project's root directory. This file should contain the environment variables needed by Claude Code. This way you don't need to run the interactive setup every time.

Here is an example .claude/settings.json file:

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:4141",
    "ANTHROPIC_AUTH_TOKEN": "dummy",
    "ANTHROPIC_MODEL": "gpt-4.1",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gpt-4.1",
    "ANTHROPIC_SMALL_FAST_MODEL": "gpt-4.1",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gpt-4.1",
    "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "1",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  },
  "permissions": {
    "deny": [
      "WebSearch"
    ]
  }
}

You can find more options here: Claude Code settings

You can also read more about IDE integration here: Add Claude Code to your IDE

Running from Source

The project can be run from source in several ways:

Development Mode

bun run dev
bun run dev --backend openai-oauth

Production Mode

bun run start
bun run start --backend openai-oauth

Auth Only

bun run auth
bun run auth --backend openai-oauth

Usage Tips

• To avoid hitting GitHub Copilot's rate limits, you can use the following flags:
  • --manual: Enables manual approval for each request, giving you full control over when requests are sent.
  • --rate-limit <seconds>: Enforces a minimum time interval between requests. For example, copilot-api start --rate-limit 30 will ensure there's at least a 30-second gap between requests.
  • --wait: Use this with --rate-limit. It makes the server wait for the cooldown period to end instead of rejecting the request with an error. This is useful for clients that don't automatically retry on rate limit errors.
• If you proxy long-running Responses or chat streams and see Bun log request timed out after 10 seconds, increase --idle-timeout up to 255 or set --idle-timeout 0 to disable the timeout entirely.
• If you have a GitHub business or enterprise plan account with Copilot, use the --account-type flag (e.g., --account-type business). See the official documentation for more details.