第 5 章　API 与成本：搞懂钱花在哪

预计阅读 18 分钟 · 全文约 5,334 字

本章产出：一份个人 AI 成本账本，以及一套"不被割"的中转站选择标准。

开场：一千块是怎么烧掉的

有个人，第一次用 API。

他听说"用 API 比订阅便宜"，兴冲冲充了 100 块，接上客户端，开始用。

第一天，他让 AI 读了一篇 30 页的 PDF，问了几个问题。第二天，他又让 AI 分析了一整本电子书。第三天，他搭了个小脚本，批量改写 2000 条商品标题。

第四天，他打开后台一看：余额 0.3 元。

他懵了：我也没问多少问题啊，怎么就没了？

问题就出在"没问多少问题"这个感觉上。

API 收费不是按"问了多少句"，是按 token 用量。读一本 20 万字的书，光"输入"就是 20 万 token；批量处理 2000 条标题，每条输入输出都算钱——积累起来，几百万 token 就没了。

这一章，人家就把这笔账给你算清楚。 算明白了，你才知道钱该花在哪、怎么省、哪些坑不能踩。

5.1 API Key 是什么、怎么管

先理解它是什么

API Key 是一串字符串，形如：

sk-4803fdcbf0eed2a4dccf885f58bb815e72c4d3b3cacb0a9a84a44795c0e3a06d

它干的事，相当于银行卡 + 密码：

证明"你是谁"（哪个账户）
决定"钱从谁的账上扣"

谁拿到这串字符，谁就能花你的钱。

三个必须养成的习惯

习惯一：一个用途一个 key。

不要所有项目共用一个 key。分开的好处：

哪个项目烧钱多，一看就知道
某个 key 泄露，只影响那一个项目
可以单独设额度上限

习惯二：key 只存在两个地方——服务商后台，和你的本地配置。

不要：

发到聊天群里（包括"技术交流群"）
截图时露出来（OCR 能读）
提交到 GitHub（有爬虫专门扫）
写在前端代码里（浏览器能看到）
存在共享文档里

习惯三：设额度上限。

大部分服务商支持"每月消费上限"。设一个你承受得起的数，比如 50 元。防止被刷爆时一夜回到解放前。

泄露了怎么办

立刻去服务商后台，作废这个 key
生成新 key
检查账单，看有没有异常消费
如果已经产生损失，联系服务商申诉

速度是关键。 key 泄露后几分钟内就可能被刷，越早作废损失越小。

5.2 token 计费：输入输出怎么算钱

计费的基本单位

所有 API 都按 token 计费，分两部分：

输入 token：你发给模型的内容（提示词、文档、对话历史）
输出 token：模型生成的内容

输出通常比输入贵 2-4 倍。 因为生成比阅读更耗算力。

一个具体例子

假设某模型价格：输入 1 元/百万 token，输出 4 元/百万 token。

你让它读一篇 5 万字的报告（约 8 万 token），然后写一段 1000 字的总结（约 1500 token）。

成本计算：

输入：80,000 token × 1 元/百万 = 0.08 元
输出：1,500 token × 4 元/百万 = 0.006 元
合计：约 0.086 元

看起来不贵？ 但你如果一天做 100 次，就是 8.6 元；一个月 258 元。

而且这还没算对话历史。

对话历史的隐性成本

每次对话，整个历史都会被重新计费。

你聊了 10 轮，第 11 轮的时候，前面 10 轮的内容全部作为"输入"再算一遍。

所以：

短对话：便宜
长对话：越聊越贵（前面的内容每次都要重新算钱）
多轮长文讨论：极贵

省钱技巧：长对话定期总结，开新对话；不要在一段对话里堆几十轮。

成本对比

图 5-1：同样的活，差价 60 倍

不同模型的价差

价差能到 100 倍以上。

类型	价格区间（每百万 token）
顶级旗舰模型	几十到上百元
主流中端模型	几元到几十元
便宜小模型	几毛到几元
开源模型自部署	只有硬件和电费

这解释了为什么"用对模型"能省大钱：一个分类任务用旗舰模型，纯属烧钱。

