本文部分内容由 AI 辅助整理，所有价格、数据、命令均标注了出处；成本速算脚本为本人在本机真实运行并贴出原始输出。

8 月 6 日，DeepSeek 在开发者后台发了条公告：拟整体上调 DeepSeek API 服务定价，预计涨幅较大，建议企业和个人开发者合理规划调用量。细则和生效时间还没公布。

但对大多数普通用户来说，还有一件更近的事：DeepSeek 的 API 早就不是一口价了——高峰时段（工作日 9:00-12:00、14:00-18:00）全部计费项价格翻倍，只有深夜和周末才是平峰原价。

这就带来一个问题：如果你日常调用刚好集中在工作日白天，那你实际付的早就不是价目表上那个「每百万 token 几毛钱」了。这篇就借 DeepSeek 涨价这个时点，把这笔账算清楚：你的用量画像下，继续用 API 还是上本地更划算。文末附一个零依赖的成本速算脚本，把你的日调用量、高峰占比、本地月成本代进去，几分钟出结论。

一、先看热点事实：涨价在即，高峰已翻倍

把两件事分开，别混：

• 已执行：峰谷分时计费。工作日 9:00-12:00、14:00-18:00 为高峰，全部计费项价格 ×2；凌晨 00:30-08:30 以及周末、法定节假日为平峰，执行原价。
• 拟执行：8 月 6 日公告拟整体上调 API 定价，涨幅较大，具体细则与生效时间未公布，以官方最新公告为准。

两条放一起，方向是一致的：DeepSeek 正在从「地板价」往回调。官方把高峰翻倍归因于「更合理地配置资源、提升服务稳定性」；涨价预告则被业内普遍解读为 V4 正式版发布在即。

以上价格与公告信息为 2026-08-08 媒体公开报道口径，以 DeepSeek 官方最新公告为准。

二、反常识一：「平峰价」多数人吃不到

价目表上那个「输入 1 元 / 输出 2 元每百万 token」，是平峰价。但绝大多数人的使用习惯恰恰在工作日白天——上班办公、联调测试、白天处理业务，全是高峰时段。

结果就是：如果你的调用 80% 落在高峰时段，你实际付的是 1.8 倍价；如果是 100% 高峰，就是 2 倍价。「每百万 token 几毛钱」是给深夜批处理和周末用户的价格，白天办公的团队通常吃不到。

这是一个容易被忽略、但影响很大的变量：价目表上差 1 倍，换算成月账单可能差出一台本地的折旧。

举个具体的：同一个日调用 1000 万 token 的应用（输出占三成），如果调用全落在平峰，按 V4 Flash 平峰价算，一个月 API 费约 390 元；如果 80% 落在高峰，月费直接到约 702 元。应用什么都没变，只是「你几点调用」变了，账单多了 80%。

三、反常识二：涨价后，本地部署的临界点反而更低

先说一个判断（不是预测具体涨多少，细则没公布）：

本地部署的成本结构是「一次性硬件 + 每月电费运维」，跟 API 单价没有直接关系；而 API 月费是「用量 × 单价」。**API 单价是本地这笔账的分母——单价涨，本地更划算的临界用量就降。**所以如果整体调价落地，之前「用量还不够大、用 API 更划算」的团队，临界点会被拉低，可能一跨就跨过去了。

这也是这篇值得现在算账的原因：趁着当前价格还贴着地板，把临界点算清楚，涨价细则出来你心里就有数了。

把临界点公式写出来就清楚了：

临界日调用量 = 本地月成本 ÷ 30 ÷ 平均每 token 成本
平均每 token 成本 = (输入占比 × 输入价 + 输出占比 × 输出价) × 峰谷加权

分母里是「单价」——单价涨，临界点必降。举个示意（涨多少是我自拟的演示幅度，非官方预测）：按当前平峰价，日调用 2000 万、高峰占 80% 的画像，临界点约 1424 万 token/日；若输出价从 2 元涨到 3 元，同画像的临界点会降到约 1157 万。方向确定，幅度只取决于涨多少。

