<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <title>成本分析 on KnightLi的博客</title>
        <link>https://www.knightli.com/tags/%E6%88%90%E6%9C%AC%E5%88%86%E6%9E%90/</link>
        <description>Recent content in 成本分析 on KnightLi的博客</description>
        <generator>Hugo -- gohugo.io</generator>
        <language>zh-cn</language>
        <lastBuildDate>Sat, 25 Apr 2026 08:44:32 +0800</lastBuildDate><atom:link href="https://www.knightli.com/tags/%E6%88%90%E6%9C%AC%E5%88%86%E6%9E%90/index.xml" rel="self" type="application/rss+xml" /><item>
        <title>大模型 API 为什么按 Token 收费：一文讲清输入、输出和上下文成本</title>
        <link>https://www.knightli.com/2026/04/25/llm-token-pricing-principles/</link>
        <pubDate>Sat, 25 Apr 2026 08:44:32 +0800</pubDate>
        
        <guid>https://www.knightli.com/2026/04/25/llm-token-pricing-principles/</guid>
        <description>&lt;p&gt;大模型 API 的计费方式里，最容易让人困惑的一点，就是为什么几乎所有平台最后都会落到 &lt;code&gt;token&lt;/code&gt; 这个单位上：&lt;strong&gt;大模型为什么按 token 收费，而且不同 token 还会有不同价格。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;很多人刚接触模型 API 时，最容易困惑的不是模型能力，而是账单。明明只问了几个问题，为什么费用会涨得这么快？为什么输入便宜、输出更贵？为什么上下文一长，成本就开始明显失控？&lt;/p&gt;
