Claude 的令牌是什么，又是怎么运作的？我们数了 38 亿个

在 Claude 周围，这个词随处可见：价目表里、限额提示里、/usage 里，以及每一篇教你省钱的文章里。几乎没人说清令牌是什么，而人们盯着的数字很少是真正重要的那个。Claude 写回的部分，不到一次编码会话所计数量的百分之一。

所以我们数了自己的。在一台 Mac 上运行的 30 天 Claude Code 会话，从 2026 年 9 月 10 日到 10 月 9 日：388 个会话，19,668 次模型请求，38 亿令牌。下面讲令牌是什么、Claude 统计它的四种方式，以及这些数字在真实工作中的样子。

令牌是一段文本，而这段文本的大小会变

模型不读字母，也不读词。它读的是令牌：取自固定词表的文本片段，有时是完整的短词，常常是词的一部分，遇到没见过的东西时，有时是单个字符或字节。一切都按这些片段计数：你发送的、Claude 写的、它在轮与轮之间保存的。

一个令牌能装下多少文本，取决于模型和语言。Anthropic 的术语表给出的是：在 Claude 4.7 之前的模型上，每个令牌约 3.5 个英文字符；Claude 4.7 及之后的模型使用新的分词器，同样的文本会多出约 30% 的令牌。精确数字只能通过 令牌计数端点 获得，并指定你打算用的模型。

我们用自己的文本测了这个比例。我们的代理用法语回答，所以挑出纯文本回答：没有思考、没有工具调用、没有代码块、至少 80 个词。共 296 条，分布在 Opus 5、Opus 5.5、Fable 5.1 和 Sonnet 5.5 上。中位数是每个令牌 2.3 个字符，约合每个词 2.6 令牌。代码、JSON 和非拉丁文字的比例各不相同。重点不在精确数字：令牌比词小，你也永远不会手工去数。

每次请求都记在四个计数器上

Claude Code 把每个会话写进 ~/.claude/projects/ 下的 JSONL 转录文件。模型的每个回答都带一个 usage 块。下面是我们转录中的真实例子，只保留有用的字段：

"usage": {
  "input_tokens": 2,
  "cache_creation_input_tokens": 51836,
  "cache_read_input_tokens": 24882,
  "output_tokens": 315,
  "output_tokens_details": { "thinking_tokens": 54 },
  "cache_creation": {
    "ephemeral_1h_input_tokens": 51836,
    "ephemeral_5m_input_tokens": 0
  }
}

四个计数器，价格各不相同：

• input_tokens：提示词中既没有写入缓存、也没有从缓存读取的部分，按基础输入价格计费。在 Claude Code 里它几乎总是寥寥几个令牌，因为几乎一切都走缓存。
• cache_creation_input_tokens：提示词中存入缓存、供下一次请求复用的部分。缓存写入的价格是：5 分钟缓存为输入价格的 1.25 倍，1 小时缓存为 2 倍。在我们的转录中，97% 的写入是 1 小时缓存。
• cache_read_input_tokens：提示词中从缓存里重放的部分。缓存读取的价格是：大多数模型上为输入价格的 0.1 倍，Opus 5.5 和 Sonnet 5.5 上为 0.05 倍，Fable 5.1 上为 0.025 倍（Anthropic 的提示词缓存页面，2026 年 10 月 10 日核对）。
• output_tokens：Claude 写出的内容，包括思考。在所有现行模型上，输出价格都是输入价格的 5 倍：每百万令牌 Opus 5.5 为 20 美元，Opus 5 为 25 美元，Fable 5.1 为 50 美元，Sonnet 5.5 为 10 美元。

前三个相加，就是模型这次请求读取的上下文。第四个是回答。

我们 30 天的会话是什么样子

对 19,668 次请求，每次请求只计一次（一次 API 调用可能占据转录中的多行）：

成本一列按每次请求自己的模型和缓存时长计价。我们并没有付这笔钱：这些会话跑在订阅上。它是每个计数器的权重，和 AgentsRoom 在项目之间分摊套餐百分比时用的权重相同。

三点解读。

几乎每个令牌都是被重新读取的对话。 97.7% 的令牌是缓存读取。99.2% 的请求都从缓存里读了些东西。有人说一个会话“用了 5,000 万令牌”时，看的就是这个。

Claude 写出的内容在令牌上很少，在成本上并不少。 占令牌的 0.34%，占账单的 16.8%，因为输出是最贵的令牌。其中 29% 是思考。

缓存写入是代价高昂的意外。 占令牌的 2%，占成本的 37%。我们原以为它们来自缓存过期，但 19,668 次请求中只有 16 次不得不重写冷掉的上下文，其中七次是在一小时以上没有动静之后。79% 的写入只是每条新消息和每个工具结果各存储一次，价格是输入的两倍，之后每一轮都被重新读取。其余 20% 是每个会话的第一次请求。