四、账怎么算：一页纸的成本模型

不搞复杂的 TCO 模型，就两笔账：

API 月费 = 日用量 × 30 天 × (输入占比 × 输入价 + 输出占比 × 输出价) × 峰谷加权
本地月成本 = 硬件折旧 + 电费 + 运维（你每月实际为本地部署花的钱）

• 输入 token 便宜、输出 token 贵（输出价通常是输入的 2 倍），所以「输出占比」是关键输入；
• 峰谷加权：价目表是平峰价，把「高峰时段占比」代进去，算出你实际的平均单价；
• 本地月成本没有标准答案，只有你自己的数——脚本不猜任何硬件价格，你填多少算多少。

临界日调用量 = 本地月成本 ÷ 30 ÷ 平均每 token 成本。日用量超过这个数，本地更省；低于，API 更省。

五、本地部署的产能：我们实测的账

算账之前，先确认一件事：本地部署不是玩具，它撑得起真实团队用量。

我们在这套环境上实测过它的产出能力：2 台 DGX Spark 直连（TP=2，合计 256 GB 统一内存），跑 deepseek-v4-flash-0731，官方 FP8 权重，没有自行量化。都是我们自己机器上实测的，只代表这一套环境、这一个模型版本、这一组参数，不是行业通用值。

• 单并发 84.89 tok/s，八并发合计 284.80 tok/s（decode 阶段，从首 token 到末 token）；
• 满负荷一天理论输出约 2460 万 token（284.80 × 86400 秒，实际有闲置和高峰不均，只会更低）。

对照第四节的临界日用量——示例里约 1424 万到 2331 万 token/日——这个产能是够得上的。本地部署的瓶颈从来不是「撑不撑得住」，而是「值不值得」；而值不值得，正是第四节的账。

再补一刀关于「利用率」：本地这套产能，只有被用起来才算数。如果团队用不到这个量，机器大部分时间闲着，那折旧买的就是闲置；而 API 是「用多少付多少，空闲不花钱」。所以本地值不值得，不只看价格表，更看利用率——这也是为什么全文强调「临界日用量」，而不是「本地一定便宜」。

（注：这次实测是两台 Spark 网线直连，没有经过存储/调度中枢；本文只陈述这套直连环境的数，不涉及其他拓扑。）

六、脚本：把账算给你看

下面的脚本零依赖，只用标准库。参数就是第四节的模型：日调用量、输出占比、高峰时段占比、本地月成本；API 单价默认取 DeepSeek V4 Flash 平峰公开价，可以覆盖成你的协议价。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""h21_cost_bench.py -- DeepSeek API 月费 vs 本地部署月成本 速算。

背景：DeepSeek 于 2026-08-06 官宣拟整体上调 API 定价（涨幅较大、细则未公布），
且高峰时段（工作日 9:00-12:00、14:00-18:00）计费已翻倍。
这个脚本把你自己的用量画像代进去，算两笔账：
  1) 按你的「日调用量 + 高峰时段占比」算 API 月费；
  2) 对比你本地部署的月成本（硬件折旧 + 电费 + 运维，自己填），
     并反推「本地更划算」的临界日调用量。

零依赖，只用标准库。API 单价默认取 DeepSeek V4 Flash 平峰公开价
（2026-08-08 媒体公开报道口径），可用参数覆盖 —— 公开价会变，
正式调价细则未公布，一切以官方最新公告为准。

用法：
  # 用默认价（DeepSeek V4 Flash 平峰价），填你自己的用量与本地月成本
  python3 h21_cost_bench.py --daily-tokens 20000000 --peak-ratio 0.8 \
      --local-monthly 1000

  # 覆盖 API 单价（比如你有协议价）
  python3 h21_cost_bench.py --in-price 1.5 --out-price 3.0 --local-monthly 800

