Anthropic 详解 Opus 5.5 上一次 Claude Code 任务的成本构成

一项任务的成本，以及一次重试的成本

你并不是一开始就打算购买数百万个 token。你是为了构建一个功能、完成一次迁移，或者运行一项任务。token 数量只是模型为达成目标所需要的量。

两个每 token 成本相同的模型，在同一项任务上的花费可能相差很大。一个只读一遍代码。另一个读了代码，尝试修复，然后又读一遍。其中每一步都是一轮，而每一轮都会重新发送到目前为止的对话。因此，需要更多轮的模型花费更高，即使单价相同也是如此。

读完这篇文章后，你应该能够回答关于自己工作的三个问题：

• 我的典型任务在 Opus 5.5 上要花多少钱？
• 哪些设置会改变这一点，改变多少？
• 我该如何查看自己的会话用量？

我想事先说明的权衡是：每一种减少 token 消耗的方式，也可能让你付出任务无法完成的代价。降低 effort、使用更小的模型，或者减少上下文，这些当然都能节省 token。但一次重试的成本会超过这些节省。本文试图为每一种权衡标出价格。

这里的一些数字是标价，另一些则是基于标价构建的示例。这些数字是可交互的，所以你可以在阅读时更改输入。这些都是尽力而为的示例，所以请务必查阅我们的文档，并自行核算。

一个任务要花多少钱？

Claude Code 中的一个任务就是一个循环。模型读取对话，调用工具，读取结果，然后再次循环，直到完成。循环中的每一轮就是一次请求。有四件事决定了这个循环的成本。

轮次。每一轮都会重新发送到目前为止的对话。轮次越少，处理的输入就越少。

缓存读取。一轮中重新发送的大部分内容都是模型在上一轮已经看过的文本。这部分按缓存读取计费，价格仅为输入价格的一小部分。

输出 token 类型。这是最贵的 token，价格是输入的五倍。思考按输出计费，因此一个在得出答案的过程中推理更少的模型，成本更低。

模型。每个模型都有自己的价格，列在定价页面上，因此你选择的模型决定了每一个 token 的价格。

我们的示例使用 Opus 5.5 的 API 标价：每百万输入 token 4 美元，每百万输出 token 20 美元，每百万缓存读取 0.20 美元。与下方的计算器一样，这些示例将缓存输入按读取价格计费，其他所有内容按输入价格计费，并且不计缓存写入。token 数量仅为示例说明。

轮次

假设一个任务开始时上下文为 20K tokens，随着模型读取文件和工具结果，增长到 120K。在第 40 轮时，平均每轮发送约 70K tokens。这个任务大约消耗 2.8M 输入 tokens，尽管对话从未超过 120K。如果 90% 从缓存读取，输入成本约为 $1.62。同样的任务在 25 轮内处理约 1.75M tokens，输入成本约为 $1.02。

一轮的成本高于它新增的 tokens，因为它会重新发送之前的所有内容。所以最便宜的一轮就是你不需要的那一轮。

一个能减少轮次的习惯是给模型一种检查自己工作的方式。例如，一个可运行的测试、一次构建，或一个调用该端点的脚本。能够检查自己工作的模型会更早发现自己的错误。

一个能在一次遍历中收集所需内容、并批量执行工具调用的模型，也能减少重新发送的次数。

缓存读取

同样的 2.8M 输入 tokens，如果没有任何来自缓存，成本为 $11.20。在 90% 命中率下成本为 $1.62，在 96% 时约为 $0.99。没有其他设置能如此大幅地影响输入成本。一个稳定的会话本身就能保持高命中率。我在本文后面会介绍一些避免破坏缓存的注意事项。

输出 tokens

在 Opus 5.5 上，一个输出 token 的成本是一次缓存读取的 100 倍。一个典型任务的 60K 输出 token 花费 $1.20，与从缓存中读取 6M token 相同。输出包含思考过程。即使 Claude Code 只向你展示摘要，你也要为全部内容付费。这就是为什么 effort（主要改变模型思考量）会让账单变化如此之大。

模型

缓存读取更便宜的模型主要有利于长会话。输出更便宜的模型主要有利于需要大量推理的任务。

Opus 5.5 有哪些变化

有两处变化：价格，以及模型完成的工作量。

每一条价格线都更低了。输入和输出 token 比 Opus 5 便宜 20%。缓存读取便宜 60%。输入价格下降，读取费率也随之下降，从输入价格的十分之一降至二十分之一。图 A 比较了两个模型每百万 token 的价格。这些是 API 标价。在 Pro、Max 或 Team 套餐上，Opus 5.5 更低的价格会传递到你的限额上，包括缓存上下文，因此它们比 Opus 5 大约多出 25% 的可用量。缓存读取的额外降价属于 API 价格变动。

