GPT-Load

Server Configuration:

Security Configuration:

Database Configuration:

Performance & CORS Configuration:

Logging Configuration:

Proxy Configuration:

GPT-Load automatically reads proxy settings from environment variables to make requests to upstream AI providers.

Supported Proxy Protocol Formats:

• HTTP: http://user:pass@host:port
• HTTPS: https://user:pass@host:port
• SOCKS5: socks5://user:pass@host:port

Basic Settings:

Request Settings:

Key Configuration:

Migration Scenarios

• Enable Encryption: Encrypt plaintext data for storage - Use --to <new-key>
• Disable Encryption: Decrypt encrypted data to plaintext - Use --from <current-key>
• Change Encryption Key: Replace the encryption key - Use --from <current-key> --to <new-key>

Operation Steps

Docker Compose Deployment

# 1. Update the image (ensure using the latest version)
docker compose pull

# 2. Stop the service
docker compose down

# 3. Backup the database (strongly recommended)
# Before migration, you must manually backup the database or export your keys to avoid key loss due to operations or exceptions.

# 4. Execute migration command
# Enable encryption (your-32-char-secret-key is your key, recommend using 32+ character random string)
docker compose run --rm gpt-load migrate-keys --to "your-32-char-secret-key"

# Disable encryption
docker compose run --rm gpt-load migrate-keys --from "your-current-key"

# Change encryption key
docker compose run --rm gpt-load migrate-keys --from "old-key" --to "new-32-char-secret-key"

# 5. Update configuration file
# Edit .env file, set ENCRYPTION_KEY to match the --to parameter
# If disabling encryption, remove ENCRYPTION_KEY or set it to empty
vim .env
# Add or modify: ENCRYPTION_KEY=your-32-char-secret-key

# 6. Restart the service
docker compose up -d

Source Build Deployment

# 1. Stop the service
# Stop the running service process (Ctrl+C or kill process)

# 2. Backup the database (strongly recommended)
# Before migration, you must manually backup the database or export your keys to avoid key loss due to operations or exceptions.

# 3. Execute migration command
# Enable encryption
make migrate-keys ARGS="--to your-32-char-secret-key"

# Disable encryption
make migrate-keys ARGS="--from your-current-key"

# Change encryption key
make migrate-keys ARGS="--from old-key --to new-32-char-secret-key"

# 4. Update configuration file
# Edit .env file, set ENCRYPTION_KEY to match the --to parameter
echo "ENCRYPTION_KEY=your-32-char-secret-key" >> .env

# 5. Restart the service
make run

Important Notes

⚠️ Important Reminders:

• Once ENCRYPTION_KEY is lost, encrypted data CANNOT be recovered! Please securely backup this key. Consider using a password manager or secure key management system
• Service must be stopped before migration to avoid data inconsistency
• Strongly recommended to backup the database in case migration fails and recovery is needed
• Keys should use 32 characters or longer random strings for security
• Ensure ENCRYPTION_KEY in .env matches the --to parameter after migration
• If disabling encryption, remove or clear the ENCRYPTION_KEY configuration

Key Generation Examples

# Generate secure random key (32 characters)
openssl rand -base64 32 | tr -d "=+/" | cut -c1-32

GPT-Load routes requests to different AI services through group names. Usage is as follows:

1. Proxy Endpoint Format

http://localhost:3001/proxy/{group_name}/{original_api_path}

• {group_name}: Group name created in the management interface
• {original_api_path}: Maintain complete consistency with original AI service paths

2. Authentication Methods

Configure Proxy Keys in the web management interface, which supports system-level and group-level proxy keys.

• Authentication Method: Consistent with the native API, but replace the original key with the configured proxy key.
• Key Scope: Global Proxy Keys configured in system settings can be used in all groups. Group Proxy Keys configured in a group are only valid for the current group.
• Format: Multiple keys are separated by commas.

3. OpenAI Interface Example

GPT-Load currently supports two OpenAI-compatible group types:

• openai (OpenAI Chat Completions format)
• openai-response (OpenAI Responses format)

Assuming a group named openai was created:

