如何理解 GPT-6.2 Sol 的计费规则?从 Responses 用量复算一笔 $0.0479 的账单

如何理解 GPT-6.2 Sol 的计费规则?从 Responses 用量复算一笔 $0.0479 的账单

作者注:从一条 Responses 的 usage 出发,逐项复算 GPT-6.2 Sol 的普通输入、缓存读取与写入、推理输出,再说明缓存寿命和请求状态怎样改变同一工作流的账单。

GPT-6.2 Sol 的账单可以按固定方法复算。请求记录里的 usage 把输入拆成普通输入、缓存读取、30 分钟缓存写入、12 小时缓存写入四类,这四类互斥。输出另成一类,推理 token 已经计入其中。每类 token 数乘以对应费率后相加,就是这次请求的模型费。工具费另行计算。

有三个条件会改变结果。第一是单次请求的输入总量是否超过 272K,超过后整次请求换用长上下文费率。第二是缓存寿命与实际命中次数,同一段前缀写成 30 分钟还是 12 小时,盈亏点不同。第三是请求状态,incomplete、重试和后台任务都会影响一个工作流的总账。

OpenAI 在 2026 年 11 月 17 日发布了 GPT-6.2 Sol,API 模型 ID 为 gpt-6.2-sol,可以通过 Responses 和 Chat Completions 调用,函数调用和内置工具走 Responses 路径。本文以 OpenAI 官方直连的美元标价为基准,同时说明 API易 apiyi.com 公开定价接口中这个模型的挂牌口径。本文算例全部基于合成用量,不是实测账单。

gpt-6-2-sol-billing-responses-usage-recalculation-image-0


GPT-6.2 Sol 计费知识地图与阅读顺序

全文按「字段 → 金额 → 缓存决策 → 工作流对账」的顺序展开。每一步的输出就是下一步的输入:先认清 usage 里有哪几项,再把它们换成美元,然后用这套算法比较缓存方案,最后把单次请求汇总成工作流成本。

Responses usage
 ├─ 输入总量 input_tokens
 │   ├─ 缓存读取 cached_tokens ──────────┐
 │   ├─ 30m 写入 ttl_30m_tokens ─────────┤
 │   ├─ 12h 写入 ttl_12h_tokens ─────────┼─→ ×对应费率 → 单次请求模型费(第 2 节)
 │   └─ 普通输入 = 总量 − 读取 − 全部写入 ┤
 └─ 输出 output_tokens(含 reasoning_tokens)┘
                                          ↓
         缓存寿命选择(第 3 节) ← 同一前缀多次请求的总价比较
                                          ↓
         工作流对账(第 4 节) ← 工具费 + 重试 + incomplete + 费用导出
编号 回答的问题 依赖前一节的内容 读完能做什么
1 usage 里哪些数字参与计费 — 从一条响应中拆出五项计费用量
2 这些用量值多少钱 第 1 节的五项用量 把日志数字换成美元,判断长短档
3 缓存写 30 分钟还是 12 小时 第 2 节的单价算法 按调用间隔和命中次数选择缓存寿命
4 一个任务到底花了多少 第 2、3 节的单请求核算 建立最小日志表,追查账单差额

只想解释一笔费差的读者,读完第 1、2 节即可。负责缓存策略或成本台账的读者,建议顺序读完全部四节。

GPT-6.2 Sol 计费术语 To Know

术语 解释
usage API 响应中汇总当前请求 token 用量的字段
普通输入 总输入扣除计费缓存读取和所有缓存写入后剩下的用量
缓存读取 当前请求中按复用价格计费的那部分输入
缓存断点 允许缓存保存或复用输入前缀的边界
TTL 缓存最短计价覆盖时间配置,Sol 支持 30 分钟和 12 小时两种写入
推理 token 模型在思考阶段产生、纳入计费输出总量的 token
响应 ID 关联对账日志、后台轮询和对应模型响应的标识
工具费 使用特定托管工具产生的独立费用

1 从 Responses usage 找到 GPT-6.2 Sol 的五项计费用量

1.1 四种输入与一种输出

Responses 的 usage 对象把一次请求的输入和输出分开记录。输入侧给出总量和若干明细,输出侧给出总量和推理子项。复算时要找的是下面这些字段:

