## 费用优化指南

使用 Claude Code 写代码很爽，但如果不注意用法，账单也可能让你「惊喜」。这篇指南帮你理解费用是怎么产生的，以及如何在不牺牲效率的前提下合理控制成本。

## 理解 Token 计费

在优化费用之前，你需要先理解费用的底层逻辑——Token。

### 什么是 Token

Token 是 AI 模型处理文本的最小单位。你可以把它理解为模型的「字」：

- **英文**：1 个 token 约等于 4 个字符，或 0.75 个单词
- **中文**：1 个汉字约等于 1-2 个 token（平均约 1.5 个 token）
- **代码**：变量名、关键字、符号各占不同数量的 token

简单估算参考：

| 内容 | 大约字数/行数 | 大约 Token 数 |
|------|-------------|-------------|
| 一段简短的中文需求描述 | 100 字 | ~150 tokens |
| 一个 200 行的 TypeScript 文件 | ~5000 字符 | ~1500 tokens |
| 一次包含上下文的典型对话输入 | — | 5,000-20,000 tokens |
| Claude Code 的系统提示词 | — | ~8,000 tokens |

### 输入 vs 输出 Token

每次与 Claude 交互，费用由两部分组成：

```
总费用 = 输入 tokens × 输入单价 + 输出 tokens × 输出单价
```

关键点：**输出 token 的价格通常是输入 token 的 5 倍**。以 Sonnet 5 为例：

| 类型 | 价格（美元/百万 tokens） | 1000 tokens 费用 |
|------|----------------------|-----------------|
| 输入 | $2.00 | $0.002 |
| 输出 | $10.00 | $0.010 |
| 缓存读取 | $0.20 | $0.0002 |

这意味着：让 Claude 生成长篇大论比你提供大量上下文更贵。

### 一次典型对话消耗多少 Token

以 Sonnet 5 为例，几种常见场景的费用估算：

| 场景 | 输入 tokens | 输出 tokens | 估计费用 |
|------|-----------|-----------|---------|
| 简单问答（解释一段代码） | 3,000 | 500 | $0.011 |
| 修改一个函数 | 8,000 | 1,500 | $0.031 |
| 创建一个新组件（含文件读取） | 15,000 | 3,000 | $0.060 |
| 复杂功能开发（多轮对话） | 50,000 | 15,000 | $0.250 |
| 大型重构（10+ 文件） | 200,000 | 50,000 | $0.900 |

> 以上数字仅作参考，实际费用取决于你的代码量、对话轮次和上下文大小。

## 模型选择策略

选对模型是最直接的省钱方式。不同模型之间的价格差异非常大。

### 三种模型的定位

| 模型 | 输入价格 | 输出价格 | 定位 |
|------|---------|---------|------|
| Haiku 4.5 | $1.00 | $5.00 | 轻量快速，日常简单任务 |
| Sonnet 5 | $2.00 | $10.00 | 最佳平衡，主力模型 |
| Opus 5 | $5.00 | $25.00 | 当前旗舰，与 4.7 同价 |
| Opus 4.7 | $5.00 | $25.00 | 上一代旗舰，仍可用 |

**费用对比**：完成同一个中等复杂任务（输入 10K、输出 3K tokens）：

- Haiku：$0.025
- Sonnet：$0.050
- Opus：$0.125

Sonnet 5 是 Haiku 的 2 倍，Opus 5 是 Haiku 的 5 倍。

### 模型选择原则

```
日常首选 Sonnet（80% 的任务用它就够了）

仅在以下场景切换 Opus：
  - 复杂架构设计和技术决策
  - 大规模代码重构
  - 涉及多个系统的跨模块修改
  - 需要深度推理的疑难 bug

仅在以下场景切换 Haiku：
  - 简单的格式转换
  - 生成重复性代码（如 CRUD 接口）
  - 快速问答（一句话能回答的问题）
  - 代码注释和文档生成
```

用 `/model` 命令随时切换：

```
/model sonnet    # 切换到 Sonnet
/model opus      # 切换到 Opus
/model haiku     # 切换到 Haiku
```

## 上下文管理省钱技巧

