Claude API定价和成本控制指南 新手选模型最划算方案

一、计费基础：Token 是什么，怎么数

Claude API 不按次收费，按 token 收费。Token 是模型处理文本的基本单位，大概理解为：

计费分两部分，输入和输出分开算，输出的价格通常是输入的 5 倍：

• 输入 token：你发给 Claude 的所有内容——System Prompt + 对话历史 + 当前消息 + 工具定义
• 输出 token：Claude 生成的回复内容

二、三档模型价格对比（2026年3月）

M = 百万。单位：美元。以上为官方标准价格，2026年3月。

价格差距直观感受：处理同样的任务，Opus 的输出费用是 Haiku 的 5 倍。如果你每天调用 10000 次、每次平均输出 500 token：

• 全用 Haiku：约 $25 / 月
• 全用 Sonnet：约 $75 / 月
• 全用 Opus：约 $125 / 月

选对模型，月费差距可以达到 5 倍。

三、省钱技巧一：选对模型（最大杠杆）

最有效的省钱方法不是压缩 Prompt，而是为不同任务选合适的模型。以下是决策框架：

混合路由策略：用 Haiku 分流，节省 40-60% 成本

import anthropic

client = anthropic.Anthropic()

def smart_route(user_message: str) -> str:
    """
    先用 Haiku 判断任务复杂度，再选对应模型
    简单任务用 Haiku 直接回答，复杂任务转 Sonnet
    """

    # 第一步：用 Haiku 判断复杂度（成本极低，约0.001分/次）
    complexity_check = client.messages.create(
        model      = "claude-haiku-4-5-20251001",
        max_tokens = 8,
        messages   = [{
            "role":    "user",
            "content": f"判断以下问题的复杂度：simple 或 complex。只输出一个词。\n\n问题：{user_message}"
        }]
    )

    complexity = complexity_check.content[0].text.strip().lower()

    # 第二步：根据复杂度选模型
    if "simple" in complexity:
        model = "claude-haiku-4-5-20251001"
    else:
        model = "claude-sonnet-4-6"

    # 第三步：用选定的模型回答
    response = client.messages.create(
        model      = model,
        max_tokens = 1024,
        messages   = [{"role": "user", "content": user_message}]
    )

    print(f"[使用模型：{model}]")
    return response.content[0].text


# 测试
print(smart_route("2+2等于几"))           # 用 Haiku
print(smart_route("帮我设计一个分布式缓存架构"))  # 用 Sonnet

四、省钱技巧二：Batch API 打五折

Anthropic 提供 Batch API，异步批量处理请求，价格是标准 API 的 50%。适合不需要实时响应的任务——批量分类、离线内容生成、数据处理流水线。

import anthropic
import time

client = anthropic.Anthropic()

# 准备批量任务
texts_to_classify = [
    "这款手机拍照真的太棒了！",
    "质量很差，根本不值这个价",
    "还行，凑合能用",
    "包装很精美，快递也快",
    "假货，和描述完全不符",
]

# 构建批量请求
requests = [
    anthropic.types.MessageCreateParamsNonStreaming(
        model      = "claude-haiku-4-5-20251001",
        max_tokens = 16,
        messages   = [{
            "role":    "user",
            "content": f"判断情感（只输出：正面/负面/中性）：{text}"
        }]
    )
    for text in texts_to_classify
]

# 提交批量任务
batch = client.messages.batches.create(requests=requests)
print(f"批量任务已提交：{batch.id}")
print(f"预计节省：50% 费用（相比实时 API）")

# 等待完成（实际项目可以存 batch.id，之后再查）
while True:
    status = client.messages.batches.retrieve(batch.id)
    print(f"状态：{status.processing_status}")
    if status.processing_status == "ended":
        break
    time.sleep(10)

# 获取结果
for result in client.messages.batches.results(batch.id):
    if result.result.type == "succeeded":
        idx    = int(result.custom_id.split("_")[-1]) if "_" in result.custom_id else 0
        output = result.result.message.content[0].text
        print(f"文本：{texts_to_classify[idx][:20]}... → {output}")

五、省钱技巧三：Prompt Caching 最高省 90%

如果你每次请求都带着同一段很长的内容（比如一份10万字的文档、或者固定的 System Prompt），可以启用 Prompt Caching。被缓存的内容首次读取计费，后续读取只收 10% 的价格。

import anthropic

client = anthropic.Anthropic()

# 一份很长的文档（实际使用中可能有几十万 token）
LONG_DOCUMENT = """
[你的长文档内容，比如一份产品手册、法律文件等]
""" * 100   # 模拟长内容