&lt;p&gt;如果把这件事讲简单一点，可以先记住一句话：&lt;strong&gt;模型收费，买的不是“一次回答”，而是整段推理过程中消耗的计算与带宽资源。&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&#34;1-什么是-token&#34;&gt;1. 什么是 token
&lt;/h2&gt;&lt;p&gt;在大模型计费里，&lt;code&gt;token&lt;/code&gt; 不是“字数”也不是“单词数”，而是模型处理文本时使用的切分单位。&lt;/p&gt;
&lt;p&gt;它可能是：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;一个汉字&lt;/li&gt;
&lt;li&gt;一个英文单词的一部分&lt;/li&gt;
&lt;li&gt;一个标点符号&lt;/li&gt;
&lt;li&gt;一小段常见词组合&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;所以 API 平台通常不会按“每句话”或“每次请求”收费，而是按模型实际读入和生成的 token 数量收费。&lt;br&gt;
这比按请求次数计费更合理，因为同样是一次请求，可能只输入 20 个字，也可能塞进去 20 万 token 的上下文，两者消耗完全不是一个量级。&lt;/p&gt;
&lt;h2 id=&#34;2-为什么输入和输出要分开定价&#34;&gt;2. 为什么输入和输出要分开定价
&lt;/h2&gt;&lt;p&gt;现在大多数模型 API，都会把价格拆成两部分：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;输入 token 价格&lt;/li&gt;
&lt;li&gt;输出 token 价格&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;而且常见情况是：&lt;strong&gt;输出 token 比输入 token 更贵。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;原因并不难理解。&lt;/p&gt;
&lt;p&gt;模型处理输入时，本质上是在“读”和“编码”已有内容；但生成输出时，它需要一步一步预测下一个 token，再继续预测下一个 token。这个过程不只是读取，而是持续进行推理和采样，所以通常更耗算力。&lt;/p&gt;
&lt;p&gt;你可以把它粗略理解成：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;输入：像把材料递给模型&lt;/li&gt;
&lt;li&gt;输出：像让模型现场写答案&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;“现场写”的计算成本，通常比“把材料读一遍”更高，所以输出价格更贵是很常见的设计。&lt;/p&gt;
&lt;h2 id=&#34;3-为什么上下文越长费用越容易失控&#34;&gt;3. 为什么上下文越长，费用越容易失控
&lt;/h2&gt;&lt;p&gt;很多人以为自己只是在“多贴一点背景资料”，但从模型账单的角度看，这件事的影响往往比想象中大。&lt;/p&gt;
&lt;p&gt;原因在于：&lt;strong&gt;模型每次调用时，通常都要重新处理当前请求里带进去的整段上下文。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;也就是说，如果你当前请求里包含：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;系统提示词&lt;/li&gt;
&lt;li&gt;历史对话&lt;/li&gt;
&lt;li&gt;工具返回结果&lt;/li&gt;
&lt;li&gt;长文档片段&lt;/li&gt;
&lt;li&gt;代码文件内容&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这些内容都会一起进入输入 token 计费。&lt;/p&gt;
&lt;p&gt;所以真正让账单变大的，往往不是最后那一句提问，而是它前面拖着的一大串上下文。&lt;br&gt;
当对话轮数增加、工具调用变多、历史消息不断回灌时，token 成本就会被一轮轮放大。&lt;/p&gt;
&lt;h2 id=&#34;4-工具调用为什么特别容易涨-token&#34;&gt;4. 工具调用为什么特别容易涨 token
&lt;/h2&gt;&lt;p&gt;在 Agent、代码助手、工作流自动化这类场景里，token 消耗通常比普通聊天高得多。&lt;/p&gt;
&lt;p&gt;问题不只是“模型回答了一段话”，而是整个流程里会不断出现这些内容：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;读文件&lt;/li&gt;
&lt;li&gt;看日志&lt;/li&gt;
&lt;li&gt;调接口&lt;/li&gt;
&lt;li&gt;返回 JSON&lt;/li&gt;
&lt;li&gt;执行工具结果再回填给模型&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;每一次工具调用的结果，只要被重新塞回下一轮上下文，就会继续变成新的输入 token。&lt;/p&gt;
&lt;p&gt;这就是为什么很多开发者会发现：&lt;br&gt;
&lt;strong&gt;不是模型本身单价特别离谱，而是工作流把 token 账单一层层叠上去了。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;例如一个编码 Agent 连续做下面这些事：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;读取项目结构&lt;/li&gt;
&lt;li&gt;打开几个源码文件&lt;/li&gt;
&lt;li&gt;跑一次测试&lt;/li&gt;
&lt;li&gt;把报错日志喂回模型&lt;/li&gt;
&lt;li&gt;再读取更多相关文件&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;每一步都可能让后续请求背着更长的上下文继续跑。这样即使单价不变，总账单也会很快增长。&lt;/p&gt;
&lt;h2 id=&#34;5-为什么同样是模型价格会差很多&#34;&gt;5. 为什么同样是模型，价格会差很多
&lt;/h2&gt;&lt;p&gt;不同模型的 token 价格差异，背后通常不只是“厂商想卖贵一点”，而是和几个因素直接相关：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;模型规模&lt;/li&gt;
&lt;li&gt;推理效率&lt;/li&gt;
&lt;li&gt;上下文长度&lt;/li&gt;
&lt;li&gt;部署成本&lt;/li&gt;
&lt;li&gt;目标市场&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;模型越大、激活参数越多、推理链路越复杂，单次生成一个 token 的成本通常就越高。&lt;br&gt;
如果模型还支持超长上下文、复杂推理、工具调用优化，那它的基础设施压力也会进一步增加。&lt;/p&gt;
&lt;p&gt;所以定价本质上是在覆盖几类成本：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;GPU / 加速卡资源&lt;/li&gt;
&lt;li&gt;显存占用&lt;/li&gt;
&lt;li&gt;推理延迟&lt;/li&gt;
&lt;li&gt;网络与服务稳定性&lt;/li&gt;
&lt;li&gt;峰值并发能力&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;便宜模型不一定差，贵模型也不一定适合所有场景。很多时候价格差，反映的是“这类能力大概值多少基础设施成本”。&lt;/p&gt;
&lt;h2 id=&#34;6-为什么缓存输入会更便宜&#34;&gt;6. 为什么缓存输入会更便宜
&lt;/h2&gt;&lt;p&gt;不少模型平台现在会提供：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;cached input&lt;/li&gt;
&lt;li&gt;prompt caching&lt;/li&gt;
&lt;li&gt;prefix caching&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这类能力的共同思路是：如果一大段输入已经算过，不要每次都从头按原价重算。&lt;/p&gt;
&lt;p&gt;比如一个固定 system prompt、固定工具说明、固定长文档前缀，如果每轮都完全重复发送，平台就有机会把其中一部分计算缓存下来。这样同样是输入 token，缓存命中的部分就可以按更低价格计费。&lt;/p&gt;
&lt;p&gt;这也解释了为什么很多 API 价格页会出现三档甚至更多价格：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;普通输入&lt;/li&gt;
&lt;li&gt;缓存输入&lt;/li&gt;
&lt;li&gt;输出&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;它们反映的不是文字内容不同，而是底层计算是否可以复用。&lt;/p&gt;
&lt;h2 id=&#34;7-便宜-token为什么不等于总成本更低&#34;&gt;7. “便宜 token”为什么不等于“总成本更低”
&lt;/h2&gt;&lt;p&gt;很多人看到某个模型“每百万 token 超便宜”，第一反应是总成本一定更低。实际上不一定。&lt;/p&gt;
&lt;p&gt;因为总账单大致等于：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;token 单价 × 实际消耗量&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;而实际消耗量又会被很多因素放大：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;提示词写得太长&lt;/li&gt;
&lt;li&gt;历史消息不清理&lt;/li&gt;
&lt;li&gt;工具结果回填过多&lt;/li&gt;
&lt;li&gt;输出太啰嗦&lt;/li&gt;
&lt;li&gt;一个任务反复重试&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;所以真正决定账单的，通常不是单价一个变量，而是：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;模型单价&lt;/li&gt;
&lt;li&gt;每轮输入长度&lt;/li&gt;
&lt;li&gt;每轮输出长度&lt;/li&gt;
&lt;li&gt;调用次数&lt;/li&gt;
&lt;li&gt;工作流设计&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这也是为什么“低单价模型”在某些 Agent 任务里，最后总费用仍然可能不低。因为它可能需要更多轮交互、更多补充上下文、更多失败重试。&lt;/p&gt;
&lt;h2 id=&#34;8-开发者该怎么估算-token-成本&#34;&gt;8. 开发者该怎么估算 token 成本
&lt;/h2&gt;&lt;p&gt;如果你想在项目里更稳地控制预算，可以先用一个很朴素的估算方式：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;统计平均每次请求的输入 token&lt;/li&gt;
&lt;li&gt;统计平均每次请求的输出 token&lt;/li&gt;
&lt;li&gt;估算一个任务会调用多少轮&lt;/li&gt;
&lt;li&gt;再乘上对应模型单价&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;举个思路上的例子：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;每轮输入 &lt;code&gt;8k tokens&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;每轮输出 &lt;code&gt;1k tokens&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;一个任务跑 &lt;code&gt;10&lt;/code&gt; 轮&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;那它真正消耗的就不是“一次问答”，而是：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;输入约 &lt;code&gt;80k tokens&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;输出约 &lt;code&gt;10k tokens&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果中途还有日志、工具结果、文件内容不断追加，总量还会继续上升。&lt;/p&gt;
&lt;p&gt;所以做预算时，最好不要只看单轮，而要看&lt;strong&gt;一个完整任务闭环&lt;/strong&gt;到底会吃掉多少 token。&lt;/p&gt;
&lt;h2 id=&#34;9-怎么实际控制账单&#34;&gt;9. 怎么实际控制账单
&lt;/h2&gt;&lt;p&gt;如果你已经在用 API 或 Agent，下面这些做法通常最有效：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;缩短 system prompt，避免重复废话&lt;/li&gt;
&lt;li&gt;定期裁剪历史消息&lt;/li&gt;
&lt;li&gt;工具返回结果只保留必要字段&lt;/li&gt;
&lt;li&gt;长文档先检索，再喂局部片段&lt;/li&gt;
&lt;li&gt;控制输出长度，避免模型无上限展开&lt;/li&gt;
&lt;li&gt;对高价值任务用贵模型，低价值任务用便宜模型&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;很多时候，省钱最有效的方式不是一味换更便宜的模型，而是先把工作流里无意义的 token 消耗砍掉。&lt;/p&gt;
&lt;h2 id=&#34;10-这件事真正该怎么理解&#34;&gt;10. 这件事真正该怎么理解
&lt;/h2&gt;&lt;p&gt;大模型 token 定价，说到底是在给“模型读了多少、想了多少、写了多少”计费。&lt;/p&gt;
&lt;p&gt;它不是传统软件那种按账号、按次数、按包月就能完全描述的资源模型，因为模型调用本身就是一个动态计算过程。你塞进去的上下文、拉起的工具、要求的输出长度，都会直接影响成本。&lt;/p&gt;
&lt;p&gt;所以理解 token 定价，最重要的不是背价格表，而是先建立一个直觉：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;长上下文会涨输入成本&lt;/li&gt;
&lt;li&gt;长输出会涨生成成本&lt;/li&gt;
&lt;li&gt;工具链会放大总 token&lt;/li&gt;
&lt;li&gt;缓存和工作流设计会明显影响账单&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;只要把这几个点想清楚，大多数模型 API 的价格结构其实都不难理解。&lt;/p&gt;
</description>
        </item>
        
    </channel>
</rss>