在使用 API key 的情况下，缓存读取降价对 Claude Code 影响最大。一个长时间运行的智能体会话将大部分输入花在缓存读取上。在下方图 B 所定价的会话中，缓存这一行从 $1.00 降至 $0.40，是账单上降幅最大的一项。

你能节省多少取决于你工作的形态。一个以缓存读取为主的会话，在输入上最多可节省 60%。一个没有缓存、答案很长的简短提问，最多可节省 20%，因为输出占了主导。大多数 Claude Code 任务介于两者之间。下面的计算器会显示你的任务处于哪个位置。

Opus 5.5 在一个回答上可以使用更多 token，因为它在回复前总会先思考。我们预计人们用 Opus 5.5 能完成更多工作，但这因任务而异，所以要在你自己的工作上测量。图 C 比较了两个模型上每个任务的成本。这一部分取决于你的工作，其影响远大于价格。

在一个范围明确的任务上，两个模型完成的轮数大致相同，降价就是你得到的全部好处。差距应该在开放式任务上最大，因为模型可能在一个错误的想法上耗费很多轮。没有哪个单一数字适用于所有代码库，所以要测量它（见最后一节）。

长时间运行以一份报告收尾。 Opus 5.5 会以它改动了什么、发现了什么以及需要你提供什么来结束一次长时间运行。这也能省钱，因为当你能看到发生了什么时，你重跑会话的频率就会降低。

相同任务并排对比

图 B 以相同的 token 数量为两个模型上的同一个会话定价。所以差异就是价格变化，别无其他。切换模型即可对比。token 数量仅为示意。

按 Opus 5 的标价

图 B。

同一会话在两种模型上使用相同 token 的示例，因此这里仅体现价格变化。

图 B。同一会话在两种模型上使用相同 token 的示例，因此这里仅体现价格变化。

这张账单包含 /usage 为某次会话显示的三行。按 token 计，缓存读取是最大的一行，为 2M。按 token 计，输出是最小的一行，但按成本计却是最大的一行。全新输入介于两者之间。它涵盖每个文件的首次读取以及每个新的工具结果。

图 B 给两种模型相同的 token 数量，因此它仅体现价格变化。你自己的会话在 Opus 5.5 上可能使用更多或更少的 token。按这种方式计价，该会话的成本大约低 31%。

一次实际记录的运行还会叠加第二个效应，即模型完成工作量的变化。在一个出现起步失误的任务上，差距应该会拉大。试试你自己的数字

设定你某个任务的使用量，或者从预设值开始。这些预设值颇具示例性，但我仍然建议你自己算一算。缓存输入按缓存读取价格计费，全新输入按输入价格计费，因此缓存滑块展示了差距中有多少来自缓存读取。

要用真实会话填充这些滑块，请在任务结束时运行 /usage。Session 区块会给出输入、输出和缓存的数据。最后一个滑块是你对 Opus 5.5 在你的任务上能少做多少工作的假设。如果只想看价格变化，就把它留在 0%。要根据你自己的实际工作来设定它，方法如下：在 Opus 5 和 Opus 5.5 上运行同一个任务，比较轮次和输出 token。Measure it yourself 会带你走一遍流程，Reading a session 则展示了在 /usage 中该检查什么。

所有轮次中发送给模型的内容，无论是否命中缓存。

包含思考内容，它按输出计费。

只看价格就留在 0%。Opus 5.5 用更少的 token 做更多的事，但这要在你自己的任务上实测。

Opus 5 每任务

Opus 5.5 每任务

每任务变化

一个月按工作日计算。采用标价。不含批量或批量折扣，且不计入缓存写入（见下方缓存部分）。

最大化会话价值的技巧

Opus 5.5 更低的价格让每个 token 的成本更少。你如何运行会话决定了你使用多少 token，以下步骤会有所帮助。

在更换模型之前先提高 effort

Effort 为模型每一轮消耗多少 token 设定了一个总体倾向：包括它的思考、它写出的文本以及它的工具调用。在较低的 effort 下，它进行的工具调用更少，且调用更简短。Opus 5.5 有四个级别（low、medium、high 和 xhigh），外加用于单次会话的 max。在下方选择一个级别，查看何时使用它以及设置它的命令。

级别从每轮最少思考到最多思考依次排列。

Claude Code 会为每个模型设定一个默认级别，`/effort status` 会显示你的当前级别。对于范围明确、日常性的工作，可以试试 medium。当 medium 卡住时，试试 high。它每轮的开销比 medium 更高，但低于换用更大的模型。对于机械性的工作，比如重命名或在多个文件中应用已知模式，使用 low。

