AI API Token 用量统计与成本控制实践

在调用大模型 API 时，你是否曾被月末账单"惊喜"到？Token 用量统计与成本控制，是每个 AI 应用开发者必须掌握的技能。本文将带你从零实现用量监控，并给出实用的成本优化方案。

HolySheep vs 官方 API vs 其他中转站核心对比

从对比可以看出，立即注册 HolySheep API 不仅汇率优惠，还支持国内主流支付方式，对于国内开发者来说是最优选择。

Token 计费基础概念

在开始统计之前，我们需要理解 Token 的计费模式：

• Input Token：发送给模型的提示词（Prompt）按字符/Token 计费
• Output Token：模型生成的回复按 Token 计费，通常 Output 单价是 Input 的 2-10 倍
• 2026主流模型 Output 价格参考：
  • GPT-4.1: $8/MTok
  • Claude Sonnet 4.5: $15/MTok
  • Gemini 2.5 Flash: $2.50/MTok
  • DeepSeek V3.2: $0.42/MTok

Python 实现 Token 用量统计

下面我们基于 HolySheep API 实现完整的用量监控方案：

import requests
import time
from datetime import datetime
from collections import defaultdict

class TokenUsageTracker:
    """AI API Token 用量追踪器"""
    
    def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        # 按模型分组的用量统计
        self.usage_stats = defaultdict(lambda: {"input_tokens": 0, "output_tokens": 0, "requests": 0, "cost": 0.0})
        # 2026年各模型 Output 单价（$/MTok）- 基于 HolySheep 报价
        self.model_prices = {
            "gpt-4.1": {"input": 2.0, "output": 8.0},
            "claude-sonnet-4.5": {"input": 3.0, "output": 15.0},
            "gemini-2.5-flash": {"input": 0.30, "output": 2.50},
            "deepseek-v3.2": {"input": 0.10, "output": 0.42}
        }
    
    def call_model(self, model: str, prompt: str, **kwargs) -> dict:
        """调用模型并记录用量"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            **kwargs
        }
        
        start_time = time.time()
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=60
        )
        elapsed_ms = (time.time() - start_time) * 1000
        
        if response.status_code != 200:
            raise Exception(f"API 调用失败: {response.status_code} - {response.text}")
        
        result = response.json()
        
        # 提取 Token 用量（如果 API 返回了 usage 字段）
        if "usage" in result:
            usage = result["usage"]
            input_tokens = usage.get("prompt_tokens", 0)
            output_tokens = usage.get("completion_tokens", 0)
        else:
            # 估算 Token 数量（简单估算：中文≈2字符/Token，英文≈4字符/Token）
            input_tokens = len(prompt) // 2
            output_tokens = len(result["choices"][0]["message"]["content"]) // 2
        
        # 计算成本（基于 HolySheep 汇率：¥1=$1）
        prices = self.model_prices.get(model, {"input": 1.0, "output": 5.0})
        input_cost = (input_tokens / 1_000_000) * prices["input"]  # 转换为美元
        output_cost = (output_tokens / 1_000_000) * prices["output"]
        total_cost_usd = input_cost + output_cost
        
        # 更新统计
        self.usage_stats[model]["input_tokens"] += input_tokens
        self.usage_stats[model]["output_tokens"] += output_tokens
        self.usage_stats[model]["requests"] += 1
        self.usage_stats[model]["cost"] += total_cost_usd
        
        return {
            "response": result,
            "tokens": {"input": input_tokens, "output": output_tokens},
            "cost_usd": total_cost_usd,
            "latency_ms": round(elapsed_ms, 2)
        }
    
    def get_summary(self, exchange_rate: float = 7.0) -> dict:
        """获取用量汇总（支持自定义汇率）"""
        summary = {
            "total_requests": 0,
            "total_input_tokens": 0,
            "total_output_tokens": 0,
            "total_cost_usd": 0.0,
            "total_cost_cny": 0.0,
            "by_model": {}
        }
        
        for model, stats in self.usage_stats.items():
            model_cost_usd = stats["cost"]
            model_cost_cny = model_cost_usd * exchange_rate
            summary["by_model"][model] = {
                **stats,
                "cost_cny": round(model_cost_cny, 4)
            }
            summary["total_requests"] += stats["requests"]
            summary["total_input_tokens"] += stats["input_tokens"]
            summary["total_output_tokens"] += stats["output_tokens"]
            summary["total_cost_usd"] += model_cost_usd
        
        summary["total_cost_cny"] = round(summary["total_cost_usd"] * exchange_rate, 2)
        return summary

使用示例
if __name__ == "__main__":
    tracker = TokenUsageTracker(
        api_key="YOUR_HOLYSHEEP_API_KEY"  # 替换为你的 HolySheep API Key
    )
    
    # 模拟调用
    test_prompts = [
        ("gpt-4.1", "解释什么是机器学习"),
        ("deepseek-v3.2", "写一个快速排序算法"),
        ("gemini-2.5-flash", "翻译：Hello World")
    ]
    
    for model, prompt in test_prompts:
        result = tracker.call_model(model, prompt)
        print(f"[{model}] 消耗 Token: {result['tokens']}, 成本: ${result['cost_usd']:.4f}")
    
    # 打印汇总
    summary = tracker.get_summary()
    print("\n=== 用量汇总 ===")
    print(f"总请求数: {summary['total_requests']}")
    print(f"总 Input Token: {summary['total_input_tokens']}")
    print(f"总 Output Token: {summary['total_output_tokens']}")
    print(f"总成本: ¥{summary['total_cost_cny']} (基于 ¥7=$1 汇率)")
    print(f"如使用 HolySheep 汇率(¥1=$1): ¥{summary['total_cost_usd']:.2f}")

成本控制进阶策略

import tiktoken
from typing import List, Dict, Optional

class CostOptimizer:
    """AI API 成本优化器"""
    
    def __init__(self):
        # 各模型的上下文窗口大小（Token）
        self.context_limits = {
            "gpt-4.1": 128000,
            "claude-sonnet-4.5": 200000,
            "gemini-2.5-flash": 1000000,
            "deepseek-v3.2": 64000
        }
    
    def count_tokens(self, text: str, model: str = "gpt-4.1") -> int:
        """计算 Token 数量"""
        try:
            encoding = tiktoken.encoding_for_model(model)
            return len(encoding.encode(text))
        except:
            # 回退到简单估算
            return len(text) // 2
    
    def truncate_to_limit(self, text: str, model: str, 
                          max_tokens: Optional[int] = None,
                          preserve_prefix: bool = True) -> str:
        """截断文本以符合模型上下文限制"""
        limit = max_tokens or self.context_limits.get(model, 32000)
        # 保留 90% 用于输入，留 10% 给输出
        safe_limit = int(limit * 0.9)
        
        current_tokens = self.count_tokens(text, model)
        if current_tokens <= safe_limit:
            return text
        
        # 编码后截断
        try:
            encoding = tiktoken.encoding_for_model(model)
            tokens = encoding.encode(text)
            truncated_tokens = tokens[:safe_limit]
            return encoding.decode(truncated_tokens)
        except:
            # 回退方案：按字符比例截断
            chars_to_keep = int(len(text) * (safe_limit / current_tokens))
            if preserve_prefix:
                return text[:chars_to_keep]
            else:
                return text[-chars_to_keep:]
    
    def select_optimal_model(self, task_complexity: str, 
                             input_length: int) -> str:
        """根据任务复杂度选择最优模型"""
        # 基于成本和性能的选择策略
        model_selection = {
            "simple": {
                "threshold": 1000,  # 1K tokens 以下
                "primary": "deepseek-v3.2",  # $0.42/MTok
                "fallback": "gemini-2.5-flash"
            },
            "medium": {
                "threshold": 10000,  # 10K tokens 以下
                "primary": "gemini-2.5-flash",  # $2.50/MTok
                "fallback": "gpt-4.1"
            },
            "complex": {
                "threshold": float('inf'),
                "primary": "gpt-4.1",  # $8/MTok，能力最强
                "fallback": "claude-sonnet-4.5"
            }
        }
        
        strategy = model_selection.get(task_complexity, model_selection["medium"])
        
        # 检查输入长度是否超过模型限制
        primary = strategy["primary"]
        if input_length > self.context_limits.get(primary, float('inf')) * 0.9:
            return strategy["fallback"]
        
        return primary
    
    def estimate_cost(self, model: str, input_tokens: int, 
                      output_tokens: int) -> Dict[str, float]:
        """估算单次调用成本"""
        prices = {
            "gpt-4.1": {"input": 2.0, "output": 8.0},
            "claude-sonnet-4.5": {"input": 3.0, "output": 15.0},
            "gemini-2.5-flash": {"input": 0.30, "output": 2.50},
            "deepseek-v3.2": {"input": 0.10, "output": 0.42}
        }
        
        p = prices.get(model, {"input": 1.0, "output": 5.0})
        input_cost = (input_tokens / 1_000_000) * p["input"]
        output_cost = (output_tokens / 1_000_000) * p["output"]
        
        return {
            "input_cost_usd": round(input_cost, 6),
            "output_cost_usd": round(output_cost, 6),
            "total_cost_usd": round(input_cost + output_cost, 6),
            "total_cost_cny": round((input_cost + output_cost) * 1.0, 4)  # HolySheep 汇率
        }

使用示例
optimizer = CostOptimizer()

估算成本
cost = optimizer.estimate_cost(
    model="deepseek-v3.2",
    input_tokens=5000,
    output_tokens=2000
)
print(f"DeepSeek V3.2 调用成本估算: ¥{cost['total_cost_cny']}")

同样的任务用 GPT-4.1
cost_gpt = optimizer.estimate_cost("gpt-4.1", 5000, 2000)
print(f"GPT-4.1 调用成本估算: ¥{cost_gpt['total_cost_cny']}")

print(f"选择 DeepSeek 可节省: ¥{cost_gpt['total_cost_cny'] - cost['total_cost_cny']}")

成本节省对比计算器

def calculate_savings(monthly_output_tokens: int, model: str = "gpt-4.1") -> dict:
    """
    计算使用 HolySheep API vs 官方 API 的月度节省金额
    
    参数:
        monthly_output_tokens: 月度 Output Token 消耗量
    """
    # 各模型官方 vs HolySheep 的 Output 价格（$/MTok）
    model_prices = {
        "gpt-4.1": {"official": 15.0, "holysheep": 8.0},
        "claude-sonnet-4.5": {"official": 30.0, "holysheep": 15.0},
        "gemini-2.5-flash": {"official": 5.0, "holysheep": 2.50},
        "deepseek-v3.2": {"official": 0.80, "holysheep": 0.42}
    }
    
    prices = model_prices.get(model, {"official": 10.0, "holysheep": 5.0})
    
    # 计算成本（Token 转换为 MTok）
    mtok = monthly_output_tokens / 1_000_000
    
    official_cost = mtok * prices["official"]  # 美元
    holysheep_cost = mtok * prices["holysheep"]  # 美元
    
    # 官方需换汇（按 ¥7.3=$1），HolySheep 直接人民币（¥1=$1）
    official_cost_cny = official_cost * 7.3
    holysheep_cost_cny = holysheep_cost * 1.0  # HolySheep 直接人民币计价
    
    savings = official_cost_cny - holysheep_cost_cny
    savings_percent = (savings / official_cost_cny) * 100
    
    return {
        "model": model,
        "monthly_tokens_m": round(mtok, 2),
        "official_monthly_cny": round(official_cost_cny, 2),
        "holysheep_monthly_cny": round(holysheep
相关资源
📚 AI API 技术文章库
💰 查看价格
📖 开发者文档
🚀 免费注册
相关文章