DOCUMENTATION

Tkone 接口文档

FluxAPI 是 Tkone 平台对外的统一大模型调用接口，完全兼容 OpenAI API 协议——改两行代码（Base URL + API Key）即可无缝接入。

OpenAI 兼容 JSON + SSE v1

产品简介 #

FluxAPI 是 Tkone 平台对外的统一大模型调用接口，完全兼容 OpenAI API 协议——改两行代码（Base URL + API Key）即可无缝接入。

OpenAI 兼容：任何支持 OpenAI SDK / API 规范的客户端、框架、应用都能直接使用
多模型聚合：一个 Key 调用平台上线的全部模型（对话、图像、语音、向量等）
透明计费：按 token 用量计费，价格页明码标价，日志页逐笔可查

快速开始 #

步骤	操作	位置
①	注册账号并完成登录	右上角 → 注册
②	创建应用，获取 API Key（sk- 开头）	控制台 → 应用管理
③	确认可用模型与价格	控制台 → 模型广场
④	用 Base URL + API Key 发起调用	任意 OpenAI 兼容环境

第一次请求示例：

curl -X POST "https://tkonegeo.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "model": "<model>",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "model": "<model>",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
}

response = requests.post("https://tkonegeo.com/v1/chat/completions", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "model": "<model>",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/chat/completions?model=<model>&messages=<messages>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"model\": \"<model>\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\"\n    }\n  ]\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

鉴权 #

所有网关接口通过 HTTP Header 携带 API Key 鉴权。请在「应用管理」中创建应用后获取 Key。

HTTP

Authorization: Bearer sk-xxxxxxxxxxxxxxxxxx

注意：请勿将 API Key 提交到公开代码仓库或分享给他人。如 Key 泄露，请立即在应用管理中禁用或重新生成。

接口文档 #

Base URL 为 https://tkonegeo.com/v1，协议为 OpenAI API 兼容，JSON 请求/响应，流式为 SSE。

模型接口 #

GET/v1/models

列出当前 API Key 可用的所有模型

curl -X GET "https://tkonegeo.com/v1/models" \
  -H "Authorization: Bearer sk-<API_KEY>"

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}

response = requests.get("https://tkonegeo.com/v1/models", headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/models", {
  method: "GET",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  }
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/models"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

GET/v1/models/{model}

获取指定模型的详细信息

请求参数

参数名	类型	必填	说明
model	string	是	模型 ID，如 gpt-4o-mini

curl -X GET "https://tkonegeo.com/v1/models/{model}" \
  -H "Authorization: Bearer sk-<API_KEY>"

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}

response = requests.get("https://tkonegeo.com/v1/models/{model}", headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/models/{model}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  }
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/models/{model}"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

对话接口 #

POST/v1/chat/completions

Chat Completions 接口，兼容 OpenAI 格式，支持流式响应（SSE）

请求参数

参数名	类型	必填	说明
model	string	是	模型 ID
messages	array	是	消息数组 [{role, content}]
stream	bool	否	是否流式响应，默认 false
temperature	float	否	采样温度 0-2
max_tokens	int	否	最大生成 Token 数
top_p	float	否	核采样概率
frequency_penalty	float	否	频率惩罚 -2 到 2
presence_penalty	float	否	存在惩罚 -2 到 2

curl -X POST "https://tkonegeo.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "model": "<model>",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "model": "<model>",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
}

response = requests.post("https://tkonegeo.com/v1/chat/completions", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "model": "<model>",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/chat/completions?model=<model>&messages=<messages>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"model\": \"<model>\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"你好\"\n    }\n  ]\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

POST/v1/completions

文本补全接口（Legacy）

请求参数

参数名	类型	必填	说明
model	string	是	模型 ID
prompt	string	是	提示文本
stream	bool	否	是否流式响应
max_tokens	int	否	最大生成 Token 数
temperature	float	否	采样温度

curl -X POST "https://tkonegeo.com/v1/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "model": "<model>",
  "prompt": "<prompt>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "model": "<model>",
  "prompt": "<prompt>"
}

response = requests.post("https://tkonegeo.com/v1/completions", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "model": "<model>",
  "prompt": "<prompt>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/completions?model=<model>&prompt=<prompt>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"model\": \"<model>\",\n  \"prompt\": \"<prompt>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

POST/v1/edits

文本编辑接口，根据指令修改输入文本

请求参数

参数名	类型	必填	说明
model	string	是	模型 ID
input	string	否	待编辑的文本，默认为空字符串
instruction	string	是	编辑指令
temperature	float	否	采样温度
top_p	float	否	核采样概率

curl -X POST "https://tkonegeo.com/v1/edits" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "model": "<model>",
  "instruction": "<instruction>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "model": "<model>",
  "instruction": "<instruction>"
}