怎么估算你的用量

给你一个实用公式：

月成本 ≈ 每天请求数 × 每次平均 token × 30 × 单价

举例：

每天 50 次请求
每次平均 5000 token（输入+输出）
用中端模型，按 5 元/百万 token 算

50 × 5000 × 30 × 5 / 1,000,000 = 37.5 元/月

先估算，再充值。 别一上来充几百。

5.3 中转站商业模式：号池、倍率、跑路

中转站怎么赚钱

核心模式：低价买入，加价卖出，赚差价。

具体有四种货源：

货源一：正规批量采购。 从厂商拿企业折扣，转卖赚差价。这是最干净的。

货源二：账号池（号池）。 批量注册免费/低价账号，共享给用户用。成本极低，但违反服务商条款，随时被封。

货源三：盗刷信用卡。 用盗来的卡开账号，成本几乎为零。这是犯罪，风险极高。

货源四：模型降级。 收你 GPT-4 的钱，实际转发给便宜模型。答复质量差一截，你还不一定发现。

大多数便宜得离谱的中转站，是二、三、四的混合。

倍率：中转站的定价游戏

你在中转站后台经常看到"倍率"这个词：

官方模型倍率 1.0
本站倍率 0.12

意思是：官方价格 × 0.12 = 你付的价格。

0.12 倍是什么概念？ 官方 100 块的东西，你花 12 块。

为什么能这么便宜？

如果货源是正规采购：不可能，成本都不止
如果货源是号池：可能，但随时封
如果货源是盗刷：可能，但违法
如果模型降级：可能，但你被坑了

一句话：便宜得不符合成本规律的，一定有猫腻。

跑路盘的四个征兆

征兆一：价格低到离谱。 官方 1 折以下，还长期稳定，不符合商业逻辑。

征兆二：疯狂促销。 "充 100 送 500""限时 0.05 倍"，这是在快速圈钱，圈完就跑。

征兆三：客服失联/群禁言。 群里只许吹捧，不许提问；客服几天不回。

征兆四：提现困难/规则突变。 突然改条款、突然限制提现、突然"系统维护"。

遇到任何一个，立刻停止充值，把余额用完。

怎么降低风险

小额多次：一次充 10-20 块，用完再充
测模型真假：用几个"只有真模型才知道"的问题测（比如问它某个具体版本的细节）
看运营时间：开了半年以上的，比刚开三天的稳
看社区口碑：搜一下"XX 中转站跑路"，有前科的别碰
敏感数据不走中转：合同、病历、内部资料，用官方或本地模型

5.4 自建中转：one-api / new-api 部署

为什么要自建

如果你有一堆上游 key（官方、各种渠道），想统一管理、统一计费、分给团队用，就可以自建一个中转。

好处：

所有 key 统一管理
可以给不同人分配不同额度
可以看每个人的用量
可以接多个上游，自动切换

主流方案

one-api：老牌开源项目，Go 语言写的，支持几十种上游，界面简洁。社区活跃。

new-api：one-api 的衍生版，功能更多（支持更多渠道、更好的计费、更多模型），更新快。

部署步骤（Docker 版，最简单）

bash

# 1. 装 Docker（略，各系统不同）
# 2. 拉镜像并运行
docker run -d --name one-api \
  -p 3000:3000 \
  -v /home/oneapi/data:/data \
  -e TZ=Asia/Shanghai \
  justsong/one-api

# 3. 打开浏览器访问 http://你的IP:3000
# 4. 默认账号 root，密码 123456，首次登录立刻改密码

然后：

在后台"渠道"里添加上游（填上游的 base_url 和 key）
在"令牌"里创建你自己的 key，设置额度
把你的客户端 base_url 指向 http://你的IP:3000/v1

部署的三个坑

坑一：暴露在公网不设防。 直接开 3000 端口到公网，几天就会被扫到、爆破。至少改默认密码，最好加反向代理和 HTTPS。

坑二：数据卷没挂载。 容器删了，数据全没。一定要挂载 /data 目录。

坑三：上游 key 配错。 base_url 少了 /v1、模型名对不上，都会导致请求失败。配置完先用 curl 测一下。