上下文管理是费用优化的核心。每一轮对话，Claude 都会重新发送之前的所有对话历史，这意味着对话越长，每一轮的输入 token 就越多。

### /compact 压缩历史

当对话进行了 10 轮以上，或者你感觉响应变慢了，使用 `/compact` 压缩：

```
/compact
```

`/compact` 会让 Claude 将之前的对话总结成一段精简的摘要，替代完整的历史记录。这样下一轮对话的输入 token 会大幅减少。

**使用时机：**
- 对话超过 10 轮
- 完成了一个子任务，准备开始下一个
- 感觉 Claude 的回复质量在下降（上下文过载的信号）

### /clear 彻底清空

换一个完全不同的话题时，果断用 `/clear`：

```
/clear
```

**使用时机：**
- 从功能 A 的开发切换到功能 B
- 调试完毕，开始写新代码
- 对话已经偏离了方向，想重新开始

> **不用 /clear 的代价**：假设之前的对话历史有 50K tokens，换个话题后每一轮对话你都在白白为这 50K tokens 买单。以 Sonnet 计算，每轮额外花费 $0.15。对话 10 轮就浪费了 $1.5。

### 精准 @ 引用

让 Claude 自己搜索文件 vs 你直接引用文件，cost 差异很大：

```bash
# 贵！Claude 可能会搜索数十个文件来找到相关代码
"帮我修改用户注册逻辑中的邮箱验证部分"

# 便宜！直接告诉 Claude 在哪里
"修改 @src/services/auth-service.ts 中 validateEmail 方法的正则表达式"
```

当你知道要改哪个文件时，永远用 `@` 直接引用。让 Claude 自己搜索不仅更贵，结果也不一定准确。

### .claudeignore 排除大文件

确保以下类型的文件在 `.claudeignore` 中：

```bash
# 这些文件如果被 Claude 读取，会消耗大量 token
node_modules/          # 动辄上万个文件
dist/                  # 构建产物
*.min.js               # 压缩后的 JS
*.sql                  # 数据库 dump
*.csv                  # 数据文件
package-lock.json      # 锁文件（内容巨大）
pnpm-lock.yaml         # 锁文件
yarn.lock              # 锁文件
```

> **真实案例**：一位用户发现费用异常高，排查后发现 Claude 在搜索代码时读取了一个 50MB 的 SQL dump 文件，一次就消耗了约 15M tokens（约 $45 输入费用）。

## 缓存机制利用

Prompt Caching 是 Claude API 的一个非常重要的省钱特性。

### 什么是 Prompt Caching

当你连续多轮对话时，每一轮都会重新发送之前的所有内容。如果没有缓存，每次都按完整输入价格计费。有了缓存后：

- **首次发送**：按正常输入价格（缓存写入价格略高）
- **后续发送**：相同内容命中缓存，按缓存读取价格（只有 1/10）

以 Sonnet 5 为例：

| 类型 | 价格/百万 tokens | 相比正常输入 |
|------|----------------|------------|
| 正常输入 | $2.00 | 100% |
| 缓存写入 | $2.50 | 125% |
| 缓存读取 | $0.20 | 10% |

也就是说，**缓存命中时只需 1/10 的价格**。

### 如何利用好缓存

缓存是自动生效的，但你可以通过使用习惯来提高缓存命中率：

**保持对话连贯**：

```bash
# 好习惯：在同一个对话中持续开发同一个功能
> "创建 UserService 基础结构"
> "添加 getUserById 方法"        # 前面的内容命中缓存
> "添加 updateUser 方法"         # 前面的内容命中缓存
> "添加单元测试"                 # 前面的内容命中缓存

# 坏习惯：每说一句话就 /clear
> "创建 UserService 基础结构"
> /clear
> "给 UserService 添加 getUserById 方法"    # 无法利用缓存
> /clear
> "给 UserService 添加 updateUser 方法"     # 无法利用缓存
```

**不要频繁修改 CLAUDE.md**：

CLAUDE.md 的内容在每轮对话中都会发送。如果内容稳定，它会长期命中缓存。频繁修改会导致缓存失效。

**合理的 /compact 时机**：

`/compact` 会替换历史记录，导致缓存失效。所以不要太频繁地使用它——当对话真的太长时才用。

