Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!
npm install @ashsec/copilot-api/v1/chat/completions, /v1/models, /v1/embeddings) and Anthropic-compatible (/v1/messages) API.
--claude-code).
--rate-limit) and a waiting mechanism (--wait) to prevent errors from rapid requests.
--manual).
--show-token).
sh
bun install
`
Using with Docker
Build image
`sh
docker build -t copilot-api .
`
Run the container
`sh
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.
$3
You can pass the GitHub token directly to the container using environment variables:
`sh
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
`
$3
`yaml
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:
`sh
npx copilot-api@latest start
`
With options:
`sh
npx copilot-api@latest start --port 8080
`
For authentication only:
`sh
npx copilot-api@latest auth
`
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
$3
The following command line options are available for the start command:
| Option | Description | Default | Alias |
| -------------- | ----------------------------------------------------------------------------- | ---------- | ----- |
| --port | Port to listen on | 4141 | -p |
| --verbose | Enable verbose logging | false | -v |
| --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 |
| --show-token | Show GitHub and Copilot tokens on fetch and refresh | false | none |
| --proxy-env | Initialize proxy from environment variables | false | none |
$3
| Option | Description | Default | Alias |
| ------------ | ------------------------- | ------- | ----- |
| --verbose | Enable verbose logging | false | -v |
| --show-token | Show GitHub token on auth | false | none |
$3
| 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.
$3
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. |
$3
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. |
$3
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. |
Example Usage
Using with npx:
`sh
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
Provide GitHub token directly
npx copilot-api@latest start --github-token ghp_YOUR_TOKEN_HERE
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 Usage Viewer
After starting the server, a URL to the Copilot Usage Dashboard will be displayed in your console. This dashboard is a web interface for monitoring your API usage.
1. Start the server. For example, using npx:
`sh
npx copilot-api@latest start
`
2. The server will output a URL to the usage viewer. Copy and paste this URL into your browser. It will look something like this:
https://ericc-ch.github.io/copilot-api?endpoint=http://localhost:4141/usage
- If you use the start.bat script on Windows, this page will open automatically.
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:
$3
To get started, run the start command with the --claude-code flag:
`sh
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.
$3
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:
`json
{
"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:
$3
`sh
bun run dev
`
$3
`sh
bun run start
`
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 : 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 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.