自建适合谁

有多个上游 key 要管理
团队共用，要分配额度
想完全掌控数据流向

不适合：只有一两个 key 的个人用户——直接用客户端填 key 就行，没必要多一层。

5.5 成本优化：缓存、批处理、小模型分流

优化一：小模型分流

原则：什么任务用什么模型。

任务	用什么
分类、打标签	最便宜的小模型
提取信息、格式转换	小模型
简单问答	中端模型
复杂推理、写代码	旗舰模型
关键决策、最终输出	旗舰模型

实测效果：把 80% 的简单任务分流到小模型，成本能降 70-90%。

优化二：缓存

同样的请求，不要重复付费。

提示词缓存：很多厂商支持"相同前缀缓存"，重复的系统提示词只收一次钱（打折）
结果缓存：你自己在应用层缓存"问题→答案"，相同问题直接返回缓存

适合场景：FAQ 问答、固定模板生成、重复性任务。

优化三：批处理

很多厂商提供"批处理 API"：把大量请求打包提交，24 小时内返回，价格打五折甚至更多。

适合：不要求实时返回的批量任务（数据清洗、内容审核、批量翻译）。

优化四：控制上下文

最容易被忽视的省钱点。

长对话定期总结，开新的
不要每次把整本书塞进去，用 RAG 只取相关段落
系统提示词精简，别写几千字的人设

一个实测数据：把上下文从 10 万 token 压到 1 万 token，单次成本降 90%。

优化五：输出控制

输出比输入贵 2-4 倍。

明确要求"简洁回答""不超过 100 字"
需要结构化输出时，用 JSON 模式，避免它啰嗦
不需要解释的时候，明确说"只给结果，不要解释"

优化六：用开源模型

高频、简单的任务，本地跑开源模型，边际成本接近零。

比如：文本分类、敏感词检测、简单提取。用 7B 模型在本地跑，一分钱不花。

5.6 跑路盘识别清单

人家给你一张清单，遇到中转站，逐条打勾：

危险信号（中一条就要警惕）：

[ ] 价格低于官方 1 折
[ ] 疯狂促销（充值送几倍）
[ ] 客服只在群里说话，私聊不回
[ ] 群里禁言，只允许发好评
[ ] 网站简陋，没有备案信息/公司信息
[ ] 上游模型列表频繁变动（说明渠道不稳）
[ ] 要求"必须预充值大额才能用"
[ ] 提现要"满多少才能提"
[ ] 搜索"站名 + 跑路"有前科

安全信号（越多越稳）：

[ ] 运营半年以上
[ ] 价格在官方 3-8 折之间（符合成本逻辑）
[ ] 有公开的运营主体信息
[ ] 支持小额充值
[ ] 社区有真实用户讨论（不是纯广告）
[ ] 提供退款/按量计费选项

最后一条铁律：永远不要在一家中转站放超过你一个月的用量预算。 跑路是常态，不是意外。

5.7 实战：算清一次批量任务的账

场景

你要把 500 条商品标题改写成营销文案。每条标题平均 20 字，输出平均 60 字。

算账

输入 token：

系统提示词：约 200 token
每条任务说明：约 50 token
标题本身：20 字 × 1.5 ≈ 30 token
合计：约 280 token

输出 token：60 字 × 1.5 ≈ 90 token

单条合计：约 370 token

500 条：185,000 token

按不同模型算成本：

模型档位	单价（元/百万 token，输入/输出）	总成本
旗舰模型	30 / 120	约 10.5 元
中端模型	5 / 20	约 1.7 元
便宜小模型	0.5 / 2	约 0.17 元

差距 60 倍。

这就是"选对模型"的价值——同样的活，旗舰模型 10 块，小模型 1 毛 7。

什么时候必须用贵的

任务	能否用小模型
标题改写（有明确模板）	能
合同条款提取（要精确）	谨慎，要抽检
法律意见生成	必须用旗舰 + 人工复核
代码重构	用中高端

一个省钱的三段式方案

第一段：小模型批量初稿（成本 0.17 元）
第二段：人工抽检 10%，找出问题类型
第三段：只把有问题的 10% 用中端模型重做（成本 0.17 元）