一个粗略理解 effort 定价的方式：假设 high 在一个任务中额外增加 20K 思考 token。在 Opus 5.5 上，这就是 $0.40。一个十轮的 retry 循环，使用 100K 缓存上下文，总共 10K 输出 token，成本大致相同。所以，如果 high 能在一个任务中省下一次 retry，它就值回成本。而在一个 medium 本可以一次就完成的任务上，它就是浪费。

当 medium 只修复一层时

你需要更高 effort 的最明显信号，是修复只停留在一层。

假设某个字段在 API 处理程序中被重命名。在 medium 档位下，模型更新了处理程序，处理程序的测试通过了，但客户端仍然发送旧字段。它做了被要求做的事，只是没有读得足够远，去找到第二个调用方。在 high 档位下，它会在写入之前花更多轮次阅读调用点，并一次性修改两层。

检查也能捕获同样的 bug。如果模型能运行一个经过客户端的测试，那么在 medium 档位下，旧字段在写入的那一轮就会让该测试失败。所以在你提高 effort 之前，先检查模型是否有办法验证自己的工作。运行一次测试的成本是一轮加上其输出。而更高的 effort 会给每一轮都增加思考。

如果升级 effort 档位和增加检查都不奏效，那就换用更大的模型。

在会话中途更改 effort

在 Claude Code 中，运行 /effort 并带上档位，例如 /effort high。/effort status 会打印当前档位。你可以在任务进行中更改它，新档位会应用于下一个请求。

更改 effort 或 thinking 设置会清除缓存的对话，因为这些设置是缓存所匹配的提示词的一部分。下一个请求将按整段对话支付缓存写入的费用。

为你的工作选择合适的模型

模型选择决定了一次会话中每个 token 的价格，因此它对账单的影响比 effort 更大。它的影响还更深远。每一个继承主模型的子智能体也会继承它的价格。大多数日子需要三种模型：一个用于查找的小模型、用于你密切监督的工作的 Opus 5.5，以及用于最难任务的更大模型。

将 Opus 5.5 作为日常主力

将 Opus 5.5 用于你监督的工作：跨几个文件的功能开发、调试，以及带有后续修改的代码审查。你阅读它的操作，并在它偏离时介入，从而让循环保持简短。升级到 Fable 5.1

当结果比 token 价格更重要时，升级到 Fable 5.1。例如你不会监督的长时间运行、代码库中没有现成模式的问题，以及需要协调许多子智能体的大型改动。不要等到第三次失败。如果 Opus 5.5 在高强度下两次遇到同一个问题，就切换，等它解决后再切回来。对于交互式工作，Opus 5.5 更合适，因为它延迟更低、成本更少。

Fable 5.1 的标价是每百万输入 token 10 美元、每百万输出 token 50 美元，是 Opus 5.5 价格的 2.5 倍。其缓存读取费用为每百万 0.25 美元，仅为 Opus 5.5 费率的 1.25 倍，因为它们是按输入价格的 0.025 倍计费的。因此，在长时间、缓存密集的运行中差距最小，而在大量写入的任务中差距最大。

在自然的断点处切换。缓存属于上一个模型，因此在新模型上的第一轮会为整段对话支付写入成本。先运行 /compact，或者用一个简短的书面计划开启新会话，让那一轮更小。运行 /model 并带上别名或模型名称即可切换。/model 还会把你的选择保存为新会话的默认值，所以等困难的部分完成后就切换回去。

降级用于查找

降级到 Sonnet 或 Haiku 用于查找，而不是用于写代码：用于搜索和总结、读取日志和测试输出，以及"这个定义在哪里"这类问题的子智能体。对于跨多个文件的机械式编辑，保留 Opus 5.5 并将 effort 设为 low。这样编辑仍由编写你其余代码的那个模型完成，而每轮成本更低。

要让某个子智能体使用更小的模型，在其定义中设置 model: haiku 或 model: sonnet。要让所有子智能体都使用同一个模型，设置 CLAUDE_CODE_SUBAGENT_MODEL 环境变量。子智能体定义中指定的模型会覆盖该变量。未设置模型的子智能体会运行在你的主模型上，除非该变量已设置。

每个子智能体都在自己的上下文窗口中运行，并返回一份摘要，因此它读取的文件不会进入你的主对话。它仍然要为自己的 token 付费，所以模型设置决定了这笔开销的多少。

权衡在于：一个会误读搜索结果的小模型，会把主模型引向错误的文件，而主模型要为这段弯路付出代价。让小模型去做那些出错后容易发现的工作，比如查找文件、运行测试和读取日志。

