第2405篇：AI产品的定价策略——Token消耗与商业模式的工程视角

适读人群：参与AI产品商业化的工程师、技术负责人和产品经理 | 阅读时长：约13分钟 | 核心价值：理解AI产品定价的成本结构和常见商业模式，为产品定价决策提供工程视角的支撑

有个问题我被问过很多次：「我们的AI功能，应该怎么定价？」

问这个问题的，有工程师，有产品经理，也有创业团队。

每次我都先反问一个问题：「你们清楚每次AI对话的成本是多少吗？」

通常回答是：「大概知道，但不太精确。」

这就是问题所在。不知道成本的定价，是盲目定价。

AI产品的定价和传统SaaS有根本的不同：传统SaaS的边际成本接近零（一个用户多用几次软件，几乎不产生额外成本），但AI产品每次调用都有真实的、可量化的成本（Token消耗 + 计算资源）。

不理解这个差异，就会出现两种常见的商业模式失败：

一种是定价太低，用户越多亏得越多（典型案例：某些AI产品「随便用、无限次」，被薅羊毛薅死了）；另一种是定价太高，用户不愿意付（因为不理解成本结构，定价超出了价值）。

---

第一步：建立精确的成本核算模型

定价的基础是清楚地知道每次服务的成本是多少。

AI产品的成本由以下几个部分组成：

直接成本：Token消耗

@Service
public class AICostCalculator {
    
    // 以下价格为示例，实际需要根据使用的模型和供应商实时更新
    private static final Map<String, ModelPricing> MODEL_PRICING = Map.of(
        "gpt-4o", new ModelPricing(0.005, 0.015),           // 输入$0.005/1K tokens, 输出$0.015/1K tokens
        "gpt-4o-mini", new ModelPricing(0.00015, 0.0006),   // 更便宜的小模型
        "claude-3-5-sonnet", new ModelPricing(0.003, 0.015),
        "glm-4", new ModelPricing(0.001, 0.001)              // 国产模型通常更便宜
    );
    
    /**
     * 计算单次AI调用的成本
     */
    public CallCost calculateCallCost(String modelName, int inputTokens, int outputTokens) {
        ModelPricing pricing = MODEL_PRICING.get(modelName);
        if (pricing == null) {
            throw new IllegalArgumentException("未知模型：" + modelName);
        }
        
        // 转换为人民币（假设汇率7.2）
        double usdCost = (inputTokens * pricing.inputPricePerKToken() / 1000.0)
            + (outputTokens * pricing.outputPricePerKToken() / 1000.0);
        double cnyTokenCost = usdCost * 7.2;
        
        // 加上基础设施成本（服务器、网络等），通常占直接成本的30-50%
        double infrastructureCost = cnyTokenCost * 0.4;
        
        double totalCost = cnyTokenCost + infrastructureCost;
        
        return new CallCost(inputTokens, outputTokens, cnyTokenCost, 
                           infrastructureCost, totalCost, modelName);
    }
    
    /**
     * 根据业务场景估算月均成本
     * @param monthlyActiveUsers 月活跃用户数
     * @param avgCallsPerUserPerMonth 每用户每月平均调用次数
     * @param avgTokensPerCall 每次调用的平均Token数（输入+输出）
     */
    public MonthlyCostEstimate estimateMonthlyCost(
            int monthlyActiveUsers, 
            double avgCallsPerUserPerMonth,
            int avgInputTokensPerCall,
            int avgOutputTokensPerCall,
            String modelName) {
        
        double totalCalls = monthlyActiveUsers * avgCallsPerUserPerMonth;
        
        CallCost perCallCost = calculateCallCost(
            modelName, avgInputTokensPerCall, avgOutputTokensPerCall);
        
        double totalMonthlyCost = totalCalls * perCallCost.totalCost();
        double costPerUser = totalMonthlyCost / monthlyActiveUsers;
        
        return new MonthlyCostEstimate(
            (long) totalCalls,
            perCallCost.totalCost(),
            totalMonthlyCost,
            costPerUser
        );
    }
    
    record ModelPricing(double inputPricePerKToken, double outputPricePerKToken) {}
    
    record CallCost(
        int inputTokens, int outputTokens,
        double tokenCostCny, double infrastructureCostCny,
        double totalCost, String modelName
    ) {}
    
    record MonthlyCostEstimate(
        long totalMonthlyCallCount,
        double costPerCall,
        double totalMonthlyCost,
        double costPerMonthlyActiveUser
    ) {}
}