计费类别 读取的字段 说明
输入总量 usage.input_tokens 四类输入之和,本身不直接乘费率
缓存读取 input_tokens_details.cached_tokens 账单意义上的读取量
缓存写入合计 cache_write_tokens 两种寿命写入之和
30 分钟写入 cache_write_tokens_details.ttl_30m_tokens 返回寿命明细时使用
12 小时写入 cache_write_tokens_details.ttl_12h_tokens 返回寿命明细时使用
输出 usage.output_tokens 已包含推理 token
推理子项 output_tokens_details.reasoning_tokens 用于理解输出构成,不再单独加价

1.2 普通输入的计算公式

普通输入在 usage 里没有单独字段,需要用减法得到:

普通输入 = input_tokens − cached_tokens − cache_write_tokens

这里减去的是全部写入,即 30 分钟和 12 小时两种之和。两种写入、读取、普通输入四者互斥,同一个 token 只落在其中一类。被写入缓存的 token 按写入费率计费,不会再叠加一遍普通输入价。这一点最容易算错:如果把写入量留在普通输入里,再另计写入费,总额就会偏高。

输出侧的推理 token 也容易重复计算。reasoning_tokens 是 output_tokens 的子集,复算时只用 output_tokens 乘输出费率即可。推理子项适合拿来分析「为什么这次输出这么多」,不适合作为额外的计费项。

gpt-6-2-sol-billing-responses-usage-recalculation-image-1

1.3 复算用计费字段,诊断字段只用于排查

Prompt Caching 的诊断信息里还会出现「可复用量」「未命中估计量」之类的数字。它们解释缓存为什么没命中,比如前缀变了或者长度不足,但不代表实际出账。复算账单时只采用 usage 中的实际计费字段。

如果某个渠道没有返回寿命明细,或缺少 cache_write_tokens,不应根据缺省字段去推定账单。这种情况下应以该渠道自己的出账记录为准。下一节的算例使用合成 usage,所有字段都齐全,方便演示完整算法。


2 把 GPT-6.2 Sol 日志数字换成美元

2.1 官方 Standard 费率表

下表为 OpenAI 官方直连口径,单位 USD / 百万 token。长短档按每次请求的输入总量判断,超过 272K 时整次请求切换为长上下文费率:输入及各类缓存费率 ×2,输出 ×1.5。

Standard 计费类别 短上下文(≤272K) 长上下文(>272K)
普通输入 $2.00 $4.00
缓存读取 $0.10 $0.20
30 分钟缓存写入 $2.50 $5.00
12 小时缓存写入 $5.00 $10.00
输出(已含推理 token) $10.00 $15.00

短上下文的基础标价与 GPT-6.1 Sol 相同。另外,模型卡给出的上下文窗口是 1,050,000 token,最大输入 922,000 token,最大输出 128,000 token。「最多能输入多少」和「从哪里开始按长档计费」是两个独立的数字,一次 300K 输入的请求完全合法,但会整体按长档计价。

2.2 合成 usage 的完整复算

假设一次短上下文 Standard 请求返回如下用量,没有使用工具,也没有附加费:输入总量 12,000,缓存读取 4,000,30 分钟写入 3,000,12 小时写入 4,000,输出 1,800(其中推理 1,200)。

先求普通输入:12,000 − 4,000 − 3,000 − 4,000 = 1,000。然后逐项乘费率:

计费项 token 数 费率(USD/百万) 金额(USD)
普通输入 1,000 2.00 0.0020
缓存读取 4,000 0.10 0.0004
30 分钟写入 3,000 2.50 0.0075
12 小时写入 4,000 5.00 0.0200
输出(含推理 1,200) 1,800 10.00 0.0180
合计 — — 0.0479

这笔账里,12 小时写入只占 4,000 token,却贡献了四成以上的金额。原因是它的单价是普通输入的 2.5 倍,写入当次只有成本,回报要等后续命中才兑现。第 3 节会专门讨论这一点。

建议成本台账给每种计费项分别记录 token 数和费率,而不是只存一个总金额。这样遇到费差时,可以把日志中的实际值直接代入上表,逐行定位差额来源。

2.3 长上下文先换费率,再套同一公式