### 缓存效果有多大

假设一次 10 轮对话，每轮输入约 20K tokens（包含历史）：

| | 无缓存 | 有缓存（90% 命中率） |
|---|---|---|
| 总输入 tokens | 200K | 200K |
| 按正常价格计费 | 200K | 20K |
| 按缓存价格计费 | 0 | 180K |
| 总输入费用（Sonnet） | $0.60 | $0.114 |
| **节省** | — | **$0.486（81%）** |

缓存可以帮你节省约 80% 的输入费用。

## 监控与预算

养成监控费用的习惯，避免不知不觉花超。

### /cost 查看当前会话

随时在 Claude Code 中输入：

```
/cost
```

会显示当前会话已消耗的 token 数量和估算费用。建议每完成一个任务后看一眼。

### QCode.cc Dashboard 查看历史

登录 [QCode.cc 控制台](https://qcode.cc/dashboard)，在「使用统计」页面可以看到：

- **模型调用明细**：每次调用的模型、token 数量、费用
- **按天/按月汇总**：费用趋势图
- **套餐消耗进度**：当前套餐额度使用百分比

建议养成每天看一眼 Dashboard 的习惯，及时发现异常消耗。

### 费用控制建议

| 使用量级 | 建议模型策略 | 月预算参考 |
|---------|-----------|----------|
| 轻度使用（每天 1-2 小时） | 以 Sonnet 为主 | $30-80 |
| 中度使用（每天 3-5 小时） | Sonnet + 偶尔 Opus | $80-200 |
| 重度使用（全天开发） | Sonnet 主力 + Opus 架构决策 | $200-500 |

## 常见费用陷阱

以下是最容易浪费 token 的几种情况，对照检查一下你有没有中招：

### 陷阱 1：大文件直接粘贴

```bash
# 错误做法：把文件内容粘贴到对话中
> "下面是我的代码，帮我检查一下：
[粘贴了 500 行代码]"

# 正确做法：用 @ 引用
> "检查 @src/services/order-service.ts 中的 createOrder 方法"
```

区别：粘贴 500 行代码约 1500 tokens 输入，而且每一轮对话都会重复发送这些内容。用 `@` 引用同样的文件，Claude 只在需要时读取，而且读取的内容会被缓存。

### 陷阱 2：不断重试相同的失败命令

```bash
# 错误做法：反复让 Claude 执行同一个失败的命令
> "运行 npm run build"
# 失败了
> "再试一次"
# 还是失败
> "再来一次"

# 正确做法：分析失败原因，换个方式
> "运行 npm run build"
# 失败了
> "看看错误日志，分析失败原因，修复问题后再构建"
```

每次重试都会发送完整的对话历史（包括之前所有失败的输出），token 消耗会快速累积。

### 陷阱 3：忘记 /clear 导致上下文膨胀

这是最隐蔽的费用陷阱：

```bash
# 上午：修了一个 bug（对话积累了 30K tokens 的历史）
# 下午：开始写新功能，但没有 /clear
# 每一轮新对话都白白携带了上午的 30K tokens 历史

# 修复：养成换任务时 /clear 的习惯
/clear
> "现在开始开发新功能..."
```

### 陷阱 4：用 Opus 做简单任务

```bash
# 浪费：用 Opus 生成一个简单的 interface
/model opus
> "帮我定义一个 User 接口，包含 id、name、email 字段"

# 节省：简单任务用 Haiku 就够了
/model haiku
> "帮我定义一个 User 接口，包含 id、name、email 字段"
```

这个任务两个模型输出几乎一样，但 Opus 的费用是 Haiku 的 5 倍。

### 陷阱 5：让 Claude 搜索整个项目

```bash
# 贵：Claude 可能读取几十个文件
> "找到项目中处理支付的代码"

# 便宜：告诉它大概位置
> "在 @src/services/ 目录下找到处理支付的服务"

# 最便宜：直接指定文件
> "查看 @src/services/payment-service.ts"
```

## 费用优化检查清单

每次使用 Claude Code 时，对照这个清单：

- [ ] 是否选择了合适的模型（大部分任务用 Sonnet）
- [ ] 是否使用 `@` 引用而非粘贴文件内容
- [ ] 换话题时是否执行了 `/clear`
- [ ] 对话超过 10 轮是否考虑 `/compact`
- [ ] 是否配置了 `.claudeignore` 排除大文件
- [ ] 需求描述是否足够清晰（避免因理解偏差导致返工）
- [ ] 是否检查了 `/cost` 了解当前消耗

养成这些习惯后，你会发现费用可以降低 30-50%，同时开发效率丝毫不受影响。

## Prompt 缓存与成本

前面提到缓存命中只需 1/10 的输入价格，这里进一步讲清楚「为什么」以及如何主动设计你的上下文来最大化缓存收益。

### 稳定前缀才能被缓存

Claude API 的 Prompt Caching 缓存的是**提示词的稳定前缀**——系统提示词、CLAUDE.md、长篇背景资料等不变的开头部分。命中缓存后，这部分的读取价格约为正常输入的 10%（便宜约 90%）。关键在于：缓存以「前缀」为单位，一旦前缀中靠前的内容发生改动，从改动点往后的缓存全部失效。

因此省钱的核心原则是：**把不变的内容放在最前面，且尽量不去编辑它**。

| 内容类型 | 放置位置 | 缓存友好度 |
|---------|---------|-----------|
| 系统提示词、CLAUDE.md | 最前（稳定） | 高，长期命中 |
| 项目规范、API 文档等长背景 | 靠前（稳定） | 高 |
| 当前任务的具体指令 | 靠后 | 低（本就常变） |
| 实时对话历史 | 末尾 | 随对话增长 |

### 让上下文对缓存友好的做法

- **精简且稳定的 CLAUDE.md**：内容高信号、少改动。频繁修改 CLAUDE.md 会让它后面的整段缓存失效，每次都按全价重算。
- **复用会话**：在同一个会话里持续推进同一任务，前缀始终一致，后续每轮都吃到缓存读取价。
- **用路径引用代替粘贴**：用 `@路径` 引用文件而非把内容粘进对话，既减少 token，又避免把易变内容塞进前缀破坏缓存。
- **谨慎使用 /compact**：`/compact` 会重写历史摘要，相当于改写了前缀，会让既有缓存失效——只在对话确实过长时才用。

> 一句话总结：稳定内容靠前、易变内容靠后、不轻易改动前缀，是用最小代价吃满缓存折扣的关键。关于上下文层级与精简技巧，可参阅[模型选择指南](/docs/usage/model-selection)中的配套建议。

## 按角色选择模型

「日常用 Sonnet」是一个好起点，但更省钱的做法是**按任务角色选择模型**，让每一类工作都跑在性价比最高的模型上，而不是全程用同一个模型。

### 按角色分工

| 任务角色 | 推荐模型 | 典型场景 |
|---------|---------|---------|
| 查询 / 格式化 / 简单改写 | Haiku 4.5 | 查文档、格式转换、改注释、一句话能答的问题 |
| 日常实现 / 修 bug | Sonnet 5 | 写功能、改逻辑、常规调试（约 80% 的工作）。4.6 仍在售 |
| 架构 / 大型重构 / 编排 | Opus 5 | 跨模块设计、大规模重构、多步骤任务编排、疑难推理。4.8 仍在售 |
| Codex 风格编码 | gpt-5.6-terra | 偏 Codex 工作流的代码生成 |

核心思路是**不要用 Opus 跑琐碎任务**：一个简单的接口定义，Haiku 和 Opus 输出几乎相同，但 Opus 贵 5 倍。把重型模型留给真正需要深度推理的环节。

### 在会话中途切换

用 `/model` 可以随时切换，无需重开会话：

```
/model haiku     # 切到轻量模型处理简单步骤
/model sonnet    # 切回主力模型继续实现
/model opus      # 遇到架构决策时临时升级
```

一个高效的省钱节奏是：用 Sonnet 推进主体开发，遇到架构难点临时 `/model opus` 思考，决策完成后切回 Sonnet；把批量的简单收尾交给 Haiku。更详细的逐模型能力对比与选型建议，见[模型选择指南](/docs/usage/model-selection)。