使用示例——计算AI客服助手的成本结构：

@Test
public void calculateCustomerServiceAICost() {
    var calculator = new AICostCalculator();
    
    // 假设：每次客服对话平均输入1000 tokens，输出500 tokens
    var estimate = calculator.estimateMonthlyCost(
        10_000,     // 1万月活用户
        8.0,        // 每用户每月平均8次对话
        1000,       // 平均输入Token
        500,        // 平均输出Token
        "gpt-4o-mini"  // 使用较便宜的模型
    );
    
    System.out.println("月均总对话数：" + estimate.totalMonthlyCallCount());
    System.out.printf("每次对话成本：¥%.4f%n", estimate.costPerCall());
    System.out.printf("月均总成本：¥%.2f%n", estimate.totalMonthlyCost());
    System.out.printf("每用户每月成本：¥%.2f%n", estimate.costPerMonthlyActiveUser());
    
    // 输出示例：
    // 月均总对话数：80000
    // 每次对话成本：¥0.0052
    // 月均总成本：¥416.00
    // 每用户每月成本：¥0.04
}

这个计算告诉你：在这个场景下，每用户每月的AI成本只有0.04元，完全可以包含在任何合理的SaaS定价中。

但如果你用的是更贵的模型，或者每次对话Token更多，数字会有很大差异——这就是为什么精确的成本核算如此重要。

---

三种主流AI产品定价模式

模式一：订阅制（月费）

适用场景：重度用户，每天都会用，使用量可预期

定价逻辑：

定价下限 = 月均AI成本 / 用户 × 3（覆盖成本+30%利润+波动缓冲）
定价参考 = 对标竞品 + 价值评估

关键设计：

• 必须有使用量上限（无限使用会导致成本失控）
• 可以设计不同配额的档位（基础版/专业版/企业版）

工程实现要点：

• 每个用户每月的Token使用量需要精确统计
• 接近配额上限时提前预警（用户体验）
• 超过配额后的降级策略（限速 vs 拒绝服务）

模式二：按量计费（Pay-as-you-go）

适用场景：使用量波动大，或者B端企业用户（他们更接受计量收费）

定价逻辑：

每次对话/每千Token的价格 = 成本 × 标记倍数
标记倍数通常在3-10之间（取决于竞争环境和价值感知）

常见的计量单位：

• 按对话次数（适合用户理解，但对长对话不公平）
• 按Token消耗（对用户有学习成本，但最准确）
• 按「积分」（抽象化的计量单位，提高价值感知）

模式三：免费增值（Freemium）

适用场景：消费者产品，需要低门槛吸引用户，通过部分用户转化付费

经济模型：

可持续的Freemium = 免费用户成本 ≤ 付费用户贡献 × 转化率

Freemium的工程设计：

• 免费版本必须有明确的限制（次数限制、功能限制、质量限制）
• 限制的设定需要平衡：太严格→用户价值体验不够→不愿付费；太宽松→太多人免费用→商业不可持续
• 「限制点」的位置要在用户已经体验到价值之后

@Service
public class FreemiumUsageManager {
    
    private static final int FREE_DAILY_CALLS = 10;         // 免费版每日10次
    private static final int FREE_MAX_TOKENS = 500;         // 免费版每次最多500 Token回答
    private static final int PRO_DAILY_CALLS = 200;
    private static final int PRO_MAX_TOKENS = 4000;
    
    /**
     * 检查用户是否可以继续使用，以及使用限制
     */
    public UsagePermission checkAndGetPermission(String userId) {
        UserSubscription subscription = subscriptionRepo.findByUserId(userId);
        UsageStats todayStats = usageRepo.getTodayStats(userId);
        
        if (subscription.isPro()) {
            return UsagePermission.pro(
                PRO_DAILY_CALLS - todayStats.callCount(),
                PRO_MAX_TOKENS
            );
        }
        
        int remainingCalls = FREE_DAILY_CALLS - todayStats.callCount();
        
        if (remainingCalls <= 0) {
            // 触发升级引导而不是直接拒绝
            return UsagePermission.dailyLimitReached(
                "您今天的免费次数已用完",
                "升级专业版，获得每日200次对话 + 更长的回答",
                generateUpgradeUrl(userId)
            );
        }
        
        // 接近限制时提前提示
        if (remainingCalls <= 3) {
            return UsagePermission.freeWithWarning(
                remainingCalls,
                FREE_MAX_TOKENS,
                "今天还剩" + remainingCalls + "次免费对话"
            );
        }
        
        return UsagePermission.free(remainingCalls, FREE_MAX_TOKENS);
    }
    