退出码：0 = 正常；2 = 参数非法。
"""

import argparse
import sys


def effective_price(flat, peak_ratio, peak_mult):
    """高峰翻倍下，平峰价加权成「实际平均单价」。

    价目表是平峰价；高峰时段调用占比 peak_ratio 的部分按 peak_mult 倍计。
    """
    return flat * (1 + (peak_mult - 1) * peak_ratio)


def run(daily, out_ratio, peak_ratio, local_monthly,
        in_price, out_price, peak_mult, days):
    in_tok = daily * (1 - out_ratio)          # 日输入 token
    out_tok = daily * out_ratio               # 日输出 token
    in_eff = effective_price(in_price, peak_ratio, peak_mult)
    out_eff = effective_price(out_price, peak_ratio, peak_mult)

    # API 日费：token 数 × 单价（单价=元/百万token，故除 1e6）
    api_day = (in_tok * in_eff + out_tok * out_eff) / 1e6
    api_month = api_day * days
    diff = local_monthly - api_month          # 正=本地贵；负=本地省

    # 临界日调用量：本地月成本==API月费时的日用量
    unit = ((1 - out_ratio) * in_eff + out_ratio * out_eff) / 1e6  # 元/token
    critical = (local_monthly / days) / unit if unit > 0 else float('inf')

    return api_day, api_month, diff, critical, in_eff, out_eff


def fmt(n):
    return ('%s' % int(round(n))) if n >= 1e5 else ('%.2f' % n)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('--daily-tokens', type=float, default=20_000_000,
                    help='日调用 token 总量（默认 20000000）')
    ap.add_argument('--output-ratio', type=float, default=0.3,
                    help='输出 token 占比 0~1（默认 0.3，输出单价更高）')
    ap.add_argument('--peak-ratio', type=float, default=0.5,
                    help='高峰时段（工作日 9-12/14-18）调用占比 0~1（默认 0.5）')
    ap.add_argument('--local-monthly', type=float, default=1000,
                    help='本地部署月成本：硬件折旧+电费+运维，元/月（默认 1000，必填你自己的）')
    ap.add_argument('--in-price', type=float, default=1.0,
                    help='API 输入平峰价 元/百万token（默认 1.0 = DeepSeek V4 Flash 公开价）')
    ap.add_argument('--out-price', type=float, default=2.0,
                    help='API 输出平峰价 元/百万token（默认 2.0 = DeepSeek V4 Flash 公开价）')
    ap.add_argument('--peak-mult', type=float, default=2.0,
                    help='高峰翻倍系数（默认 2.0，官方高峰 2 倍价）')
    ap.add_argument('--days', type=int, default=30, help='月计费天数（默认 30）')
    args = ap.parse_args()

    if args.daily_tokens <= 0 or args.output_ratio < 0 or args.output_ratio > 1:
        print('参数非法: --daily-tokens 必须 > 0，--output-ratio 必须在 0~1')
        return 2
    if args.peak_ratio < 0 or args.peak_ratio > 1:
        print('参数非法: --peak-ratio 必须在 0~1')
        return 2
    if args.local_monthly < 0:
        print('参数非法: --local-monthly 不能为负')
        return 2
    if args.in_price <= 0 or args.out_price <= 0 or args.peak_mult <= 1:
        print('参数非法: 单价必须 > 0，--peak-mult 必须 > 1')
        return 2

    api_day, api_month, diff, critical, in_eff, out_eff = run(
        args.daily_tokens, args.output_ratio, args.peak_ratio,
        args.local_monthly, args.in_price, args.out_price,
        args.peak_mult, args.days)

    print('用量画像')
    print('  日调用 token    : %s' % fmt(args.daily_tokens))
    print('  输出占比        : %.0f%%' % (args.output_ratio * 100))
    print('  高峰时段占比    : %.0f%%' % (args.peak_ratio * 100))
    print('  API 平峰单价    : 输入 %.2f / 输出 %.2f 元每百万token' % (args.in_price, args.out_price))
    print('  高峰翻倍系数    : %.1fx' % args.peak_mult)
    print('')
    print('计算结果')
    print('  高峰加权后输入价: %.2f 元每百万token' % in_eff)
    print('  高峰加权后输出价: %.2f 元每百万token' % out_eff)
    print('  API 日费        : %.2f 元' % api_day)
    print('  API 月费(%d天)  : %.2f 元' % (args.days, api_month))
    print('  本地月成本      : %.2f 元' % args.local_monthly)
    if diff < 0:
        print('  本地每月省      : %.2f 元' % (-diff))
    else:
        print('  本地每月贵      : %.2f 元' % diff)
    print('')
    print('临界日调用量      : 约 %s token/日' % fmt(critical))
    print('   解释: 日用量超过这个数, 本地月成本低于 API 月费; 低于则 API 更省。')
    verdict = '本地部署每月更省' if diff < 0 else 'API 每月更省'
    print('结论              : 这个用量画像下, %s。' % verdict)
    print('')
    print('口径说明')
    print('  · API 月费 = 日用量按「高峰/平峰占比加权后的单价」折算, 默认价取 DeepSeek')
    print('    V4 Flash 平峰公开价（2026-08-08 媒体公开报道, 以官方最新公告为准）。')
    print('  · 本地月成本(硬件折旧+电费+运维)是你自己填的数, 脚本不猜测任何硬件价格。')
    print('  · 临界日调用量只算 API 与本地两条路线的金钱账; 数据主权、合规、稳定性等')
    print('    非金钱因素不在本脚本内, 需要单独权衡。')
    return 0


if __name__ == '__main__':
    sys.exit(main())

脚本输出三样东西：按你用量算出的 API 月费、本地月成本、以及临界日调用量。

七、真跑：同样的用量，两种时间习惯

同样的日调用量（2000 万 token）、同样的本地月成本（1000 元/月，示例参数，换成你自己的），只看「高峰时段占比」不同：

场景 A：工作日白天为主（80% 调用落在高峰）

用量画像
  日调用 token    : 20000000
  输出占比        : 30%
  高峰时段占比    : 80%
  API 平峰单价    : 输入 1.00 / 输出 2.00 元每百万token
  高峰翻倍系数    : 2.0x

计算结果
  高峰加权后输入价: 1.80 元每百万token
  高峰加权后输出价: 3.60 元每百万token
  API 日费        : 46.80 元
  API 月费(30天)  : 1404.00 元
  本地月成本      : 1000.00 元
  本地每月省      : 404.00 元

临界日调用量      : 约 14245014 token/日
   解释: 日用量超过这个数, 本地月成本低于 API 月费; 低于则 API 更省。
结论              : 这个用量画像下, 本地部署每月更省。

口径说明
  · API 月费 = 日用量按「高峰/平峰占比加权后的单价」折算, 默认价取 DeepSeek
    V4 Flash 平峰公开价（2026-08-08 媒体公开报道, 以官方最新公告为准）。
  · 本地月成本(硬件折旧+电费+运维)是你自己填的数, 脚本不猜测任何硬件价格。
  · 临界日调用量只算 API 与本地两条路线的金钱账; 数据主权、合规、稳定性等
    非金钱因素不在本脚本内, 需要单独权衡。

场景 B：深夜 / 周末为主（10% 调用落在高峰）

用量画像
  日调用 token    : 20000000
  输出占比        : 30%
  高峰时段占比    : 10%
  API 平峰单价    : 输入 1.00 / 输出 2.00 元每百万token
  高峰翻倍系数    : 2.0x

计算结果
  高峰加权后输入价: 1.10 元每百万token
  高峰加权后输出价: 2.20 元每百万token
  API 日费        : 28.60 元
  API 月费(30天)  : 858.00 元
  本地月成本      : 1000.00 元
  本地每月贵      : 142.00 元

临界日调用量      : 约 23310023 token/日
   解释: 日用量超过这个数, 本地月成本低于 API 月费; 低于则 API 更省。
结论              : 这个用量画像下, API 每月更省。

口径说明
  · API 月费 = 日用量按「高峰/平峰占比加权后的单价」折算, 默认价取 DeepSeek
    V4 Flash 平峰公开价（2026-08-08 媒体公开报道, 以官方最新公告为准）。
  · 本地月成本(硬件折旧+电费+运维)是你自己填的数, 脚本不猜测任何硬件价格。
  · 临界日调用量只算 API 与本地两条路线的金钱账; 数据主权、合规、稳定性等
    非金钱因素不在本脚本内, 需要单独权衡。

看出差别了吗：同一个日用量、同一个本地月成本，白天为主的团队，本地每月省 404 元；深夜为主的团队，API 反而省 142 元。「你什么时候用」这个变量，直接把结论翻过来了。

（示例里的本地月成本 1000 元是我的演示值，不是任何硬件的价格——换成你实际每月花的钱，结论才属于你。）

八、DeepSeek 峰谷价目速查表

脚本默认价来自 DeepSeek 公开价目，平峰价如下（元/百万 token，2026-08-08 公开报道口径，以官方最新公告为准）：

模型	输入（缓存命中）	输入（未命中）	输出	高峰（全部翻倍）
V4 Flash	0.02	1	2	输入 2 / 输出 4
V4 Pro	0.025	3	6	输入 6 / 输出 12

注意脚本按最保守口径算：默认用「输入未命中」价（1 元），如果你缓存命中率高，实际成本比脚本结果更低，临界点也更远。

怎么确认你自己的实际价格和高峰占比？两个动作：一是看 DeepSeek 平台当前的价目页——本文价格以 2026-08-08 公开报道为准，随时会变；二是拉你自己近一个月的账单，看「几点调的、每次多少 token」，算一下高峰占比。这两个数填进脚本，比任何通用结论都准。

九、决策树：什么时候该切本地

把前面几节收拢成一张决策树（判断，不是实测）：

• 继续用 API：低频、脉冲式调用（一天几次到几百次）；调用集中在平峰时段；本地月成本一时凑不齐；数据不敏感。
• 认真考虑本地：日调用稳定在几千万 token 以上；调用集中在工作日白天（高峰占比高）；数据敏感、不想出企业；用量还在增长。
• 两个容易算错的地方：一是把「高峰占比」忽略，按平峰价估月费，低估了账单；二是只算硬件不算运维，把部署的人力成本漏掉。

关于「稳定高频 + 数据敏感 + 高峰时段多」的团队，本地部署大概率在临界点以内——具体还是拿脚本代你自己的数。

十、如果你决定本地，又不想自己折腾部署

这一节是判断，不是实测。

前面算的「本地月成本」，只算了硬件折旧、电费、运维。但部署本身有一块不写在账上的成本：装推理框架、配权重、调并发、盯故障，这些时间和人力，也是钱。

如果你算下来决定上本地，又不想把这些时间搭进去，可以买一套装好调通的交付——拿到就能用本地的 DeepSeek V4 Flash，不用自己从零搭。完全没必要为了「省 API 钱」这一层，把自己从开发者变成运维——部署的折腾成本，要一起算进那笔账里。

小结

DeepSeek 要涨价是时点，高峰翻倍是机制，本地部署划不划算则是你自己的用量画像。这篇不替你做决定，只给方法和工具：

1. 记住「平峰价」多数人吃不到——工作日白天调用为主，实际付的是 1.8~2 倍；
2. 涨价会拉低本地部署的临界用量——方向确定，幅度未知；
3. 用脚本把你的日用量、高峰占比、本地月成本代进去，几分钟算出临界点；
4. 本地部署的产能（八并发 284.80 tok/s）撑得住团队用量，值不值得另算。

价格会变、公告会更新，但「用你自己的数算你的账」这个方法，什么时候都不过时。