总成本 0.34 元，效果接近全用中端模型（1.7 元）。

核心思想：不是"一刀切用最便宜的"，是"分层处理，好钢用在刀刃上"。

5.8 一个月的真实账单复盘

账单长什么样

一个中度用户（每天 20-30 次请求，偶尔处理长文档）的月账单，大概是这样的：

项目	用量	费用
日常问答（中端模型）	300 万 token	约 30 元
长文档处理（旗舰模型）	50 万 token	约 50 元
批量任务（小模型）	800 万 token	约 6 元
图片理解（多模态）	200 张图	约 10 元
合计	—	约 96 元

结论：真正烧钱的不是"日常聊天"，是长文档 + 旗舰模型。

三个"隐形账单"

隐形账单一：长对话的历史。

一次聊 50 轮的对话，后面的每一轮都在重复计费前面的内容。同一段对话，越聊越贵。

隐形账单二：失败的请求也收费。

请求超时、输出被截断、工具调用失败——只要模型生成了 token，就计费。

隐形账单三：重试。

网络抖动导致的自动重试，会重复计费。生产环境要做"幂等"，避免重复提交。

怎么把账单砍一半

① 把长文档处理换成"分段 + 小模型预筛"

先让小模型读一遍，标出"可能重要的段落"，再只用旗舰模型处理这些段落。

② 把长对话改成"任务制"

不要一个对话聊一天。一个任务一个对话，做完就关。

③ 用缓存

相同的前缀（系统提示词）用厂商的缓存功能，能省 50%-90%。

④ 设预算上限

在服务商后台设"每月上限"，防止意外烧穿。

⑤ 定期看账单

每周花 5 分钟看一眼"哪个模型花得最多"，你会发现惊喜（或者惊吓）。

5.9 自己做一个 token 用量监控

为什么要自己算

服务商后台的账单是"事后"的，等看到的时候钱已经花了。自己记，才能实时知道花到哪了。

最小实现（Python，包一层 API 调用）

python

import json, time, os
from openai import OpenAI

client = OpenAI(base_url="https://你的接口/v1", api_key="sk-xxx")
LOG = "usage_log.jsonl"

# 价格表（元/百万 token），按你自己的服务商填
PRICE = {
    "小模型":   {"in": 0.5,  "out": 2.0},
    "中端模型": {"in": 5.0,  "out": 20.0},
    "旗舰模型": {"in": 30.0, "out": 120.0},
}

def call(model_tier, model, messages, **kw):
    resp = client.chat.completions.create(model=model, messages=messages, **kw)
    u = resp.usage
    p = PRICE[model_tier]
    cost = (u.prompt_tokens * p["in"] + u.completion_tokens * p["out"]) / 1_000_000

    rec = {
        "ts": time.strftime("%Y-%m-%d %H:%M:%S"),
        "tier": model_tier,
        "model": model,
        "in": u.prompt_tokens,
        "out": u.completion_tokens,
        "cost": round(cost, 6),
    }
    with open(LOG, "a", encoding="utf-8") as f:
        f.write(json.dumps(rec, ensure_ascii=False) + "\n")
    return resp

def report():
    total = 0
    by_tier = {}
    for line in open(LOG, encoding="utf-8"):
        r = json.loads(line)
        total += r["cost"]
        by_tier[r["tier"]] = by_tier.get(r["tier"], 0) + r["cost"]
    print(f"累计花费：{total:.3f} 元")
    for k, v in sorted(by_tier.items(), key=lambda x: -x[1]):
        print(f"  {k}: {v:.3f} 元 ({v/total*100:.0f}%)")

这个脚本能帮你发现什么

发现一：哪个档位的模型最烧钱。 通常是旗舰模型——哪怕调用次数少，单价高。

发现二：哪类任务最烧钱。 记录里加一个 task 字段，就能按任务归类。

发现三：异常调用。 某个小时突然花了很多，多半是死循环或者脚本跑飞了。

一个真实发现

有人做了这个监控，一周后看报告：