当输入总量超过 272K,算法不变,只需把上表的费率整列换成长上下文的值。注意切换针对的是整次请求,缓存读取和写入也同步翻倍,输出按 1.5 倍计。因此判断长短档必须放在逐项相乘之前完成。

通过第三方渠道调用时,费率要换成该渠道的口径。以 API易 apiyi.com 为例,2026-11-20 回读其公开定价接口,gpt-6.2-sol 的 billing_expr 同样以 272,000 输入 token 切档:短档普通输入 $2、缓存读取 $0.10、缓存写入 $2.50、输出 $10;长档分别为 $3、$0.15、$3.75、$11.25(USD / 百万 token)。可以看到长档倍率与官方直连不同,接口表达式也只列出一档缓存写入价。实际项目的分组、功能和出账以平台当前配置和账单为准。

下面的代码通过 API易 的 OpenAI 兼容接口发起一次 Responses 请求,并把 usage 原样打印出来,供后续复算使用:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # API易 OpenAI 兼容接口
)

resp = client.responses.create(
    model="gpt-6.2-sol",
    input=[
        {"role": "developer", "content": "固定规则与公共资料(放在前部便于缓存复用)"},
        {"role": "user", "content": "本次请求的具体问题"},
    ],
    max_output_tokens=4000,
)

print(resp.id, resp.status)
print(resp.usage.model_dump())

拿到 usage 后,用一个函数把五项用量换成金额。费率表做成参数,切换官方口径或渠道口径时只改配置:

查看完整复算函数
LONG_THRESHOLD = 272_000

# OpenAI 官方 Standard 口径,USD / 百万 token
OFFICIAL_RATES = {
    "short": {"input": 2.00, "cached": 0.10, "w30m": 2.50, "w12h": 5.00, "output": 10.00},
    "long":  {"input": 4.00, "cached": 0.20, "w30m": 5.00, "w12h": 10.00, "output": 15.00},
}

def _get(d, *keys, default=None):
    for k in keys:
        if not isinstance(d, dict) or k not in d:
            return default
        d = d[k]
    return d

def recalc_cost(usage: dict, rates: dict = OFFICIAL_RATES) -> dict:
    total_in = usage["input_tokens"]
    details = usage.get("input_tokens_details") or {}
    cached = details.get("cached_tokens", 0) or 0

    # 写入字段的位置以实际返回结构为准,这里两处都查
    write_total = details.get("cache_write_tokens", usage.get("cache_write_tokens"))
    ttl = details.get("cache_write_tokens_details") or usage.get("cache_write_tokens_details")
    if write_total is None:
        raise ValueError("缺少 cache_write_tokens,改用渠道出账记录,不要推定")
    w30 = _get(ttl, "ttl_30m_tokens")
    w12 = _get(ttl, "ttl_12h_tokens")
    if write_total and (w30 is None or w12 is None):
        raise ValueError("缺少写入寿命明细,无法区分 30m/12h 费率")
    w30, w12 = w30 or 0, w12 or 0

    plain = total_in - cached - write_total
    output = usage["output_tokens"]
    tier = "long" if total_in > LONG_THRESHOLD else "short"
    r = rates[tier]

    items = {
        "plain_input": plain * r["input"] / 1e6,
        "cache_read": cached * r["cached"] / 1e6,
        "write_30m": w30 * r["w30m"] / 1e6,
        "write_12h": w12 * r["w12h"] / 1e6,
        "output": output * r["output"] / 1e6,
    }
    items["tier"] = tier
    items["model_total"] = round(sum(v for k, v in items.items() if k != "tier"), 6)
    return items

# 用第 2.2 节的合成 usage 验证
demo = {
    "input_tokens": 12000,
    "input_tokens_details": {
        "cached_tokens": 4000,
        "cache_write_tokens": 7000,
        "cache_write_tokens_details": {"ttl_30m_tokens": 3000, "ttl_12h_tokens": 4000},
    },
    "output_tokens": 1800,
    "output_tokens_details": {"reasoning_tokens": 1200},
}
print(recalc_cost(demo))  # model_total: 0.0479

函数遇到缺字段时直接报错,而不是按 0 处理。这样做是为了避免把一笔缺少写入明细的请求错算成「全部按普通输入」。

