ChatGPT

平台特色：OpenAI 兼容模式

本平台采用 OpenAI 兼容格式，让您无需学习新的 API 文档，即可轻松调用 OpenAI 的 ChatGPT 系列模型。

核心优势：一套代码，多种模型

用 OpenAI 格式跑通后，只需要更换模型名称 (model) 即可切换到 Claude、Gemini 等其他大模型，无需重写代码！这种设计让您可以轻松对比不同模型的效果，或根据成本和性能需求灵活切换。

支持的 OpenAI 模型

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

基础信息 & 认证

API 端点 (Endpoint)

https://api.exchangetoken.ai/v1

Chat 请求路径

POST /v1/chat/completions

认证方式

所有 API 请求需要在 Header 中包含认证信息：

Authorization: Bearer YOUR_API_KEY

请求参数 (Chat Completions)

完全兼容 OpenAI /v1/chat/completions 接口参数。

参数	类型	必填	说明
`model`	string	是	模型名称，例如 `gpt-5.4`
`messages`	array	是	对话消息数组，包含 role 和 content
`temperature`	number	否	采样温度，0-2之间，默认1。
`max_completion_tokens`	integer	否	最大生成令牌数。对于 GPT-5 系列模型，优先使用这个字段而不是 `max_tokens`。
`stream`	boolean	否	是否流式返回 (Streaming)，默认 false

完整代码示例

bash

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": "你是一个有用的AI助手。"},
      {"role": "user", "content": "你好！请介绍一下自己。"}
    ],
    "temperature": 0.7,
    "max_completion_tokens": 1000
  }'

python

from openai import OpenAI

# 初始化客户端
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.exchangetoken.ai/v1"
)

# 发送聊天请求
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "你是一个有用的AI助手。"},
        {"role": "user", "content": "你好！请介绍一下自己。"}
    ],
    temperature=0.7,
    max_completion_tokens=1000
)

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

python

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": "你是一个有用的AI助手。"},
        {"role": "user", "content": "你好！请介绍一下自己。"}
    ],
    "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"错误: {result}")

javascript

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": "你是一个有用的AI助手。"},
        {"role": "user", "content": "你好！请介绍一下自己。"}
      ],
      temperature: 0.7,
      max_completion_tokens: 1000
    });
    
    console.log(response.choices[0].message.content);
  } catch (error) {
    console.error('API调用错误:', 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();
        
        // 构建请求体
        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", "你是一个有用的AI助手。"),
            Map.of("role", "user", "content", "你好！请介绍一下自己。")
        );
        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());
        }
    }
}

csharp

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 = "你是一个有用的AI助手。" },
                new { role = "user", content = "你好！请介绍一下自己。" }
            },
            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($"错误: {ex.Message}");
        }
    }
}

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: "你是一个有用的AI助手。"},
            {Role: "user", Content: "你好！请介绍一下自己。"},
        },
        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("请求错误: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

流式响应 (Streaming)

开启流式输出

在请求中设置 stream: true：

json

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

流式响应格式

响应将以 Server-Sent Events (SSE) 格式返回：

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]

错误处理

错误响应格式

json

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

常见错误码

错误码	HTTP状态码	说明
`invalid_api_key`	401	API密钥无效
`insufficient_quota`	429	额度不足
`model_not_found`	404	模型不存在
`invalid_request_error`	400	请求参数错误
`server_error`	500	服务器错误
`rate_limit_exceeded`	429	请求过于频繁

ChatGPT ​

平台特色：OpenAI 兼容模式 ​

支持的 OpenAI 模型 ​

基础信息 & 认证 ​

请求参数 (Chat Completions) ​

完整代码示例 ​

流式响应 (Streaming) ​

开启流式输出 ​

流式响应格式 ​

错误处理 ​

错误响应格式 ​

常见错误码 ​