response = requests.post("https://tkonegeo.com/v1/edits", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/edits", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "model": "<model>",
  "instruction": "<instruction>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/edits?model=<model>&instruction=<instruction>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"model\": \"<model>\",\n  \"instruction\": \"<instruction>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

向量接口 #

POST/v1/embeddings

生成文本的向量嵌入

请求参数

参数名	类型	必填	说明
model	string	是	模型 ID
input	string\|array	是	输入文本或文本数组
encoding_format	string	否	编码格式：float \| base64

curl -X POST "https://tkonegeo.com/v1/embeddings" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "model": "<model>",
  "input": "<text>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "model": "<model>",
  "input": "<text>"
}

response = requests.post("https://tkonegeo.com/v1/embeddings", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/embeddings", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "model": "<model>",
  "input": "<text>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/embeddings?model=<model>&input=<input>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"model\": \"<model>\",\n  \"input\": \"<text>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

图像接口 #

POST/v1/images/generations

根据提示词生成图像

请求参数

参数名	类型	必填	说明
model	string	是	模型 ID，如 dall-e-3
prompt	string	是	图像描述提示词
n	int	否	生成数量，默认 1
size	string	否	图像尺寸，如 1024x1024
quality	string	否	图像质量：standard \| hd
response_format	string	否	返回格式：url \| b64_json

curl -X POST "https://tkonegeo.com/v1/images/generations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "model": "<model>",
  "prompt": "<prompt>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "model": "<model>",
  "prompt": "<prompt>"
}

response = requests.post("https://tkonegeo.com/v1/images/generations", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/images/generations", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "model": "<model>",
  "prompt": "<prompt>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/images/generations?model=<model>&prompt=<prompt>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"model\": \"<model>\",\n  \"prompt\": \"<prompt>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

语音接口 #

POST/v1/audio/transcriptions

语音转文本（需 multipart/form-data 上传音频文件）

请求参数

参数名	类型	必填	说明
file	file	是	音频文件
model	string	是	模型 ID，如 whisper-1
language	string	否	音频语言（ISO-639-1）
prompt	string	否	引导文本
response_format	string	否	返回格式：json \| text \| srt \| verbose_json \| vtt
temperature	float	否	采样温度

curl -X POST "https://tkonegeo.com/v1/audio/transcriptions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "file": "<file>",
  "model": "<model>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "file": "<file>",
  "model": "<model>"
}

response = requests.post("https://tkonegeo.com/v1/audio/transcriptions", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/audio/transcriptions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "file": "<file>",
  "model": "<model>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/audio/transcriptions?file=<file>&model=<model>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"file\": \"<file>\",\n  \"model\": \"<model>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

POST/v1/audio/translations

将音频翻译为英文文本

请求参数

参数名	类型	必填	说明
file	file	是	音频文件
model	string	是	模型 ID
prompt	string	否	引导文本
response_format	string	否	返回格式
temperature	float	否	采样温度

curl -X POST "https://tkonegeo.com/v1/audio/translations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "file": "<file>",
  "model": "<model>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "file": "<file>",
  "model": "<model>"
}

response = requests.post("https://tkonegeo.com/v1/audio/translations", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/audio/translations", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "file": "<file>",
  "model": "<model>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/audio/translations?file=<file>&model=<model>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"file\": \"<file>\",\n  \"model\": \"<model>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

POST/v1/audio/speech

文本转语音

请求参数

参数名	类型	必填	说明
model	string	是	模型 ID，如 tts-1
input	string	是	要合成的文本
voice	string	是	音色：alloy \| echo \| fable \| onyx \| nova \| shimmer
response_format	string	否	音频格式：mp3 \| opus \| aac \| flac
speed	float	否	语速 0.25 - 4.0

curl -X POST "https://tkonegeo.com/v1/audio/speech" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "model": "<model>",
  "input": "<input>",
  "voice": "<voice>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "model": "<model>",
  "input": "<input>",
  "voice": "<voice>"
}

response = requests.post("https://tkonegeo.com/v1/audio/speech", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/audio/speech", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "model": "<model>",
  "input": "<input>",
  "voice": "<voice>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/audio/speech?model=<model>&input=<input>&voice=<voice>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"model\": \"<model>\",\n  \"input\": \"<input>\",\n  \"voice\": \"<voice>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

内容审核 #

POST/v1/moderations

检查文本是否违反内容安全策略

请求参数

参数名	类型	必填	说明
input	string\|array	是	待检查的文本
model	string	否	审核模型 ID

curl -X POST "https://tkonegeo.com/v1/moderations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-<API_KEY>" \
  -d '{
  "input": "<text>"
}'

