13.2 一次请求的计费数学

把「我这一句话到底花了多少钱」算到小数点后四位。

读完你能做什么：手算任意一轮对话的成本，理解为什么长会话的账单按轮数的平方增长，并知道缓存在第几次请求开始回本。

---

一、唯一需要记住的公式

模型是无状态的。每次请求，客户端把全部历史重新发一遍，服务端全部重新计费一次。

本轮总输入 = cache_read_input_tokens
           + cache_creation_input_tokens
           + input_tokens

本轮费用 = cache_read      × 缓存读单价
        + cache_creation  × 缓存写单价
        + input_tokens    × 基础输入单价
        + output_tokens   × 输出单价

三个输入字段的含义，官方定义得很精确：

字段	含义	相对基础输入价
cache_read_input_tokens	断点之前、命中缓存被复用的部分	0.1×
cache_creation_input_tokens	断点之前、本次新写入缓存的部分	1.25×（5 分钟 TTL）/ 2×（1 小时 TTL）
input_tokens	最后一个缓存断点之后的部分	1×
output_tokens	模型生成的内容，含思考 token	见价目表

input_tokens 不是「你这次发了多少」。在缓存工作良好时它会小得离谱（几十个 token），这是最容易被误读的一个字段。

---

二、价目表（2026-07-31 核验）

单位：美元 / 百万 token（MTok）。

模型	基础输入	5 分钟缓存写	1 小时缓存写	缓存读	输出
Claude Fable 5	$10	$12.50	$20	$1	$50
Claude Opus 5	$5	$6.25	$10	$0.50	$25
Claude Sonnet 5（至 2026-08-31）	$2	$2.50	$4	$0.20	$10
Claude Sonnet 5（2026-09-01 起）	$3	$3.75	$6	$0.30	$15
Claude Haiku 4.5	$1	$1.25	$2	$0.10	$5

三个固定倍率，换模型也不变：

5 分钟缓存写 = 基础输入 × 1.25
1 小时缓存写 = 基础输入 × 2
缓存读       = 基础输入 × 0.1

最小可缓存长度（低于此值即使标记了 cache_control 也不会缓存，且不报错）：

模型	最小可缓存 token
Claude Opus 5 / Fable 5 / Mythos 5	512
Claude Sonnet 5 / Opus 4.8	1,024
Claude Haiku 4.5	4,096

价格随时可能调整，且 Batch API、数据驻留等修饰符会与上表倍率叠加。以 platform.claude.com/docs/en/about-claude/pricing 为准。

---

三、直接回答：500k 上下文里问一个 1k 的问题

先给结论：按约 501k 输入 token 计费，不是 1k。 但其中约 500k 走缓存读单价。

以 Claude Opus 5、5 分钟 TTL、输出 1k token 为例：

情形	cache_read	cache_creation	input	output	费用
缓存全命中（正常连续对话）	500,000	2,000	~50	1,000	$0.2878
缓存已过期（离开超过 TTL）	0	501,000	~50	1,000	$3.1565
完全不用缓存（基准参照）	0	0	501,000	1,000	$2.5300

拆开算第一行：

500,000 × $0.50 / 1,000,000 = $0.2500   ← 历史，缓存读
  2,000 × $6.25 / 1,000,000 = $0.0125   ← 上一轮回复 + 本轮提问，写入缓存
     50 × $5.00 / 1,000,000 = $0.0003   ← 断点之后的零头
  1,000 × $25.00 / 1,000,000 = $0.0250  ← 本轮输出
                              ─────────
                               $0.2878

同一个问题，如果上下文只有 10k：

 10,000 × $0.50 / 1,000,000 = $0.0050
  2,000 × $6.25 / 1,000,000 = $0.0125
  1,000 × $25.00 / 1,000,000 = $0.0250
                              ─────────
                               $0.0425

同一句话，在 500k 上下文里问比在 10k 上下文里问贵约 6.8 倍；如果缓存恰好过期，贵约 74 倍。

这就是「切换任务时先 /clear」这条建议的全部数值依据。

---

四、上下文越长，token 消耗越快吗

分两层回答，这两层经常被混为一谈。

单价层面：不会。 每个 token 的价格与上下文长度无关。1M 窗口的模型按标准价计费，没有长上下文加价档。第 500,001 个 token 和第 1 个 token 同价。

流量层面：会，而且是线性增长的每轮开销 + 平方增长的累计开销。

设每轮新增 T 个 token（你的问题 + 模型回复 + 工具结果），则：

第 n 轮的输入量 ≈ n × T          ← 线性
N 轮的累计输入量 = T × N(N+1)/2  ← 平方

取 T = 5,000（一轮里读了一两个文件、跑了一次测试，是很常见的量级）：

轮数 N	第 N 轮输入	累计输入 token	Opus 5 命中缓存	Opus 5 无缓存	Sonnet 5 命中缓存
10	50k	275k	$0.42	$1.38	$0.17
30	150k	2.33M	$2.02	$11.62	$0.81
50	250k	6.38M	$4.62	$31.88	$1.85
100	500k	25.25M	$15.50	$126.25	$6.20

表中只统计输入，不含输出。「命中缓存」按每轮历史全部缓存读、新增部分缓存写（5 分钟 TTL）估算。

两条可以直接换算的推论：