把需要判断的决策留给主模型。opusplan 别名以另一种方式拆分工作：Opus 在 plan 模式下做规划，Sonnet 执行该计划。这就把代码编辑交给了 Sonnet，与上面的建议正好相反。在把它设为默认之前，先在你自己的任务上实测一下。

迁移时检查你的提示词

为旧模型编写的指令会让 Opus 5.5 写更多内容并重复调用工具。在 Claude Code 中运行 /claude-api prompt-audit，检查你的 Claude Code 配置（例如你的技能和 CLAUDE.md 文件）是否存在这些提示词反模式。它还会检查你在 Claude Platform 上构建的应用的代码。

我们在一次从 Opus 4.8 到 Opus 5.5 的迁移中测试了这一点，使用了一个包含 44 张工单的内部客户支持基准，其提示词中包含若干这类模式。迁移到 Opus 5.5、采用低 effort 后，该基准的成本降低了约 18%。运行 prompt-audit 又进一步降低了 9%，最终比 Opus 4.8 的起点低约 25%。这次审计移除了那些让模型写更多内容并重复调用工具的仪式性指令：一个强制性的六步流程、一条草稿纸规则、一条验证两次的规则，以及相互矛盾的指令。

这一结果来自单一基准测试，因此请将其视为一个示例，而非可以预期的数字。先运行审计，然后在真实任务上对比使用前后的 /usage（参见"自行测量"）。

缓存与压缩

Claude Code 会为你处理缓存与压缩。你如何运行会话，决定了它们能节省多少。

缓存如何工作

Claude Code 会缓存请求中重复的部分，例如系统提示词、工具定义以及到目前为止的对话。

在 Opus 5.5 上，一次缓存读取的成本是全新输入 token 的 5%。写入缓存的成本高于全新读取，按当前定价，五分钟缓存为输入价格的 1.25 倍，一小时缓存为输入价格的两倍。每次命中都会免费重置生命周期。

在 Claude Code 中，生命周期取决于你的付费方式。使用 Claude 订阅时为 1 小时。使用 API key 或云服务商时默认是 5 分钟，而订阅一旦开始消耗用量额度，也会降为 5 分钟。

在 120K tokens 的上下文下，用 Opus 5.5 写一次五分钟的内容大约花费 $0.60，读一次大约 $0.02。一次写入的成本相当于 25 次读取。使用 API key 时，一次六分钟的咖啡休息会把下一次 $0.02 的读取变成 $0.60 的写入。同样规模下，一小时的写入大约花费 $0.96，而在 API 上，你可以支付这笔溢价来填补一天中的空档。

会话形态与命中率

缓存存储的是一个前缀，因此它只能复用请求中从开头起与上一次请求相匹配的那部分。

一个稳定的会话每一轮都会在对话末尾追加内容，从而保持较高的命中率。任何改动请求中较早部分的操作都会降低命中率。更改工具定义会清空整个缓存，而更改系统提示词会从该点起清空缓存，这几乎就是全部内容了。

在实践中，以下情况预计会发生缓存写入：

• 你暂停的时间超过了缓存生命周期；
• 你更改了 effort 或 thinking 设置（参见 effort 部分），这可能会清空已缓存的对话；
• 你连接或断开了一个 MCP server，这可能会改变每次请求开始时加载的内容；
• 你切换了模型，因为新模型会从空缓存开始；以及
• 对话被压缩，这会重写缓存所匹配的历史记录。

因此，在会话启动时就把这些设置好，然后在它工作期间不要改动它们。

为什么长会话每轮成本更高

每一轮都会重新发送整个上下文，因此随着上下文增长，一轮的成本也会增加，即使缓存是热的也不例外。在 20K tokens 的上下文下，一轮的缓存读取在 Opus 5.5 上花费约 $0.004。在 150K 时花费约 $0.03，而在这个规模下进行 30 轮，仅读取就要花 $0.90。同样的 30 轮在 20K 下花费约 $0.12。在 Claude 4.6 及之后的模型上，更大的上下文窗口不会改变每 token 的价格，因此成本完全来自重新发送对话。

这些上下文中有很大一部分是早先工作遗留下来的：一小时前的堆栈跟踪、你已经处理完的文件、你后来已经修复的测试运行输出。每一轮这些都仍会被发送。

压缩、/compact 和 /clear

当会话接近其上下文上限时，Claude Code 会总结较早的历史记录，以便后续轮次发送更少内容。运行 /autocompact 并带上一个 token 数量，可以更改在此发生之前上下文达到多满。