    record UsagePermission(
        boolean allowed,
        int remainingCalls,
        int maxTokensPerCall,
        String warningMessage,
        String upgradeMessage,
        String upgradeUrl
    ) {
        static UsagePermission pro(int remaining, int maxTokens) {
            return new UsagePermission(true, remaining, maxTokens, null, null, null);
        }
        static UsagePermission free(int remaining, int maxTokens) {
            return new UsagePermission(true, remaining, maxTokens, null, null, null);
        }
        static UsagePermission freeWithWarning(int remaining, int maxTokens, String warning) {
            return new UsagePermission(true, remaining, maxTokens, warning, null, null);
        }
        static UsagePermission dailyLimitReached(String warning, String upgrade, String url) {
            return new UsagePermission(false, 0, 0, warning, upgrade, url);
        }
    }
}

---

定价的工程陷阱：成本异常用户

无论用哪种商业模式，都需要防范「成本异常用户」——少数用户产生大量成本。

常见的异常模式：

• 超长Prompt（几万字的输入）
• 无限循环的API调用（程序bug或恶意请求）
• 爬虫机器人（模拟真实用户大量调用）

@Service
public class AICostAnomalyDetector {
    
    /**
     * 实时检测成本异常，超过阈值时限速或拦截
     */
    public AnomalyResult detect(String userId, String sessionId, 
                                 int inputTokens, int outputTokens) {
        // 1. 单次调用Token超限检查
        if (inputTokens > 8000) {
            return AnomalyResult.blocked(
                "单次输入超过8000 Token，请缩短您的输入",
                "OVERSIZED_INPUT"
            );
        }
        
        // 2. 短时间内高频调用检查（可能是爬虫或bug）
        int callsInLastMinute = usageRepo.countCallsInLastMinute(userId);
        if (callsInLastMinute > 20) {
            // 自动触发人机验证
            return AnomalyResult.captchaRequired(
                "检测到异常高频访问，请完成验证",
                "HIGH_FREQUENCY"
            );
        }
        
        // 3. 单日成本超限检查（企业用户保护）
        double todayCost = costRepo.getTodayCost(userId);
        UserQuota quota = quotaRepo.findByUserId(userId);
        
        if (todayCost > quota.getDailyCostLimit()) {
            return AnomalyResult.dailyLimitExceeded(
                String.format("今日使用量已达到上限（¥%.2f），将在明天0点重置", 
                    quota.getDailyCostLimit()),
                "DAILY_COST_EXCEEDED"
            );
        }
        
        return AnomalyResult.normal();
    }
    
    record AnomalyResult(
        boolean allowed,
        boolean requiresCaptcha,
        String userMessage,
        String anomalyCode
    ) {
        static AnomalyResult normal() {
            return new AnomalyResult(true, false, null, null);
        }
        static AnomalyResult blocked(String msg, String code) {
            return new AnomalyResult(false, false, msg, code);
        }
        static AnomalyResult captchaRequired(String msg, String code) {
            return new AnomalyResult(false, true, msg, code);
        }
        static AnomalyResult dailyLimitExceeded(String msg, String code) {
            return new AnomalyResult(false, false, msg, code);
        }
    }
}

---

定价决策的数据支撑

最后，好的定价需要数据支撑，不是拍脑袋决定的：

需要的数据	来源	用途
每用户每月平均成本	成本核算系统	定价下限
用户愿意支付的金额	用户调研 + 价格测试	定价上限参考
竞品定价	公开信息收集	市场锚定
用户的节省/创造的价值	用户访谈	价值定价基础
不同价格点的转化率	A/B测试	最优价格点

---

总结

AI产品定价的工程视角核心：

1. 成本先行：先算清楚每次服务的真实成本，再谈定价
2. 模式匹配业务：订阅制适合重度用户，按量适合B端，Freemium适合消费者产品
3. 防范成本异常：任何商业模式都需要有成本保护机制
4. 用数据决策：价格测试和用户调研，而不是直觉

工程师参与定价讨论的最大价值，是提供精确的成本数据和技术约束——让商业决策建立在真实的技术经济性上。