1. 轮数翻倍，累计成本约变成 4 倍。 平方项主导。
2. 每轮新增量 T 减半，全程成本减半。 T 是线性因子，且它同时受「工具输出是否过滤」「回复是否冗长」「是否读了整个文件」控制。

优化 T 比优化 N 更可控 —— 你很难把一个真实任务从 50 轮压到 25 轮，但很容易把每轮的 5k 压到 2.5k。

---

五、输入与输出的计费差异

	输入 token	输出 token
单价	基准 1×	约 5× 基础输入价
计费次数	每轮请求都计一次	生成时计一次，之后作为历史按输入价重复计费
能否缓存	能（降到 0.1×）	生成时不能；进入历史后按输入被缓存
受什么控制	上下文长度	max_tokens、回复冗长度、思考预算

输出的双重计费是一个容易低估的成本源。一段 2,000 token 的冗长回复，在 Opus 5 上：

生成时：2,000 × $25/MTok           = $0.0500
后续 20 轮（无缓存）：
       2,000 × $5/MTok × 20        = $0.2000   ← 是生成成本的 4 倍
后续 20 轮（缓存命中）：
       2,000 × $0.50/MTok × 20     = $0.0200

所以「让 Claude 说得更短」的收益远大于表面上省下的那一次输出费 —— 它在整个会话的剩余生命周期里持续兑现。这也是在 CLAUDE.md 里写「回复保持简洁，不要复述已完成的步骤」的经济学理由。

思考 token

思考（extended thinking）token 按输出计费，只在生成时计一次。之后是否留在上下文里，取决于模型：

模型	历史思考块默认行为	后续成本
Opus 4.5 及更新、Sonnet 4.6 及更新、Fable 5、Mythos 5	保留	作为输入 token 重复计费
更早的 Opus / Sonnet、全部 Haiku	自动剥离	不再产生后续成本

在保留思考块的模型上，高 effort 的成本是复利的。Claude Code 里用 /effort 调档，或对固定思考预算的模型设 MAX_THINKING_TOKENS：

MAX_THINKING_TOKENS=8000 claude    # 自适应推理的模型会忽略非零预算，改用 effort 档

---

六、缓存在第几次请求回本

设基础输入价为 1。复用同一前缀 k 次的总成本：

用缓存（5 分钟 TTL）：1.25 + 0.1 × (k - 1)
用缓存（1 小时 TTL）：2.00 + 0.1 × (k - 1)
不用缓存：           1.00 × k

解出交点：

TTL	回本次数	结论
5 分钟	k ≈ 1.28	第 2 次请求就已经赚了
1 小时	k ≈ 2.11	第 3 次请求开始赚

所以在几乎任何多轮场景里，开缓存都是无脑正确的。真正需要判断的是 TTL 选哪个：

• 请求间隔稳定小于 5 分钟 → 用 5 分钟 TTL，命中即免费续期
• 间隔在 5 分钟到 1 小时之间（人在思考、子代理在跑长任务）→ 1 小时 TTL 更划算
• 间隔常常超过 1 小时 → 不如接受冷启动，或者干脆 /clear

Claude Code 会替你选：订阅计划自动请求 1 小时 TTL；API key 与第三方云默认 5 分钟，用 ENABLE_PROMPT_CACHING_1H=1 开启 1 小时。调试时用 FORCE_PROMPT_CACHING_5M=1 强制回到 5 分钟。

---

七、被压缩吃掉的那笔账

用服务端压缩（compaction）时，账单结构会变，这一点官方专门警告过：

{
  "usage": {
    "input_tokens": 23000,
    "output_tokens": 1000,
    "iterations": [
      { "type": "compaction", "input_tokens": 180000, "output_tokens": 3500 },
      { "type": "message",    "input_tokens": 23000,  "output_tokens": 1000 }
    ]
  }
}

顶层的 input_tokens / output_tokens 不包含压缩迭代的用量。 上例里真实消耗是 203,000 输入 + 4,500 输出，但顶层只显示 23,000 + 1,000。

要算真实账单，必须遍历 usage.iterations 求和：

total_in = sum(it["input_tokens"] for it in resp.usage.iterations)
total_out = sum(it["output_tokens"] for it in resp.usage.iterations)

在 Claude Code 里，/compact 同样是一次完整请求：它把要压缩的对话原样发过去让模型写摘要。缓存热的时候这次请求大部分走缓存读，代价可控；离开超过 TTL 之后再 /compact，就要按全量重新处理整段历史，这是 /compact 最贵的时刻。

---

八、把公式变成一张速算卡

给定：历史长度 H（token）、本轮新增 T、输出 O、模型基础输入价 P。

命中缓存的一轮 ≈ H × 0.1P + T × 1.25P + O × 5P
冷启动的一轮   ≈ (H + T) × 1.25P + O × 5P

代入 Opus 5（P = $5/MTok）的心算版本：

每 10 万 token 历史，命中缓存时每轮约 $0.05
每 10 万 token 历史，冷启动时每轮约 $0.63
每 1000 token 输出，约 $0.025

Sonnet 5 把上面所有数字乘以 0.4，Haiku 4.5 乘以 0.2，Fable 5 乘以 2。

---

延伸阅读

• 13.1 先厘清四本账
• 13.4 缓存命中与击穿的动作全表
• 13.8 诊断与实测方法
• 03.5 Prompt Caching 与成本工程
• 02.5 思维链与 Extended Thinking