累计花费：38.6 元
  旗舰模型：31.2 元 (81%)
  中端模型： 6.8 元 (18%)
  小模型：   0.6 元 (1%)

结论：80% 的钱花在 20% 的调用上。他一查，是"长文档总结"用的旗舰模型——于是改成"小模型先切段筛选 + 旗舰模型只处理关键段"，成本降到 9 元。

5.10 中转站测真假：五个实操问题

便宜中转站最大的坑不是跑路，是**"挂羊头卖狗肉"**——收你旗舰模型的钱，转发给便宜模型。

怎么测？用只有"真模型"才答得上的问题：

问题一：版本细节题

你目前是哪个版本？训练数据截止到什么时候？你的知识截止日期是什么？

注意：模型对自己的版本描述不一定准（它可能被训练成说"我是 AI 助手"）。所以这题只做参考。

问题二：能力特征题

不同模型有不同"指纹"。比如：

让它做一道需要多步推理的数学题
让它写一段特定风格的代码
让它解释一个冷门概念

对比官方渠道的答案，如果明显差一档，可能是降级了。

问题三：上下文长度测试

请记住这个数字：4872913。
现在请从 1 数到 50，然后告诉我刚才那个数字是多少。

降级/小模型的典型表现：数到一半就忘了，或者干脆编一个。

问题四：输出格式服从性

请严格输出 JSON：{"answer": "你的回答", "confidence": 0-1}
不要输出任何其他文字。

小模型常见问题：加了 markdown 代码块、加了说明文字、格式不对。

问题五：多轮一致性

连续问三层递进的问题，看它是不是"记得住、接得上"。

降级模型：第二层就开始跑偏。

判断标准

现象	可能原因
能力强但慢	可能是真模型+高峰限速
能力强且快但便宜	可疑，可能在亏本圈人
能力明显弱一档	大概率降级
经常报错/超时	上游号池不稳
输出格式总不对	小模型冒充

一句话：便宜可以信，但"便宜+强+稳"三样同时成立，不符合商业逻辑。

行业观察：一张被中转站坑掉的账单

某小团队做 AI 写作工具，图便宜用了一家 0.08 倍率的中转站，预充了 2000 元。

第一个月：正常，账单显示消耗 800 元额度。

第二个月中：开始频繁超时，客服说"上游维护"。

第三周：网站打不开，群解散，老板失联。

事后复盘：

实际成本：2000 元预充值 + 迁移成本（重写接口适配、重新测试）+ 用户流失
那家站的价格是官方的 8%，连电费都不够——它从第一天起就没打算长期做
他们后来查，这家站的上游是盗刷的卡，跑路是因为上游被封

行业规律：中转站的寿命中位数大约 6-12 个月。别把业务建在别人的沙子上。

踩坑实录

坑一：把 key 提交到 GitHub

场景：有人写了个小项目，把 key 硬编码在代码里，推到 GitHub 公开仓库。第二天收到账单：欠费 800 元。

为什么：GitHub 上有大量爬虫，专门扫 sk- 开头的字符串，扫到就卖/直接用。

怎么爬出来：key 永远用环境变量；已经推上去的，立刻作废 key，并用 git filter-branch 或 BFG 清理历史。

坑二：以为"包月"就是无限用

场景：有人买了个"包月不限量"的中转站套餐，用了三天被封号，理由是"滥用"。

为什么："不限量"通常有隐藏的公平使用条款，或者上游成本撑不住，发现你用得多就封。

怎么爬出来：看清条款；优先选"按量计费"，用多少付多少，最透明。

坑三：长对话聊到破产

场景：有人跟 AI 聊了一整晚，几十轮，第二天看账单，花了 40 块。

为什么：每一轮都把前面的全部历史重新计费，越聊越贵。

怎么爬出来：长对话定期总结；重要的开新对话；用支持"上下文缓存"的模型。

坑四：用旗舰模型干杂活

场景：有人用最贵的模型做"给 1000 条评论打情感标签"，花了 200 块。

为什么：分类任务用便宜小模型就够了，效果差不多，成本差 50 倍。

怎么爬出来：先想"这任务需要多聪明"，再选模型。