🎯 技术建议:做成本台账时,建议先用合成 usage 跑通复算函数,再接入真实日志。通过 API易 apiyi.com 可以用同一个 API Key 发起小流量测试请求,把返回的 usage 与平台账单逐条对照,确认字段口径后再上线统计。


3 按调用节奏选择 GPT-6.2 Sol 的缓存寿命

3.1 同一前缀两次与三次访问的账

假设有一段 40,000 token 的固定前缀(系统规则加公共资料),按短上下文 Standard 计价。单次各类成本如下:每次按普通输入是 $0.08,首次写 30 分钟是 $0.10,首次写 12 小时是 $0.20,完整命中读取是 $0.004。下表只比较固定前缀部分,不含每次请求的变动内容和输出。

访问模式 普通输入 30m 写入方案 12h 写入方案
共 2 次(1 写 + 1 读) $0.160 $0.104 $0.204
共 3 次(1 写 + 2 读,均在窗口内) $0.240 $0.108 $0.208

两次访问时,12 小时写入比不缓存还贵 $0.044。三次访问时,两种缓存都比普通输入便宜,但 30 分钟方案仍然只有 12 小时方案的一半左右。前提是这些访问都落在 30 分钟窗口内。

gpt-6-2-sol-billing-responses-usage-recalculation-image-2

3.2 盈亏点:命中几次才回本

把上面的数字换个角度看会更直观(以下为按 M3 费率的推算)。每次完整命中比普通输入省 $0.076。30 分钟写入比普通输入多付 $0.02,命中一次就回本。12 小时写入多付 $0.12,需要在窗口内命中至少两次才回本。

所以 12 小时写入的价值不在于「同一窗口内多命中」,而在于调用间隔超过 30 分钟时还能命中。如果相邻两次使用相同前缀的请求间隔通常在几分钟内,30 分钟写入足够,选 12 小时只会多付写入费。如果请求是每隔一两个小时来一次,30 分钟缓存早已过期,每次都要重新写,这时 12 小时写入加上多次命中才可能更省。

还有两点会改变判断。TTL 是最短计价覆盖时间,不等于缓存一定存活这么久,最终要看 usage 里的实际读取量。30 分钟写入在读取时有刷新规则,高频场景下的实际覆盖可能长于名义的 30 分钟。因此选型后要用真实命中记录回看,而不是只看配置。

3.3 断点布局:让稳定内容排在前面

缓存只对前缀生效,最小可缓存前缀为 1,024 个可见输入 token。实践中可以按复用周期分层设置断点:

  • 长周期公共资料,如产品手册、代码库摘要:放在最前,考虑 12 小时写入。
  • 短周期会话记录,如本轮对话历史:放在其后,考虑 30 分钟写入。
  • 每次变化的即时指令:放在最后,不进入缓存。

GPT-6.2 有一个容易踩的位置细节:顶层 instructions 位于可缓存断点之后。如果把固定规则写在 instructions 里,这部分无法被复用。固定规则更适合放进 input 前部的 developer 消息,instructions 保留给每次请求都可能调整的内容。

💡 选择建议:缓存寿命要结合真实流量来定。建议先在 API易 apiyi.com 上用同一段前缀按实际节奏发几轮请求,统计 cached_tokens 的命中情况,再决定哪一层用 30 分钟、哪一层用 12 小时。不同渠道对缓存写入的计价可能不同,以平台账单为准。


4 按工作流汇总 GPT-6.2 Sol 成本并追查差额

4.1 三种会让账单与预期不符的请求状态

单次请求算对了,工作流的总账仍可能对不上。常见原因来自请求状态:

  1. incomplete:输出达到 max_output_tokens 时,响应可能以 incomplete 结束。此时可能还没有任何可见文字,但输入和推理 token 已经产生并计费。只统计「成功返回内容」的请求,会漏掉这部分成本。
  2. 后台任务:已有响应 ID 的后台任务,轮询时按同一 ID 跟踪,不应把每次轮询都当成新请求重复记账。
  3. 重试:因超时或 incomplete 而新发起的独立调用会生成新的响应,需要另记一笔。重试越多,同一任务的输入成本被重复支付的次数越多。

4.2 工具费与工具带来的后续 token