# 启用缓存：在需要缓存的内容后面加 cache_control
response = client.messages.create(
    model      = "claude-sonnet-4-6",
    max_tokens = 1024,
    system     = [
        {
            "type": "text",
            "text": f"你是文档分析助手。以下是参考文档：\n\n{LONG_DOCUMENT}",
            "cache_control": {"type": "ephemeral"},   # 标记为可缓存
        }
    ],
    messages   = [{"role": "user", "content": "文档的主要内容是什么？"}],
)

# 查看缓存命中情况
usage = response.usage
print(f"输入 token：{usage.input_tokens}")
print(f"缓存写入：{getattr(usage, 'cache_creation_input_tokens', 0)}")
print(f"缓存命中：{getattr(usage, 'cache_read_input_tokens', 0)}")

# 第一次：cache_creation_input_tokens > 0（写入缓存，收1.25倍费用）
# 后续次：cache_read_input_tokens > 0（读缓存，只收0.1倍费用）

# 对同一文档继续提问，后续请求就会命中缓存
response2 = client.messages.create(
    model      = "claude-sonnet-4-6",
    max_tokens = 1024,
    system     = [
        {
            "type": "text",
            "text": f"你是文档分析助手。以下是参考文档：\n\n{LONG_DOCUMENT}",
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages   = [{"role": "user", "content": "文档提到了哪些风险？"}],
)
print(f"\n第二次请求缓存命中：{getattr(response2.usage, 'cache_read_input_tokens', 0)} tokens")

六、省钱技巧四：精简 System Prompt 和对话历史

"""
多轮对话的成本陷阱：

第1轮：输入=50 tokens，输出=100 tokens     → 总计 150 tokens
第2轮：输入=50+100+50=200 tokens，输出=100  → 总计 300 tokens
第3轮：输入=200+100+50=350 tokens，输出=100 → 总计 450 tokens
第4轮：输入=350+100+50=500 tokens，输出=100 → 总计 600 tokens

10轮对话后，光输入就有几千 token

解决方案：滑动窗口——只保留最近 N 轮
"""

def trim_history(
    history:    list[dict],
    max_turns:  int = 10,       # 保留最近10轮
    max_tokens: int = 4000,     # 或者按 token 数限制
) -> list[dict]:
    """
    裁剪对话历史，控制输入 token 数量
    保留最新的 max_turns 轮（每轮 = 1 user + 1 assistant）
    """
    # 方法一：按轮数截断（简单，推荐）
    max_messages = max_turns * 2   # 每轮2条消息
    if len(history) > max_messages:
        return history[-max_messages:]
    return history


def estimate_tokens_rough(text: str) -> int:
    """粗略估算 token 数（不需要调 API，用于决策）"""
    # 中英文混合时的经验公式
    chinese_chars = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
    other_chars   = len(text) - chinese_chars
    return int(chinese_chars * 1.5 + other_chars / 4)


# 精简 System Prompt 的原则
VERBOSE_SYSTEM = """
你是一个非常专业的、经验丰富的客服助手，你的职责是帮助用户解决各种各样的问题，
你需要保持礼貌、专业、友善的态度，始终以用户满意为目标，在回答问题时要详细、
全面、准确，不要给出错误的信息，如果不确定就说不知道……（500字）
"""

CONCISE_SYSTEM = """你是专业客服助手。礼貌、准确，不确定时直说。"""
# 从 500 字压缩到 20 字，每次请求节省约 100 tokens
# 每天1万次调用 × 100 tokens × Sonnet价格 = 每天约 $0.045，每月约 $1.35

七、省钱技巧五：max_tokens 按任务设，不要一刀切

"""
max_tokens 不影响实际计费——Claude 自然结束时不会因为 max_tokens 大就多收钱。
但 max_tokens 设太大会影响 Claude 的输出倾向：
设大了 → Claude 倾向于生成更长的回复 → 更多输出 token → 更贵

按任务类型设置合理的 max_tokens：
"""

TASK_MAX_TOKENS = {
    "classify":   16,    # 分类：只需要一个词
    "extract":    256,   # 提取：结构化信息
    "chat":       512,   # 对话：一段话
    "summarize":  1024,  # 摘要：几段话
    "write":      4096,  # 写作：长内容
    "code":       4096,  # 代码：完整函数
}

import anthropic

client = anthropic.Anthropic()

def smart_complete(message: str, task_type: str) -> str:
    max_tokens = TASK_MAX_TOKENS.get(task_type, 1024)
    response   = client.messages.create(
        model      = "claude-haiku-4-5-20251001",
        max_tokens = max_tokens,
        messages   = [{"role": "user", "content": message}]
    )
    return response.content[0].text


# 分类任务用 max_tokens=16，避免 Claude 多说废话
result = smart_complete("这条评论是好评还是差评：'东西不错'", "classify")
print(result)  # 输出：好评

八、成本估算计算器

def estimate_monthly_cost(
    daily_requests:    int,
    avg_input_tokens:  int,
    avg_output_tokens: int,
    model:             str = "all",
) -> dict:
    """
    估算月度 API 费用

    Args:
        daily_requests:    每日请求数
        avg_input_tokens:  平均输入 token 数（含 system prompt 和历史）
        avg_output_tokens: 平均输出 token 数
        model:             指定模型或 "all" 显示所有模型对比
    """
    # 2026年3月官方价格（美元/百万token）
    prices = {
        "haiku":  {"input": 1.0,  "output": 5.0},
        "sonnet": {"input": 3.0,  "output": 15.0},
        "opus":   {"input": 5.0,  "output": 25.0},
    }

    monthly_requests = daily_requests * 30
    results = {}

    for model_name, price in prices.items():
        input_cost  = monthly_requests * avg_input_tokens  / 1_000_000 * price["input"]
        output_cost = monthly_requests * avg_output_tokens / 1_000_000 * price["output"]
        total       = input_cost + output_cost

        results[model_name] = {
            "monthly_requests": monthly_requests,
            "input_cost_usd":   round(input_cost, 2),
            "output_cost_usd":  round(output_cost, 2),
            "total_usd":        round(total, 2),
            "total_cny":        round(total * 7.24, 1),   # 参考汇率
        }

    return results


def print_cost_report(daily_requests, avg_input, avg_output):
    print(f"\n{'='*55}")
    print(f"月度成本估算")
    print(f"日请求量：{daily_requests:,}  输入：{avg_input} tokens  输出：{avg_output} tokens")
    print(f"{'='*55}")
    print(f"{'模型':<10} {'输入费用':>10} {'输出费用':>10} {'月总费用':>12} {'人民币':>10}")
    print("-" * 55)

    results = estimate_monthly_cost(daily_requests, avg_input, avg_output)
    for name, data in results.items():
        print(
            f"{name:<10} "
            f"${data['input_cost_usd']:>9.2f} "
            f"${data['output_cost_usd']:>9.2f} "
            f"${data['total_usd']:>11.2f} "
            f"¥{data['total_cny']:>9.1f}"
        )

    haiku_cost  = results["haiku"]["total_usd"]
    opus_cost   = results["opus"]["total_usd"]
    print(f"\n选 Haiku vs Opus：每月节省 ${opus_cost - haiku_cost:.2f}")
    print(f"{'='*55}")


# 示例：客服机器人，每天1万次对话
print_cost_report(
    daily_requests   = 10_000,
    avg_input        = 500,     # system prompt + 历史 + 用户消息
    avg_output       = 200,     # 客服回复
)

# 示例：批量文本分类，每天100万条
print_cost_report(
    daily_requests   = 1_000_000,
    avg_input        = 100,     # 简短文本 + 分类指令
    avg_output       = 10,      # 只输出类别
)

九、省钱总结：按优先级排序

常见问题

Q：充值的钱会过期吗？
Anthropic 的预付额度（Credits）目前没有明确的有效期，充了之后按使用量消耗。但具体政策以官方最新说明为准，建议不要一次充太多，够用3-6个月就好。

Q：怎么设置消费上限，防止代码 Bug 导致超额消费？
在 console.anthropic.com → Billing → Usage limits 里可以设置月度消费上限，超过后 API 调用会返回错误而不是继续扣费。建议在项目上线前就设好上限，防止意外的循环调用或并发失控。

Q：同样是 Sonnet，为什么有时候一次请求花了很多 token？
多轮对话时检查输入 token 数——每次请求的"输入"包含了完整的历史消息。10轮对话后，光历史消息就可能有几千 token。用本文的滑动窗口方法控制历史长度，是最有效的解决方式。

总结

Claude API 的成本控制核心是三件事：选对模型（不是所有任务都需要 Opus）、用好两个官方折扣机制（Batch API 五折、Prompt Caching 九折）、控制输入长度（对话历史要裁剪、System Prompt 要精简）。用本文的成本估算代码，输入你的实际业务规模，就能算出在三个模型下的月费差距——这个数字通常比直觉中大得多，值得认真对待。