理解 Token 用量：AI API 计费开发者指南

"每百万 Token 只需 $0.25"——听起来很便宜，直到你发现你的聊天机器人每月消耗了 2 亿个 Token，而你完全没有心理准备。

Token 计费是 AI API 的通用定价模式，但其中充满了意外：同一个英文句子，用日语写出来会贵 3 倍；编程任务中一个简单的"yes"可能消耗 400 个 Token；推理模型更会在你完全看不到的情况下悄悄烧掉数千个 Token。

本指南涵盖理解 Token 用量、准确估算成本以及避免计费意外所需的一切知识。

---

什么是 Token？

Token 是 LLM 处理的最小文本单元——大致相当于一个词的片段。单词 "unbelievable" 可能被分词为 ["un", "believe", "able"] ——三个 Token。而 "cat" 通常只占一个 Token。

Token vs 字符 vs 单词

| 文本 | 字符数 | 单词数 | Token 数 (GPT 分词器) | |------|-----------|-------|----------------------| | "Hello" | 5 | 1 | 1 | | "unbelievable" | 12 | 1 | 3 | | "The quick brown fox" | 19 | 4 | 4 | | "こんにちは" (日语) | 5 | 1 | 5 | | "print('hello')" | 14 | 1 | 7 |

经验法则：1 个 Token ≈ 0.75 个英文单词 ≈ 4 个字符。但这个比例会因语言和内容类型的不同而有显著差异。

为什么分词会影响你的账单

不同模型使用不同的分词器。GPT-4o 和 DeepSeek 都使用 BPE（字节对编码）分词器的变体，但它们的词汇表不同。一个在 GPT-4o 上是 100 个 Token 的提示词，在 DeepSeek V4 Flash 上可能是 120 个 Token——20% 的差异会在数百万次请求中被放大。

---

AI API 如何计算和计费 Token

每次 API 调用都根据两个数字计费：

1. 输入 Token：你发送的所有内容——系统提示词、对话历史、用户消息
2. 输出 Token：模型生成的所有内容——包括停止序列等不可见 Token

计费公式

成本 = (输入 Token 数 × 输入费率) + (输出 Token 数 × 输出费率)

以 DeepSeek V4 Flash 通过 Global API 为例（统一费率 $0.25/M）：

提示词：800 Token
回复：500 Token
总计：1,300 Token

成本 = 1,300 × ($0.25 / 1,000,000) = $0.000325

看起来微不足道，对吧？现在放大来看：每天 10 万次 API 调用 = $32.50/天 = $975/月。这还不包括系统提示词、对话历史和推理 Token。

Global API 为什么使用统一费率定价

传统 AI 服务商对输入和输出 Token 收取不同的价格（输出通常贵 3-5 倍）。这使得成本估算变得不可预测——在调用完成之前，你无法知道输出的长度。

Global API 为每个模型采用统一费率定价：输入和输出 Token 的价格相同。这使得成本估算变得简单明了：

| 模型 | 统一费率 / 1M Token | 每次 1K Token 调用成本 | |-------|----------------------|-------------------| | GA-Economy | $0.125 | $0.000125 | | Qwen3-8B | $0.01 | $0.00001 | | DeepSeek V4 Flash | $0.25 | $0.00025 | | GLM-5 | $1.92 | $0.00192 | | MiniMax M2.5 | $1.15 | $0.00115 | | Kimi K2.5 | $3.00 | $0.003 |

查看完整定价

---

Token 计数工具与代码

方案一：tiktoken（Python）

在发送请求前计算 Token 数的最准确方式：

import tiktoken

# GPT 系列分词器（适用于大多数 OpenAI 兼容模型）
encoding = tiktoken.get_encoding("cl100k_base")

def count_tokens(text: str) -> int:
    return len(encoding.encode(text))

# 系统提示词
system = "You are a helpful assistant. Answer concisely."
print(f"系统提示词: {count_tokens(system)} tokens")

# 用户消息
user = "Explain quantum entanglement in simple terms."
print(f"用户消息: {count_tokens(user)} tokens")

# 对话历史
history = [
    {"role": "system", "content": system},
    {"role": "user", "content": user},
    {"role": "assistant", "content": "Imagine two coins that always land the same way..."},
    {"role": "user", "content": "Can we use this for communication?"},
]
total = sum(count_tokens(m["content"]) for m in history)
print(f"完整对话: {total} tokens")

方案二：JavaScript（js-tiktoken）

import { encodingForModel } from "js-tiktoken";

const enc = encodingForModel("gpt-4");

function countTokens(text) {
  return enc.encode(text).length;
}

const messages = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "What is a token in LLM APIs?" },
];

let total = 0;
for (const msg of messages) {
  // OpenAI 每条消息额外添加约 4 个 Token 的格式化开销
  total += countTokens(msg.content) + 4;
}
total += 2; // 引导 Token