Responses 支持文件搜索、网页搜索、代码解释器和图像生成等工具。使用图像生成时,Sol 在流程中发起工具调用,图像由单独的图像工具完成,费用也按工具规则计。工具费按实际类型核对,例如网页搜索按 $10/千次计,搜索返回的内容 token 另按模型费率计价。

复算时要确认 usage 覆盖了哪些 token。工具结果回填到下一轮模型请求时,会表现为后续请求的输入量增加,这部分成本落在后续请求上,而不是工具调用本身。一个带搜索的工作流,账单通常由「工具次数费 + 多轮模型请求费」两部分组成。

4.3 最小日志项

要让工作流可对账,每个模型响应至少记录以下字段:

日志项 作用
工作流 ID 把多次请求归到同一任务
响应 ID 关联后台轮询,区分重试与同一请求
模型 确定费率表,如 gpt-6.2-sol
服务档 确认是否为 Standard 口径
最终状态 识别 completed、incomplete 等
用量分项 普通输入、读取、30m 写入、12h 写入、输出、推理
工具 工具类型与调用次数
费用 按分项复算的金额与长短档标记

有了这张表,按工作流 ID 分组求和就能得到单次任务成本。差额排查也有了顺序:先看是否有 incomplete 和重试,再看缓存读取是否低于预期,最后核对工具次数。

4.4 逐请求估算与官方导出相互核验

逐请求估算适合实时预算控制,但在多步工具调用、重试或用量字段缺失时容易出现偏差。建议定期把估算汇总与官方用量或费用导出对照,差额超过设定阈值时回到日志逐行检查。通过第三方渠道转接时,对照对象应换成该渠道的出账字段和费率。

💰 成本建议:如果团队同时在用多个模型,可以通过 API易 apiyi.com 用一个 API Key 统一调用,再按本文的最小日志项落库。统一入口能让工作流 ID 和费用口径保持一致,月底对账时少一层渠道换算。


GPT-6.2 Sol 账单的检验方法

拿到任意一条 Sol 请求记录,可以按这个顺序验证账单:先确认输入总量是否超过 272K,选定费率列;再用 input_tokens 减去读取和全部写入得到普通输入;然后五项分别乘费率相加,与账单对比。如果单请求一致而工作流总额不一致,就去日志里找 incomplete、重试和工具调用。

缓存是否划算,最终看的是 usage 里的实际读取量和调用间隔。30 分钟写入命中一次即可回本,12 小时写入需要窗口内至少两次命中,且只有在调用间隔超过 30 分钟时才体现优势。

需要拿真实流量验证这些结论时,可以在 API易 apiyi.com 申请免费测试额度,用文中的复算函数逐条对照平台账单。


📚 参考资料

  1. OpenAI GPT-6.2 Astra 与 Sol 发布公告:发布时间与产品定位

    • 链接: openai.com/index/introducing-gpt-6-2-astra-sol
    • 说明: 了解 Sol 面向日常工作与多步骤 Agent 的定位
  2. GPT-6.2 Sol 模型卡:上下文规格、费率与长上下文倍率

    • 链接: developers.openai.com/api/docs/models/gpt-6.2-sol
    • 说明: 本文费率表与 272K 切档规则的来源
  3. Prompt Caching 指南与缓存诊断:缓存字段、TTL 与断点规则

    • 链接: developers.openai.com/api/docs/guides/prompt-caching
    • 说明: 解释 cached_tokens、写入寿命与最小可缓存前缀
  4. Reasoning 指南:推理 token 与 incomplete 状态

    • 链接: developers.openai.com/api/docs/guides/reasoning
    • 说明: 理解推理用量如何计入输出
  5. 单次工作流费用控制指南:按工作流汇总 Responses 费用

    • 链接: developers.openai.com/cookbook/articles/per_run_spending_controller_responses_api
    • 说明: 工作流级预算控制的参考实现
  6. API易 模型总表:渠道挂牌与入口信息

    • 链接: docs.apiyi.com/models.md
    • 说明: 查看 gpt-6.2-sol 的可用入口与分组

作者:APIYI 技术团队
技术交流:欢迎在 API易 apiyi.com 首页联系我们,更多接入资料可访问 docs.apiyi.com 文档中心

延伸阅读

类似文章