Original invocation:

curl -X POST https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer sk-your-openai-key" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4.1-mini", "messages": [{"role": "user", "content": "Hello"}]}'

Proxy invocation:

curl -X POST http://localhost:3001/proxy/openai/v1/chat/completions \
  -H "Authorization: Bearer your-proxy-key" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4.1-mini", "messages": [{"role": "user", "content": "Hello"}]}'

Changes required:

• Replace https://api.openai.com with http://localhost:3001/proxy/openai
• Replace original API Key with the Proxy Key

OpenAI Responses format example (openai-response group):

curl -X POST http://localhost:3001/proxy/openai-response/v1/responses \
  -H "Authorization: Bearer your-proxy-key" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4.1-mini", "input": "Hello"}'

4. Gemini Interface Example

Assuming a group named gemini was created:

Original invocation:

curl -X POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent?key=your-gemini-key \
  -H "Content-Type: application/json" \
  -d '{"contents": [{"parts": [{"text": "Hello"}]}]}'

Proxy invocation:

curl -X POST http://localhost:3001/proxy/gemini/v1beta/models/gemini-2.5-pro:generateContent?key=your-proxy-key \
  -H "Content-Type: application/json" \
  -d '{"contents": [{"parts": [{"text": "Hello"}]}]}'

Changes required:

• Replace https://generativelanguage.googleapis.com with http://localhost:3001/proxy/gemini
• Replace key=your-gemini-key in URL parameter with the Proxy Key

5. Anthropic Interface Example

Assuming a group named anthropic was created:

Original invocation:

curl -X POST https://api.anthropic.com/v1/messages \
  -H "x-api-key: sk-ant-api03-your-anthropic-key" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-sonnet-4-20250514", "messages": [{"role": "user", "content": "Hello"}]}'

Proxy invocation:

curl -X POST http://localhost:3001/proxy/anthropic/v1/messages \
  -H "x-api-key: your-proxy-key" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-sonnet-4-20250514", "messages": [{"role": "user", "content": "Hello"}]}'

Changes required:

• Replace https://api.anthropic.com with http://localhost:3001/proxy/anthropic
• Replace the original API Key in x-api-key header with the Proxy Key

6. Supported Interfaces

OpenAI Chat Completions Format (openai):

• /v1/chat/completions - Chat conversations
• /v1/completions - Text completion
• /v1/embeddings - Text embeddings
• /v1/models - Model list
• And all other OpenAI-compatible interfaces

OpenAI Responses Format (openai-response):

• /v1/responses - Unified response generation
• /v1/models - Model list
• And all other OpenAI Responses-compatible interfaces

Gemini Format:

• /v1beta/models/*/generateContent - Content generation
• /v1beta/models - Model list
• And all other Gemini native interfaces

Anthropic Format:

• /v1/messages - Message conversations
• /v1/models - Model list (if available)
• And all other Anthropic native interfaces

7. Client SDK Configuration

OpenAI Python SDK:

from openai import OpenAI

client = OpenAI(
    api_key="your-proxy-key",  # Use the proxy key
    base_url="http://localhost:3001/proxy/openai"  # Use proxy endpoint
)

response = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[{"role": "user", "content": "Hello"}]
)

Google Gemini SDK (Python):

import google.generativeai as genai

# Configure API key and base URL
genai.configure(
    api_key="your-proxy-key",  # Use the proxy key
    client_options={"api_endpoint": "http://localhost:3001/proxy/gemini"}
)

model = genai.GenerativeModel('gemini-2.5-pro')
response = model.generate_content("Hello")

Anthropic SDK (Python):

from anthropic import Anthropic

client = Anthropic(
    api_key="your-proxy-key",  # Use the proxy key
    base_url="http://localhost:3001/proxy/anthropic"  # Use proxy endpoint
)

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    messages=[{"role": "user", "content": "Hello"}]
)

Important Note: As a transparent proxy service, GPT-Load completely preserves the native API formats and authentication methods of various AI services. You only need to replace the endpoint address and use the Proxy Key configured in the management interface for seamless migration.