console.log(`预估 Token 数: ${total}`);

方案三：内置用量数据（最可靠）

每次 API 响应都包含实际的 Token 计数：

import openai

client = openai.OpenAI(
    api_key="a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6",
    base_url="https://global-apis.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "你好"}],
)

usage = response.usage
print(f"提示词 Token: {usage.prompt_tokens}")
print(f"补全 Token: {usage.completion_tokens}")
print(f"总 Token 数: {usage.total_tokens}")

---

让开发者措手不及的隐藏 Token 成本

1. 系统提示词税

一条 500 个 Token 的系统提示词随每次请求发送，累积速度惊人：

500 Token × 每天 100,000 次请求 × 30 天 = 每月 15 亿 Token
按 $0.25/M Token 计算：每月 $375 —— 仅仅花在系统提示词上。

解决方案：将系统提示词控制在 100 个 Token 以内。使用简洁的指令。考虑使用基于模板的系统提示词，仅在需要时才展开。

2. 对话历史累积

对话中每一轮都会将完整历史附加到下一次请求中：

第 1 轮：100 Token（用户）+ 200 Token（助手）= 300 Token
第 2 轮：300（历史）+ 100（新用户）+ 300（助手）= 700 Token
第 3 轮：700 + 100 + 300 = 1,100 Token
第 10 轮: 3,100 + 100 + 300 = 3,500 Token

10 轮之后，每次请求的成本是第一轮的 10 倍。

解决方案：将历史记录限制在最近的 N 轮。用廉价模型对更早的消息进行摘要：

def trim_history(messages: list[dict], max_turns: int = 6) -> list[dict]:
    """只保留最近的 N 对用户-助手消息。"""
    # 始终保留系统消息
    system = [m for m in messages if m["role"] == "system"]

    # 保留最近 N 条非系统消息
    non_system = [m for m in messages if m["role"] != "system"]
    recent = non_system[-(max_turns * 2):]

    return system + recent

3. 推理 Token 开销（DeepSeek R1、o1、QwQ）

推理模型在输出最终答案之前会生成内部的"思考"Token。这些 Token 会计入你的用量，但通常不会在 API 响应中显示：

# 通过 Global API 使用 DeepSeek R1
response = client.chat.completions.create(
    model="deepseek-r1",
    messages=[{"role": "user", "content": "计算：345 × 678"}],
)

# 响应可能看起来只有 50 个 Token 的可见输出，
# 但模型内部消耗了 2,000+ 个推理 Token
print(f"计费 Token 数: {response.usage.total_tokens}")
# 计费 Token 数: 2,312 —— 不是 50！

原则：只在任务确实需要时才使用推理模型。对于简单数学，用标准模型即可。将 R1 留给多步逻辑和难题。

4. 非英语语言

LLM 对非英语文本的分词效率较低：

| 文本 | 语言 | Token 数 | |------|----------|--------| | "Hello, how are you today?" | 英语 | 7 | | "こんにちは、今日はお元気ですか？" | 日语 | 15 | | "你好，你今天好吗？" | 中文 | 13 | | "Привет, как дела сегодня?" | 俄语 | 18 |

一个中文聊天机器人的每条消息成本大约是英文的两倍。如果你服务多语言用户，需要相应做好预算。

---

构建 Token 成本估算器

以下是一个完整的成本估算工具，你可以在部署前使用：

# cost_estimator.py
import tiktoken

MODEL_PRICING = {
    # 统一费率定价（Global API）—— $/1M Token
    "deepseek-v4-flash": 0.25,
    "deepseek-v3.2": 0.378,
    "deepseek-r1": 2.50,
    "qwen3-235b-a22b": 1.82,
    "qwen3-8b": 0.01,
    "glm-5": 1.92,
    "glm-4-9b": 0.01,
    "kimi-k2.5": 3.00,
    "minimax-m2.5": 1.15,
    "ga-economy": 0.125,
    "ga-standard": 0.20,
    "ga-express": 0.25,
}

def estimate_monthly_cost(
    model: str,
    daily_requests: int,
    avg_prompt_tokens: int,
    avg_completion_tokens: int,
) -> dict:
    """根据预期用量估算月度 API 成本。"""
    rate = MODEL_PRICING.get(model, 0.50)
    total_tokens_per_call = avg_prompt_tokens + avg_completion_tokens
    daily_tokens = daily_requests * total_tokens_per_call
    monthly_tokens = daily_tokens * 30

    cost_per_call = (total_tokens_per_call / 1_000_000) * rate
    monthly_cost = (monthly_tokens / 1_000_000) * rate

    return {
        "model": model,
        "rate_per_million": rate,
        "daily_requests": daily_requests,
        "avg_tokens_per_call": total_tokens_per_call,
        "cost_per_call": round(cost_per_call, 6),
        "daily_tokens": daily_tokens,
        "monthly_tokens": monthly_tokens,
        "monthly_cost": round(monthly_cost, 2),
    }