import requests

headers = {
    "Authorization": "Bearer sk-<API_KEY>"
}
json_data = {
  "input": "<text>"
}

response = requests.post("https://tkonegeo.com/v1/moderations", json=json_data, headers=headers)
print(response.status_code)
print(response.json())

const response = await fetch("https://tkonegeo.com/v1/moderations", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk-<API_KEY>"
  },
  body: JSON.stringify({
  "input": "<text>"
})
});
const data = await response.json();
console.log(response.status, data);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://tkonegeo.com/v1/moderations?input=<input>"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer sk-<API_KEY>")
            .post(HttpRequest.BodyPublishers.ofString("{\n  \"input\": \"<text>\"\n}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

响应结构

返回 OpenAI 标准格式，用量在 usage 字段：

JSON

{
  "id": "chatcmpl-xxx",
  "model": "deepseek-chat",
  "choices": [{ "message": { "role": "assistant", "content": "..." } }],
  "usage": {
    "prompt_tokens": 15,
    "completion_tokens": 42,
    "total_tokens": 57
  }
}

第三方客户端接入 #

也可在任何客户端中手动填写：Base URL = https://tkonegeo.com/v1，API Key = 你的应用 Key。

不想写代码？控制台内置 模型体验页可直接测试。

模型与价格 #

价格查询

模型广场：所有可用模型的输入/输出单价，单位元 / 1K tokens，实时来自系统倍率配置
公开接口：GET /api/pricing 返回模型清单与倍率（无需鉴权）
模型可用性：GET /v1/models（按你的应用与分组过滤）

计费规则

JSON

本次扣费 = ( 输入tokens × 模型倍率 + 输出tokens × 模型倍率 × 补全倍率 ) × 分组倍率

换算基准：1 模型倍率 = $0.002/1K tokens ≈ ¥0.014/1K（即 ¥14/百万 tokens）
输出单价 = 输入单价 × 补全倍率（生成比理解更贵）
分组倍率按账户所在分组生效（default 分组 = 1.0）

充值与对账 #

充值

入口：控制台 → 充值中心（在线支付：支付宝 / 微信 / 易支付，支付成功实时到账）
额度换算：到账 quota = 充值金额 ÷ 充值价格 × 500,000
也可使用兑换码充值

对账

控制台 → 日志：每笔调用记录时间、模型、输入/输出 tokens、扣除 quota，可与账单核对。

应用管理 #

应用管理页支持对每个应用 Key 独立设置：

设置	说明
额度上限	该应用累计最多消耗的 quota，防失控
有效期	过期自动失效
模型范围	限定该应用只能调用哪些模型
状态	启用 / 禁用，禁用后 Key 立即失效

多项目/多人使用建议：一人一应用、一项目一应用，单独设额度上限，便于隔离与撤销。

错误码 #

HTTP 状态码	说明	处理
200	请求成功	-
400	请求参数错误	检查请求参数
401	API Key 无效或已禁用	检查 Key 状态与有效期
403	无权使用模型	检查应用的模型范围
404	模型不存在或无可用渠道	确认模型名称正确
429	额度不足或触发限流	充值或降低并发稍后重试
500	上游渠道波动	稍后重试，持续失败联系管理员

错误响应格式（OpenAI 兼容）：

JSON

{
  "error": {
    "message": "错误描述",
    "type": "invalid_request_error",
    "code": "401"
  }
}

常见问题 #

和直接调模型官方 API 有什么区别？

协议完全一致（OpenAI 兼容），区别只在 Base URL 和 Key，以及本平台的统一计费与多模型聚合。价格由平台定价，见模型广场。

一个 Key 可以多人/多项目共用吗？

可以，但建议分应用管理：额度隔离、日志可区分、泄露时单独撤销。

充值后额度没到账？

在线支付到账依赖支付平台异步回调，需站点公网可达；等待 1~2 分钟仍未到账，在订单中核对支付状态，联系管理员处理。

怎么知道某个模型划不划算？

模型广场输出价 ≈ 输入价 × 补全倍率；长回复场景优先看输出价。

可以使用 OpenAI 官方 SDK 吗？

可以。将 base_url 设为本站点地址，api_key 设为你的 Tkone API Key 即可。

文档内容会随平台能力更新。若接口行为与页面不一致，请以控制台实际返回和模型广场价格为准。需要创建应用或查看用量？进入控制台。