两条命令可以让你自己完成这件事。/clear 会清空对话且不产生任何费用，所以当你转向不相关的工作时就用它。/compact 会保留连续性，代价是一次请求。它会读取自己要总结的对话，你可以说明要保留什么，例如 /compact keep the failing test names and the schema change。

在 150K tokens 时进行压缩的大致价格约为 $0.25。这包括读取、几千个输出 token 的摘要，以及在更短上下文上的一次新的缓存写入。之后每一轮大约能节省 $0.025 的读取费用，所以这次压缩大约在十轮之内就能回本。在你即将结束时才做压缩，花费会超过它节省的。

摘要还会丢失细节。在调试过程中途做一次压缩，可能会丢掉那行唯一重要的日志。要在自然的停顿点压缩，而当下一步依赖某个具体内容时，就在 /compact 指令里说明。

在你输入之前会加载什么

你的 CLAUDE.md 文件会在每次会话开始时加载进上下文，所以其中的每一行都是每一轮都会重新发送的内容的一部分。成本文档建议将其保持在 200 行以内。MCP 工具定义是延迟加载的。开始时只加载工具名称和服务器指令，当某个工具被使用时才会加载它的完整定义。运行 /mcp 可以查看哪些服务器已连接，并关掉你没在用的那些。

账单的其余部分

该表格列出了其他会影响 Claude Code 会话的计费规则，并在有文档可查时附上了相应链接。

自己动手测量

本文中的数字仅为示例。你的代码库、提示词和习惯各不相同，因此请针对自己的任务测量成本。以下是检查方法。

1. 在会话中，运行/usage。 /cost 的作用相同。Session 区块会显示 token 用量以及按标价估算的美元成本。prompt-cache 一行会显示你的输入中有多少来自缓存。在 Pro、Max、Team 或 Enterprise 套餐下，同一界面会显示你的套餐用量条。美元数字是在你的机器上按标价计算得出的，因此在订阅套餐下，它只是衡量你做了多少工作的参考，而非账单。
2. 把同一个任务跑两遍。 从你的待办事项里挑一个，不要用玩具示例。使用 /model 在 Opus 5 和 Opus 5.5 之间切换。记录每次运行的轮次、输出 token 和成本。先做三四个任务，再下结论。
3. 对于团队，请使用用量与成本报告。 Claude Code Analytics API 提供每位用户的估算成本。Usage and Cost API 则按模型以及缓存与未缓存 token 细分支出。
4. 试试努力阶梯。把一个困难任务分别用中档和高档各跑一次。把一个机械性任务用低档跑一次。

阅读一次会话

在任务结束时，检查 /usage 中的三件事。

• 缓存占比。对于长时间会话，它应该很高。如果很低，就去找找是否有长时间停顿、努力档位或模型发生了切换，或者中途接入了某个 MCP 服务器。
• 输出与输入之比。小小的改动却产生大量输出，通常意味着努力档位对该任务来说过高，或者模型在反复重试。
• 总输入与对话规模之比。如果总量是对话规模的许多倍，说明这次会话经历了很多轮，值得读一读对话，找出循环重复发生在哪里。

作为基准，Claude Code 成本文档给出的企业部署平均值约为每位开发者每个活跃日 $13，而 90% 的用户每个活跃日低于 $30。如果一次会话的成本远高于你自己的正常水平，就值得复盘。

请记住

• 对于范围明确的日常工作，使用中档努力。
• 给模型一种检查自己工作的方式，并在计划模式下启动跨文件的改动。
• 当中等档位卡住时，把投入程度调到高。在休息时更改，因为这一更改可能会产生一次缓存写入。
• 如果高投入档位两次遇到同一个问题，就切换到 Fable 5.1。问题解决后再切换回来。
• 把搜索和读日志的子智能体放在 Sonnet 或 Haiku 上。代码编辑继续留在 Opus 5.5 上。
• 让一个长会话持续进行，这样它的缓存就能保持热态。
• 在不相关的任务之间使用 /clear，在休息时使用 /compact，并附上一条说明要保留什么内容的备注。
• 最重要的一点：在每个模型上运行一个真实任务，并比较 /usage 报告的结果。你自己的数字才是值得信赖的。

希望这篇文章对你有帮助。如果你在 Opus 5.5 上的限额并不比在 Opus 5 上更宽松，请通过 /feedback 告诉我们。

延伸阅读：有效管理成本 · 模型配置 · 在 Claude Code 中选择 Claude 模型和投入程度 · 投入程度 · 提示词缓存 · 最大化你的 Claude Code 会话价值

感谢 Michael Segner、Kacie Jenkins 和 Molly Vorwerck 的审阅。