# 示例：客服聊天机器人
result = estimate_monthly_cost(
    model="deepseek-v4-flash",
    daily_requests=5000,
    avg_prompt_tokens=600,
    avg_completion_tokens=300,
)

print(f"模型: {result['model']}")
print(f"单次调用成本: ${result['cost_per_call']}")
print(f"月度成本: ${result['monthly_cost']}")
# 模型: deepseek-v4-flash
# 单次调用成本: $0.000225
# 月度成本: $33.75

逐模型成本对比

def compare_models(daily_requests: int, prompt_tokens: int, completion_tokens: int):
    """对比各模型的月度成本。"""
    print(f"{'模型':<25} {'费率/M':>8} {'$/次':>8} {'$/月':>10}")
    print("-" * 55)

    for model, rate in sorted(MODEL_PRICING.items(), key=lambda x: x[1]):
        result = estimate_monthly_cost(model, daily_requests, prompt_tokens, completion_tokens)
        print(
            f"{model:<25} ${rate:>6.3f} "
            f"${result['cost_per_call']:>7.5f} "
            f"${result['monthly_cost']:>9.2f}"
        )

# 每天 10,000 次请求，500 提示词 + 300 输出
compare_models(10000, 500, 300)

示例输出：

模型                     费率/M   $/次     $/月
-------------------------------------------------------
qwen3-8b                  $0.010  $0.00001     $2.40
glm-4-9b                  $0.010  $0.00001     $2.40
ga-economy                $0.125  $0.00010    $30.00
ga-standard               $0.200  $0.00016    $48.00
deepseek-v4-flash         $0.250  $0.00020    $60.00
ga-express                $0.250  $0.00020    $60.00
deepseek-v3.2             $0.378  $0.00030    $90.72
minimax-m2.5              $1.150  $0.00092   $276.00
qwen3-235b-a22b           $1.820  $0.00146   $436.80
glm-5                     $1.920  $0.00154   $460.80
deepseek-r1               $2.500  $0.00200   $600.00
kimi-k2.5                 $3.000  $0.00240   $720.00

最便宜（$2.40/月）和最贵（$720.00/月）之间的差距高达 300 倍。为你的任务选择正确的模型，是控制 AI 账单的最大杠杆。

---

三个常见计费场景（以及它们的真实成本）

场景一：周末项目聊天机器人

模型: DeepSeek V4 Flash ($0.25/M)
用量: 每天 50 次对话，平均每轮 8 轮
每轮: 系统(200) + 用户(100) + 助手(300) = 平均 600
总计: 50 × 8 × 600 = 每天 240,000 Token = 每月 7.2M
成本: 7.2 × $0.25 = $1.80/月

结论: 你在信用卡账单上根本不会注意到它。

场景二：SaaS 产品（1 万日活用户）

模型: GA-Standard ($0.20/M)
用量: 10,000 用户，平均每人 5 次查询
每轮: 系统(300) + 历史(500) + 用户(200) + 助手(400) = 平均 1,400
总计: 50,000 × 1,400 = 每天 70M Token = 每月 2.1B
成本: 2,100 × $0.20 = $420/月

结论: 合理。添加缓存可以将其降至约 $250。

场景三：AI 编程助手（1 万开发者）

模型: MiniMax M2.5 ($1.15/M) + Kimi K2.5 ($3.00/M)
用量: 10,000 开发者，每人 20 次请求
配比: 70% M2.5（简单），30% K2.5（复杂）
每轮: 1,200 平均（代码上下文量大）
总计: 200,000 × 1,200 = 每天 240M Token = 每月 7.2B
成本 (M2.5): 5,040 × $1.15 = $5,796
成本 (K2.5): 2,160 × $3.00 = $6,480
总计: $12,276/月

结论: 不容忽视。考虑分层路由 + 语义缓存。

---

减少 Token 用量的快速见效方法

1. 精简系统提示词——每节省 100 个 Token，就是 100 × 请求次数 × 30 天 更少的计费 Token
2. 限制对话历史——不要发送完整聊天记录；保留最近 6 轮即可
3. 使用 max_tokens——限制输出 Token 数，防止失控的回复耗尽你的预算
4. 按端点追踪用量——为 API 调用添加元数据标签，识别哪些功能在消耗 Token
5. 选择合适的模型——"hello world" 不需要 Kimi K2.5

关于包括缓存、提示词压缩和分层路由在内的完整成本优化策略，请参阅我们的多模型成本优化指南。

---

开始追踪你的 Token 用量

Global API 为你提供实时 Token 用量仪表板、按模型分类的成本追踪，以及让成本估算变得可预测的统一费率定价。无意外。

• 注册 — 100 免费积分 — 无需信用卡
• 完整定价页面
• API 文档