为什么会话每多一轮就更重

模型在两次请求之间什么都不保留。Claude Code 每次都重新发送一切：系统提示词、工具定义、CLAUDE.md、每条消息、读过的每个文件、每条命令输出。缓存让重复部分的每令牌价格变低，但不免费，也不变小。

按会话中的位置，每次请求读取的上下文中位数：

中位数请求为了写出 290 令牌的回答，读取了 179,000 令牌的上下文。这个比例就是编码代理里令牌的全部故事：回答短，读取长，而且读取随会话增长。

我们的第一次请求很重，没人输入任何东西就已有 52,000 令牌，因为我们的代理启动时带着一份很长的角色说明，以及四个工具定义都放在提示词里的 MCP 服务器。在空文件夹里启动的裸 Claude Code 会话，起点低得多。/context 会显示你的会话在第一条消息之前带着什么。

一个会话用掉多少

在 380 个至少有三次请求的会话中：

• 中位数 33 次请求，中间一半为 16 到 61 次。
• 中位数 27,000 输出令牌，12,000 到 48,000。
• 中位数 处理 540 万令牌，中间一半为 150 万到 1,070 万，其中 510 万是缓存读取。
• 中位数 181,000 令牌 写入缓存或以未缓存方式发送：真正新增的部分。
• 按 API 标价中位数 4.55 美元，中间一半为 1.81 到 9.25 美元。

所以，“一次编码会话用掉多少令牌”的诚实答案是大约一百万到一千万，几乎全是同一段上下文被反复读取。整个下午跑一个长任务的会话处在顶端；修好一个 bug 就停下的会话处在底端。

5 小时窗口和每周窗口实际计量的是什么

在 Pro 或 Max 套餐上，你永远看不到令牌余额。Anthropic 帮助中心说，两种套餐都有五小时会话限制和每周限制，这些限制由 Claude 和 Claude Code（含 IDE）共享，Max 套餐对 Fable 另有单独的每周限制。它没有为任何一项公布令牌数字。/usage 显示每个窗口的百分比和重置时间。

按 Anthropic 自己的列表，让这个百分比变化的因素是：消息长度、附件大小、当前对话长度、工具使用、模型选择、推理强度，以及多步骤任务。结合上面的表格，主导编码会话的是“当前对话长度”：每次请求读取的上下文在五十次请求内从 52,000 令牌增长到 237,000 个。帮助中心还说，项目中缓存的内容复用时对限额消耗更少，这和缓存读取的价格是同一思路。

我们不知道 Anthropic 如何把令牌换算成窗口百分比，也不会编造换算方式。数据能说明的是：同一个问题，长会话后期的一次请求，计数是早期请求的好几倍。

实际中改变计数的因素

四个杠杆，按它们在我们数据中的影响排序：

• 在不相关的任务之间用 /clear。 Anthropic 称它为“对质量和成本都最有效的单一杠杆”。在旧会话里做新任务，每次请求都要为旧任务的上下文买单。
• 继续一个长会话时用 /compact。 它把历史换成简短摘要，后续请求读得更少。
• 留意进入上下文的内容。 一次 20,000 令牌的文件读取或命令输出，会以两倍输入价格写入一次，然后在会话结束前的每次请求中被重新读取。只读需要的那几行而非整个文件，能省两次。
• 模型和推理强度。 思考占我们输出的 29%，而输出是最贵的令牌。日常工作降低推理强度可减少输出，换用更便宜的模型则让所有价格一起下降。

在我们数据中没影响的：让会话闲置。在我们转录中 Claude Code 使用的 1 小时缓存下，30 天里冷重写只发生了 16 次。

想了解更多省钱方法，请看 如何降低 Claude Code 的令牌成本。

数一数你自己的

上面的表格来自一个无依赖的脚本。它读取本机所有 Claude Code 转录，每次请求只计一次，打印四个计数器和每个会话的中位数。想限定时间范围，就在 o["timestamp"] 上加个过滤条件。

import json, glob, os, statistics as st
from collections import defaultdict

FIELDS = ("input_tokens", "cache_creation_input_tokens",
          "cache_read_input_tokens", "output_tokens")
totals, sessions = defaultdict(int), []
for path in glob.glob(os.path.expanduser("~/.claude/projects/*/*.jsonl")):
    seen, session = set(), defaultdict(int)
    with open(path, errors="ignore") as fh:
        for line in fh:
            try: o = json.loads(line)
            except ValueError: continue
            msg = o.get("message") or {}
            usage = msg.get("usage") if isinstance(msg, dict) else None
            if o.get("type") != "assistant" or not usage: continue
            rid = o.get("requestId") or o.get("uuid")
            if rid in seen: continue   # one API call can span several lines
            seen.add(rid)
            session["requests"] += 1
            for f in FIELDS:
                n = usage.get(f) or 0
                totals[f] += n
                session[f] += n
    if session["requests"] >= 3: sessions.append(session)