Lab 5-1｜算一笔你自己的账

难度：⭐⭐☆☆☆　预计耗时：30 分钟
目标：搞清楚你每月该花多少钱，以及钱花在了哪
步骤：
打开你用的 AI 服务后台，找到"用量统计"或"账单"
记录：过去 7 天，你用了多少 token、花了多少钱
按 5.2 节的公式，估算你一个月的成本
分析：哪类任务花得最多？（长文档？长对话？批量处理？）
制定优化方案：哪些任务可以换小模型？哪些对话可以缩短？
把优化方案写进笔记，下周执行
验收标准：
[ ] 有一份真实的用量数据
[ ] 能说出"我的钱主要花在哪"
[ ] 有至少两条可执行的省钱措施
卡住了怎么办：
找不到用量统计 → 大部分服务商后台都有"账单/用量"页面
没接过 API → 用网页版也能估算：按你每天输入的字符数 × 1.5 估算 token
算不明白 → 先记录一周的实际花费，比什么都准

本章自检清单

[ ] API key 泄露会有什么后果？三个防护习惯是什么？
[ ] 输入 token 和输出 token，哪个贵？为什么？
[ ] 为什么长对话越聊越贵？
[ ] 中转站有哪四种货源？哪种最危险？
[ ] 跑路盘的四个征兆是什么？
[ ] 自建中转的三个坑是什么？
[ ] 成本优化的六个方向是什么？
[ ] 什么任务该用便宜模型？什么任务必须用贵的？

学习进度：0 / 13 章

📝 本章小测验（3 题）

1. 输入 token 和输出 token，哪个更贵？

2. 下列哪项不是中转站便宜的常见原因？

3. 跑路盘的典型征兆是？

一句话记住

token 就是钱，上下文就是账单——省钱的本质是省上下文。

第 5 章 API 与成本：搞懂钱花在哪 ​

开场：一千块是怎么烧掉的 ​

5.1 API Key 是什么、怎么管 ​

先理解它是什么 ​

三个必须养成的习惯 ​

泄露了怎么办 ​

5.2 token 计费：输入输出怎么算钱 ​

计费的基本单位 ​

一个具体例子 ​

对话历史的隐性成本 ​

不同模型的价差 ​

怎么估算你的用量 ​

5.3 中转站商业模式：号池、倍率、跑路 ​

中转站怎么赚钱 ​

倍率：中转站的定价游戏 ​

跑路盘的四个征兆 ​

怎么降低风险 ​

5.4 自建中转：one-api / new-api 部署 ​

为什么要自建 ​

主流方案 ​

部署步骤（Docker 版，最简单） ​

部署的三个坑 ​

自建适合谁 ​

5.5 成本优化：缓存、批处理、小模型分流 ​

优化一：小模型分流 ​

优化二：缓存 ​

优化三：批处理 ​

优化四：控制上下文 ​

优化五：输出控制 ​

优化六：用开源模型 ​

5.6 跑路盘识别清单 ​

5.7 实战：算清一次批量任务的账 ​

场景 ​

算账 ​

什么时候必须用贵的 ​

一个省钱的三段式方案 ​

5.8 一个月的真实账单复盘 ​

账单长什么样 ​

三个"隐形账单" ​

怎么把账单砍一半 ​

5.9 自己做一个 token 用量监控 ​

为什么要自己算 ​

最小实现（Python，包一层 API 调用） ​

这个脚本能帮你发现什么 ​

一个真实发现 ​

5.10 中转站测真假：五个实操问题 ​

问题一：版本细节题 ​

问题二：能力特征题 ​

问题三：上下文长度测试 ​

问题四：输出格式服从性 ​

问题五：多轮一致性 ​

判断标准 ​

行业观察：一张被中转站坑掉的账单 ​

踩坑实录 ​

坑一：把 key 提交到 GitHub ​

坑二：以为"包月"就是无限用 ​

坑三：长对话聊到破产 ​

坑四：用旗舰模型干杂活 ​

Lab 5-1｜算一笔你自己的账 ​

本章自检清单 ​

一句话记住 ​

延伸阅读 ​