🎯 今日核心问题
- 模型的账单为什么和「token 数 × 单价」算出来的差一截?差额来自哪三类 token?
- 缓存命中的输入和缓存未命中的输入,同一个 prompt 里价格差 10 倍,怎么分开计?
- 一次典型工单任务到底花多少钱?把这个数算到小数点后四位。
📖 精读提纲
【一】计价公式:三段式,不是两段式
单价表上通常有三个数:输入价、输出价、缓存命中输入价。所以一次调用的真实成本是:
cost = (uncachedInputTokens × P_in + cachedInputTokens × P_cache + outputTokens × P_out) / 1_000_000
注意三个陷阱。第一,输出单价通常是输入的 4 倍,所以「让模型回答得啰嗦」比「给它更多上下文」贵得多——一个 800 token 的答复和 200 token 的答复,成本差 3 倍。第二,缓存只对前缀生效,Prompt 里一旦把可变内容(时间戳、用户问题)放在前面,缓存永远命中不了。第三,推理型模型的思考 token 也计费且算输出,账单上常有一项 reasoning_tokens,很贵。
【二】真实算式:一次售后工单任务
取一个真实可复现的场景:用户问「我的订单 A20261208001 显示已发货但三天没物流,能退款吗」。Agent 跑 3 轮 ReAct,调用 2 个工具。
单价比照主流中档模型的公开价(每百万 token,美元):输入 $0.30、缓存命中输入 $0.03、输出 $1.20。
- 第 1 轮:System Prompt 1200 token(稳定前缀,命中缓存)+ 会话历史 600 token + 用户问题 40 token = 输入 1840,其中缓存 1200、未缓存 640。输出 90 token(一个 tool_call)。
- 第 2 轮:输入 = 上轮 1840 + 工具结果 380 = 2220,缓存命中 1840,未缓存 380。输出 60 token(第二个 tool_call)。
- 第 3 轮:输入 = 2220 + 工具结果 520 = 2740,缓存命中 2220,未缓存 520。输出 320 token(最终答复)。
汇总:未缓存输入 640+380+520 = 1540,缓存输入 1200+1840+2220 = 5260,输出 90+60+320 = 470。
cost = (1540 × 0.30 + 5260 × 0.03 + 470 × 1.20) / 1_000_000
= (0.462 + 0.1578 + 0.564) / 1000
= 1.1838 / 1000
= $0.001184 ≈ 0.0085 元(按 7.2 汇率)
若未做缓存: (1540+5260) × 0.30 = 2.04 → 总 2.604 / 1000 = $0.002604
缓存把这次调用降了 54.5%。
再算单量:一天 2 万次工单任务 → 日成本 $23.68,月成本约 $710(≈ 5100 元)。这个数字才是有意义的经营指标,而不是「每百万 token 多少钱」。
【三】把计价做成代码,而不是 Excel
Excel 对不上账的原因永远是「token 数来源不一致」:你在估算,而模型供应商在按自己的分词器算中文。正确做法是以 API 响应里的 usage 字段为准,不要自己 tiktoken 估算;只有在做容量规划时才用估算。
价格要版本化、要能按日期切换——供应商调价、模型换代时,历史报表必须仍按当时的价格复算。所以价格表应该是带 effectiveFrom 的配置,而不是一个常量。
【四】常见误区
- ❌ 用
double存累计成本。几十万次累加后误差肉眼可见,用long存「微美元」。 - ❌ 只算成功请求的成本。失败重试的 token 一样计费,重试率 10% 就意味着成本凭空多 10%。
- ❌ 认为缓存是免费的。部分供应商对「写缓存」收 1.25 倍输入价,对「读缓存」才便宜。得看你的账单明细。
- ❌ 把 embedding 与 rerank 的 token 混在对话成本里。它们单价低两个数量级、量却大得多,混在一起会看不清谁在烧钱。
💻 代码示例
定价表 + 计价器:支持按日期取价、微美元整数、缓存分档:
public record ModelPrice(String model, LocalDate effectiveFrom,
long inputMicroUsdPerMillion,
long cachedInputMicroUsdPerMillion,
long outputMicroUsdPerMillion) {
/** 每百万 token 的微美元价,$0.30/M = 300000 微美元/M */
public static final List<ModelPrice> CATALOG = List.of(
new ModelPrice("model-large", LocalDate.of(2026, 1, 1), 3_000_000, 300_000, 15_000_000),
new ModelPrice("model-medium", LocalDate.of(2026, 1, 1), 300_000, 30_000, 1_200_000),
new ModelPrice("model-small", LocalDate.of(2026, 1, 1), 80_000, 8_000, 240_000));
}
@Component
public class CostCalculator {
private final Map<String, NavigableMap<LocalDate, ModelPrice>> byModel = new HashMap<>();
public CostCalculator() {
for (ModelPrice p : ModelPrice.CATALOG) {
byModel.computeIfAbsent(p.model(), k -> new TreeMap<>()).put(p.effectiveFrom(), p);
}
}
public ModelPrice priceAt(String model, LocalDate date) {
Map.Entry<LocalDate, ModelPrice> e = byModel.getOrDefault(model, new TreeMap<>())
.floorEntry(date);
if (e == null) throw new IllegalStateException("no price for model " + model);
return e.getValue();
}
/** 返回微美元整数 */
public long costMicroUsd(String model, LocalDate date, long input, long cachedInput, long output) {
ModelPrice p = priceAt(model, date);
if (cachedInput > input) throw new IllegalArgumentException("cached > input");
long uncached = input - cachedInput;
long usdMicro = (uncached * p.inputMicroUsdPerMillion()
+ cachedInput * p.cachedInputMicroUsdPerMillion()
+ output * p.outputMicroUsdPerMillion()) / 1_000_000L;
return usdMicro;
}
}
接到上一节的 LoggedChatClient 里,每次调用就记账一次(含失败重试):
Usage u = resp.usage();
long cost = costCalculator.costMicroUsd(
req.model(), LocalDate.now(),
u.promptTokens(), u.cachedTokens(), u.completionTokens());
ledger.append(new TokenLedger.Entry(
traceId, req.model(), u.promptTokens(), u.cachedTokens(), u.completionTokens(), cost));
counter("agent.cost.microusd", "model", req.model()).increment(cost);
log.atInfo().addKeyValue("model", req.model())
.addKeyValue("in", u.promptTokens()).addKeyValue("cached", u.cachedTokens())
.addKeyValue("out", u.completionTokens()).addKeyValue("costMicroUsd", cost)
.log("cost.booked");
一个能自证的单元测试,把上面的手算过程固化成断言(含缓存节省率):
@Test
void typicalTicketTaskCost() {
// 三次调用聚合:未缓存输入 1540、缓存输入 5260、输出 470
long c = calc.costMicroUsd("model-medium", LocalDate.of(2026, 12, 11), 1540 + 5260, 5260, 470);
assertThat(c).isEqualTo(1184L); // $0.001184
long noCache = calc.costMicroUsd("model-medium", LocalDate.of(2026, 12, 11), 1540 + 5260, 0, 470);
assertThat((double) c / noCache).isLessThan(0.5); // 缓存省掉一半以上
// 放大到日/月量级
assertThat(c * 20_000L).isEqualTo(23_680_000L); // 日 $23.68
}
✏️ 今日动手
从线上捞 100 条 trace 的 usage,用 jq 汇总三列 token,套用上面的公式算出真实单次成本,再和你直觉里的估算比一比。然后做一件更有价值的事:把这 100 条按「输出 token 数」排序,看前 10% 的请求吃掉了多少总成本——通常会看到 40% 以上的成本集中在 10% 的请求上,这 10% 就是明天优化的靶子。
🔖 明日预告
算清了钱花在哪,明天开始省:模型降级(什么任务配什么模型)、语义缓存(命中率与风险的平衡)、Prompt 瘦身(从 1840 token 压到 700)。三招叠加,实地把单次成本压到三分之一。