grand = sum(totals[f] for f in FIELDS)
for f in FIELDS:
    print(f"{f:30s} {totals[f]:>15,} {100 * totals[f] / grand:6.2f}%")
for key in ("requests", "output_tokens", "cache_read_input_tokens"):
    print(f"median per session, {key}: {st.median(s[key] for s in sessions):,.0f}")

把你的比例和我们的比一比。缓存读取那行是被重新读取的对话，缓存写入那行是新增的内容：这两行比输出那行更能说明你的账单。

AgentsRoom 在哪里显示这些

脚本给你的是一个月的数据。你工作时，AgentsRoom 按代理显示同样的计数器：每个会话输入框里的令牌徽章，会话变重时会变红；会话监视器，显示输入、输出、缓存写入、缓存读取和缓存命中率；以及会话追踪，逐轮重放会话，指出是哪次文件读取或哪个工具结果填满了上下文。用量面板把套餐报告的百分比分摊到你的项目和代理上，按每个会话的 API 价格成本加权，和上表权重相同。

这些界面都不给你令牌余额，因为你的套餐根本没有余额。关于这个问题，请看 我在 Claude 里还剩多少令牌。关于这些输出令牌到达的速度，请看 Claude Code 每秒令牌数实测。

常见问题

Claude 里的令牌是什么？

Claude 读写文本的单位：词的一个片段，有时是一个完整的短词，有时是单个字符或一个字节。Anthropic 表示，令牌的大小取决于模型和语言：在 Claude 4.7 之前的模型上，一个令牌约等于 3.5 个英文字符，Claude 4.7 及之后的模型使用新的分词器，同样的文本会多出约 30% 的令牌。Claude 做的一切都按令牌计量：你发送的内容、它写回的内容，以及它在轮与轮之间保存在缓存里的内容。

一个 Claude 令牌等于多少字符或多少个词？

取决于语言和文本。Anthropic 给出的数字是：在 Claude 4.7 之前的模型上每个令牌约 3.5 个英文字符，在 Claude 4.7 及之后的模型上，同样的文本令牌数多出约 30%。在我们的代理于 2026 年 9 月和 10 月用法语写的 296 条纯文本回答中，一个令牌是 2.3 个字符，约合每个词 2.6 令牌。代码、JSON 和非拉丁文字的比例各不相同。要得到精确数字，可以把文本和模型交给 Anthropic 的令牌计数端点。

为什么 Claude Code 会消耗这么多令牌？

因为每次请求都会把整个对话重新发送一遍：系统提示词、工具定义、CLAUDE.md、迄今为止的每条消息和每个工具结果。在我们的 19,668 次请求中，中位数请求为了写出 290 令牌的回答，携带了 179,000 令牌的上下文；上下文从会话第一次请求时的 52,000 令牌，增长到五十次请求之后的 237,000 个。缓存让这种重复读取的每令牌价格很低，但它仍然会被计数。

一个典型的 Claude Code 会话会用掉多少令牌？

在我们 2026 年 9 月 10 日至 10 月 9 日记录的 380 个至少有三次请求的会话中：中位数为 33 次请求、27,000 个输出令牌、总共处理 540 万令牌，其中 510 万个是缓存读取。一半的会话落在 150 万到 1,070 万令牌之间。按 API 标价计算，这个中位数会话大约要花 4.55 美元；在 Pro 或 Max 套餐上，同样的工作则改为计入 5 小时窗口和每周窗口。

思考令牌算不算？

算。在每个 usage 块里，思考令牌都是 output_tokens 的一部分，另有一个 thinking_tokens 字段说明输出中有多少是思考。在 API 上它们按输出价格计费，Anthropic 也把推理强度列为让套餐用量限制消耗更快的因素之一。在我们的语料中，思考占模型写出的全部内容的 29%。

缓存写入令牌和缓存读取令牌有什么区别？

缓存写入是把提示词的一部分存起来，供下一次请求复用，它比普通输入更贵：5 分钟缓存为输入价格的 1.25 倍，1 小时缓存为 2 倍。缓存读取是复用这部分已存储的内容，便宜得多：大多数模型上为输入价格的 0.1 倍，Opus 5.5 和 Sonnet 5.5 上为 0.05 倍，Fable 5.1 上为 0.025 倍。在我们的会话中，缓存读取占令牌的 98%、按标价计算的成本的 46%；缓存写入占令牌的 2%、成本的 37%。