ChatGPT

Platform Features: OpenAI Compatibility

This platform adopts the OpenAI compatible format, allowing you to easily call OpenAI's ChatGPT series models without having to learn new API documentation.

Core Advantage: One Codebase, Multiple Models

Once you have the OpenAI format running, you only need to change the model name (model) to switch to Claude, Gemini, or other large models without rewriting code! This design allows you to easily compare results across different models or switch flexibly based on cost and performance needs.

Supported OpenAI Models

• gpt-5.5
• gpt-5.4
• gpt-5.4-mini
• gpt-5.4-nano
• gpt-5.3（gpt-5.3-chat）
• gpt-5.3-codex
• gpt-5.2-codex
• gpt-5.2
• gpt-5.1
• gpt-5
• gpt-5-mini
• gpt-5-nano
• gpt-4.1
• gpt-4.1-mini
• gpt-4.1-nano
• gpt-4o
• gpt-4o-mini

Basic Information & Authentication

API Endpoint

https://api.exchangetoken.ai/v1

Chat Request Path

POST /v1/chat/completions

Authentication

All API requests must include authentication information in the Header:

Authorization: Bearer YOUR_API_KEY

Request Parameters (Chat Completions)

Fully compatible with OpenAI /v1/chat/completions interface parameters.

Parameter	Type	Required	Description
model	string	Yes	Model name, e.g., gpt-5.4
messages	array	Yes	Array of conversation messages, containing role and content
temperature	number	No	Sampling temperature, between 0-2, default 1.
max_completion_tokens	integer	No	Maximum number of generated tokens. For GPT-5 series models, prefer this field over max_tokens.
stream	boolean	No	Whether to stream back (Streaming), default false

Complete Code Examples

cURL

curl -X POST "https://api.exchangetoken.ai/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4",
    "messages": [
      {"role": "system", "content": "You are a helpful AI assistant."},
      {"role": "user", "content": "Hello! Please introduce yourself."}
    ],
    "temperature": 0.7,
    "max_completion_tokens": 1000
  }'

Python (SDK)

from openai import OpenAI

# Initialize client
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.exchangetoken.ai/v1"
)

# Send chat request
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "Hello! Please introduce yourself."}
    ],
    temperature=0.7,
    max_completion_tokens=1000
)

print(response.choices[0].message.content)

Python (requests)

import requests
import json

url = "https://api.exchangetoken.ai/v1/chat/completions"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}

data = {
    "model": "gpt-5.4",
    "messages": [
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "Hello! Please introduce yourself."}
    ],
    "temperature": 0.7,
    "max_completion_tokens": 1000
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

if response.status_code == 200:
    print(result["choices"][0]["message"]["content"])
else:
    print(f"Error: {result}")

Node.js

const OpenAI = require('openai');

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.exchangetoken.ai/v1'
});

async function chatCompletion() {
  try {
    const response = await client.chat.completions.create({
      model: 'gpt-5.4',
      messages: [
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "Hello! Please introduce yourself."}
      ],
      temperature: 0.7,
      max_completion_tokens: 1000
    });
    
    console.log(response.choices[0].message.content);
  } catch (error) {
    console.error('API call error:', error);
  }
}

chatCompletion();

Java

import okhttp3.*;
import com.google.gson.Gson;
import java.io.IOException;
import java.util.*;

public class LaoZhangExample {
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String BASE_URL = "https://api.exchangetoken.ai/v1";
    
    public static void main(String[] args) throws IOException {
        OkHttpClient client = new OkHttpClient();
        Gson gson = new Gson();
        
        // Build request body
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", "gpt-5.4");
        requestBody.put("temperature", 0.7);
        requestBody.put("max_completion_tokens", 1000);
        
        List<Map<String, String>> messages = Arrays.asList(
            Map.of("role", "system", "content", "You are a helpful AI assistant."),
            Map.of("role", "user", "content", "Hello! Please introduce yourself.")
        );
        requestBody.put("messages", messages);
        
        RequestBody body = RequestBody.create(
            gson.toJson(requestBody),
            MediaType.parse("application/json")
        );
        
        Request request = new Request.Builder()
            .url(BASE_URL + "/chat/completions")
            .addHeader("Authorization", "Bearer " + API_KEY)
            .addHeader("Content-Type", "application/json")
            .post(body)
            .build();
        
        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}

C#

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
    private static readonly string API_KEY = "YOUR_API_KEY";
    private static readonly string BASE_URL = "https://api.exchangetoken.ai/v1";
    
    static async Task Main(string[] args)
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {API_KEY}");
        
        var requestBody = new
        {
            model = "gpt-5.4",
            messages = new[]
            {
                new { role = "system", content = "You are a helpful AI assistant." },
                new { role = "user", content = "Hello! Please introduce yourself." }
            },
            temperature = 0.7,
            max_completion_tokens = 1000
        };
        
        var json = JsonConvert.SerializeObject(requestBody);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        try
        {
            var response = await client.PostAsync($"{BASE_URL}/chat/completions", content);
            var result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type Message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type ChatRequest struct {
    Model       string    `json:"model"`
    Messages    []Message `json:"messages"`
    Temperature float64   `json:"temperature"`
    MaxCompletionTokens int       `json:"max_completion_tokens"`
}

func main() {
    apiKey := "YOUR_API_KEY"
    baseURL := "https://api.exchangetoken.ai/v1"
    
    reqData := ChatRequest{
        Model: "gpt-5.4",
        Messages: []Message{
            {Role: "system", Content: "You are a helpful AI assistant."},
            {Role: "user", Content: "Hello! Please introduce yourself."},
        },
        Temperature: 0.7,
        MaxTokens:   1000,
    }
    
    jsonData, _ := json.Marshal(reqData)
    
    req, _ := http.NewRequest("POST", baseURL+"/chat/completions", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Request error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Streaming Response

Enable Streaming Output

Set stream: true in the request:

{
  "model": "gpt-5.4",
  "messages": [{"role": "user", "content": "Hello"}],
  "stream": true
}

Streaming Response Format

Responses will be returned in Server-Sent Events (SSE) format:

data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1699000000,"model":"gpt-5.4","choices":[{"delta":{"content":"Hello"},"index":0}]}

data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1699000000,"model":"gpt-5.4","choices":[{"delta":{"content":" there"},"index":0}]}

data: [DONE]

Error Handling

Error Response Format

{
  "error": {
    "message": "Invalid API key provided",
    "type": "invalid_request_error",
    "param": null,
    "code": "invalid_api_key"
  }
}

Common Error Codes

Error Code	HTTP Status Code	Description
invalid_api_key	401	Invalid API key
insufficient_quota	429	Insufficient quota
model_not_found	404	Model not found
invalid_request_error	400	Invalid request parameters
server_error	500	Internal server error
rate_limit_exceeded	429	Request frequency too high (Rate limit exceeded)