🧮 免费层经济学

CAC/LTV 计算、免费→付费转化率行业基准 (2-5%)、何时砍免费层、用量限制怎么设。用数学而不是直觉做免费层决策。

1. 核心数学：Freemium 的盈亏公式

免费层不是"做慈善"。它的本质是一个获客渠道——用基础设施成本代替广告成本。理解这个等式，你就理解了免费层的全部经济逻辑：

当 R_freemium > 0 时，免费层是正 ROI 的获客渠道。当 R_freemium < 0 时，你在烧钱养不付费的人。

推导：免费层的盈亏平衡转化率

从上面的公式可以推导出盈亏平衡转化率——低于这个数字，免费层就在亏钱：

如果你的免费用户每月服务成本是 $0.50，付费用户 ARPU $25/月、平均留存 12 个月，那么只要转化率 > 1%，免费层就是正 ROI。这就是为什么很多产品即使只有 2% 的转化率，免费层仍然划算。

2. CAC：获取一个用户的真实成本

Customer Acquisition Cost（CAC）是 SaaS 经济学中最被滥用的指标。大多数人只算了广告费，忽略了真正的全量成本。

三种 CAC：你要看哪一个？

Fremium 产品的有效 CAC 计算

对于 Freemium 产品，真正的"免费层 CAC"应该这样算：

# Freemium 产品的有效 CAC 计算
monthly_free_users = 100_000      # 每月免费用户（活跃）
conversion_rate = 0.025           # 2.5% 月度免费→付费转化率
cost_per_free_user_monthly = 0.30 # 每免费用户每月基础设施成本
paid_marketing_spend = 5_000      # 每月付费营销（内容、SEO 工具等）
support_cost_per_free_user = 0.10 # 免费用户支持成本（工单/社区）

# 免费层总成本
free_layer_cost = (
    monthly_free_users * cost_per_free_user_monthly +
    monthly_free_users * support_cost_per_free_user +
    paid_marketing_spend
)
# = 100,000 × $0.30 + 100,000 × $0.10 + $5,000 = $35,000

# 新付费用户
new_paid_users = monthly_free_users * conversion_rate
# = 100,000 × 2.5% = 2,500

# 有效 CAC
effective_cac = free_layer_cost / new_paid_users
# = $35,000 / 2,500 = $14/付费用户

print(f"免费层有效 CAC: ${effective_cac:.0f}/付费用户")
print(f"对比：付费广告 CAC 通常 $200-$500")
print(f"免费层获客效率: {200/effective_cac:.0f}x 更优")

3. LTV：一个用户生命周期值多少钱

Life-Time Value（LTV）是判断"一个付费用户值多少钱"的核心指标。和 CAC 配合，就是你定价决策的罗盘。

LTV 计算的三个陷阱

更精确的 LTV 公式（含 Expansion Revenue）

行业 LTV:CAC 比率基准

来源：David Skok "SaaS Metrics 2.0" (2012, 持续更新的行业标杆)、Sequoia Capital 投资备忘录参考值。3:1 是行业公认的健康下限。

4. 转化率：2-5% 的真相

Freemium → Paid 的转化率是最被误读的指标。2-5% 听起来很低，但在正确的框架下，它可能是你能找到的最便宜的获客方式。

按产品类型的转化率基准

数据来源：综合 OpenView 2024 SaaS Benchmarks、ProfitWell/Paddle State of SaaS Pricing 报告、Reforge PLG 指标库、各产品公开披露数据。具体数字因定义不同（月度 vs 年度、注册 vs 活跃）会有差异。

转化率的时间维度：什么时候转化的？

免费→付费不是"第 1 个月 2%"。用户在不同时间点转化，时间分布决定了你的耐心应该有多大。

提升转化率的 8 个杠杆

5. 何时做免费层 / 何时砍免费层

免费层不是万能药。选错场景，它会变成一个无底洞。以下是决策框架。

✅ 适合做免费层的条件

❌ 应该砍掉（或不要做）免费层的信号

真实案例：砍掉免费层的公司

替代免费层的 5 种模式

6. 用量限制怎么设：校准的艺术

用量限制是免费层最精妙的杠杆。设太低 → 用户还没"上瘾"就撞墙，直接流失；设太高 → 用户永远不需要升级。正确答案在中间——让轻度用户满足，让重度用户"正好不够"。

用量限制校准三步法

# 用量限制 A/B 测试框架
import random

class UsageLimitExperiment:
    def __init__(self):
        self.variants = {
            'control': 2000,     # 当前免费上限
            'variant_a': 1500,  # 降低 25%
            'variant_b': 3000,  # 提高 50%
        }
        self.metrics = {v: {'free_users': 0, 'conversions': 0,
                           'churn_at_wall': 0, 'avg_time_to_wall': 0}
                       for v in self.variants}

    def assign_variant(self, user_id):
        """随机分配实验组"""
        return random.choice(list(self.variants.keys()))

    def record_wall_hit(self, variant, converted=False, churned=False):
        """记录撞墙事件"""
        self.metrics[variant]['free_users'] += 1
        if converted:
            self.metrics[variant]['conversions'] += 1
        if churned:
            self.metrics[variant]['churn_at_wall'] += 1

    def results(self):
        """输出实验结果"""
        print(f"{'Variant':<12} {'Limit':<8} {'Users':<8} "
              f"{'Conv Rate':<12} {'Churn@Wall':<12}")
        print("-" * 52)
        for v, limit in self.variants.items():
            m = self.metrics[v]
            conv = m['conversions'] / max(m['free_users'], 1) * 100
            churn = m['churn_at_wall'] / max(m['free_users'], 1) * 100
            print(f"{v:<12} {limit:<8} {m['free_users']:<8} "
                  f"{conv:<12.1f}% {churn:<12.1f}%")

# 关键指标：
# 1. 转化率：哪个限制下转化率最高？
# 2. 撞墙流失率：降低限制是否导致流失？
# 3. 时间到撞墙：用户多久触达上限？
# 4. 转化后 ARPU：不同限制下的付费用户价值是否不同？

7 种免费层限制策略对比

7. 免费层经济学计算器

8. 真实案例拆解

9. AI 时代的免费层：成本结构巨变

AI 产品颠覆了传统 Freemium 经济学的核心假设：边际成本 ≈ 0。对于传统 SaaS（Notion、Linear、Slack），多一个免费用户几乎不增加成本。但对于 AI 产品（ChatGPT、Cursor、Perplexity），每个免费用户每次交互都有真实的 GPU 推理成本。

传统 SaaS vs AI SaaS 的免费层经济学

AI 产品免费层的 6 种策略

10. 代码示例

完整的 Freemium 单位经济学模型

"""
Freemium Economics Model — 完整的单位经济学计算
用于评估免费层的经济可行性
"""

from dataclasses import dataclass, field
from typing import Optional


@dataclass
class FreemiumModel:
    """免费层经济学模型"""

    # === 免费层参数 ===
    monthly_free_users: int = 100_000       # 月活跃免费用户
    cost_per_free_user: float = 0.30        # 每免费用户月成本 ($)
    support_cost_per_free: float = 0.05     # 免费用户支持成本/月 ($)
    free_layer_marketing: float = 5_000     # 免费层相关营销/月 ($)

    # === 转化参数 ===
    conversion_rate: float = 0.025          # 免费→付费月度转化率
    trial_to_paid_rate: float = 0.0         # 如果有 Free Trial，试用→付费
    paid_cac: float = 200                   # 付费获客渠道 CAC ($)

    # === 付费层参数 ===
    arpu: float = 25                        # 每付费用户月收入 ($)
    monthly_churn: float = 0.05             # 月度 Churn Rate
    gross_margin: float = 0.80              # 毛利率
    expansion_rate: float = 0.0             # 月度扩展收入率 (NRR > 1 时 > 0)

    # === 运营参数 ===
    team_size: int = 5                      # 支持/运营团队人数
    avg_salary: float = 80_000              # 年均薪资 ($)
    infra_base: float = 10_000              # 基础设施固定成本/月 ($)

    @property
    def new_paid_users_monthly(self) -> int:
        """月新增付费用户"""
        return int(self.monthly_free_users * self.conversion_rate)

    @property
    def free_layer_total_cost(self) -> float:
        """免费层月总成本"""
        return (
            self.monthly_free_users * self.cost_per_free_user +
            self.monthly_free_users * self.support_cost_per_free +
            self.free_layer_marketing
        )

    @property
    def effective_cac(self) -> float:
        """有效 CAC（免费层）"""
        users = max(self.new_paid_users_monthly, 1)
        return self.free_layer_total_cost / users

    @property
    def lifespan_months(self) -> float:
        """平均用户生命周期（月）"""
        return 1 / self.monthly_churn

    @property
    def ltv(self) -> float:
        """用户生命周期价值"""
        return self.arpu * self.lifespan_months * self.gross_margin

    @property
    def ltv_cac_ratio(self) -> float:
        """LTV:CAC 比率"""
        return self.ltv / max(self.effective_cac, 0.01)

    @property
    def breakeven_conversion_rate(self) -> float:
        """盈亏平衡转化率"""
        total_ltv = self.arpu * self.lifespan_months
        return self.cost_per_free_user / max(total_ltv, 0.01)

    @property
    def monthly_paid_revenue(self) -> float:
        """月新增付费收入"""
        return self.new_paid_users_monthly * self.arpu

    @property
    def annualized_churn(self) -> float:
        """年化 Churn"""
        return 1 - (1 - self.monthly_churn) ** 12

    @property
    def net_freemium_value(self) -> float:
        """免费层月度净值 = 新用户 LTV 总和 - 免费层成本"""
        return self.new_paid_users_monthly * self.ltv - self.free_layer_total_cost

    @property
    def free_cost_as_pct_mrr(self) -> float:
        """免费层成本占月度经常性收入比例"""
        # 需要假设总 MRR（简化：用新增 + 假设存量）
        return 0  # 需要更完整的模型

    def health_check(self) -> dict:
        """单位经济学健康度检查"""
        checks = {
            "LTV:CAC > 3:1": self.ltv_cac_ratio >= 3,
            "LTV:CAC > 5:1": self.ltv_cac_ratio >= 5,
            "转化率 > 盈亏平衡": self.conversion_rate > self.breakeven_conversion_rate,
            "免费层正 ROI": self.net_freemium_value > 0,
            "年化 Churn < 30%": self.annualized_churn < 0.30,
            "Gross Margin > 70%": self.gross_margin > 0.70,
            "有效 CAC < 付费 CAC": self.effective_cac < self.paid_cac,
        }
        return checks

    def summary(self) -> str:
        """打印经济模型摘要"""
        health = self.health_check()
        lines = [
            "=" * 60,
            "📊 FREEMIUM 经济模型摘要",
            "=" * 60,
            f"",
            f"📥 免费层",
            f"  月活跃免费用户: {self.monthly_free_users:>12,}",
            f"  每免费用户月成本: ${self.cost_per_free_user:>10.2f}",
            f"  免费层月总成本: ${self.free_layer_total_cost:>10,.0f}",
            f"",
            f"🔄 转化",
            f"  月度转化率: {self.conversion_rate*100:>11.1f}%",
            f"  盈亏平衡转化率: {self.breakeven_conversion_rate*100:>11.2f}%",
            f"  月新增付费用户: {self.new_paid_users_monthly:>12,}",
            f"",
            f"💰 付费层",
            f"  ARPU: ${self.arpu:>14.0f}/月",
            f"  Gross Margin: {self.gross_margin*100:>12.0f}%",
            f"  月度 Churn: {self.monthly_churn*100:>12.1f}%",
            f"  年化 Churn: {self.annualized_churn*100:>12.1f}%",
            f"  平均生命周期: {self.lifespan_months:>10.1f} 月",
            f"",
            f"📐 单位经济学",
            f"  LTV: ${self.ltv:>15,.0f}",
            f"  有效 CAC: ${self.effective_cac:>12,.0f}",
            f"  LTV:CAC: {self.ltv_cac_ratio:>14.1f}:1",
            f"  免费层月净价值: ${self.net_freemium_value:>8,.0f}",
            f"",
            f"🏥 健康检查",
        ]
        for check, passed in health.items():
            emoji = "✅" if passed else "❌"
            lines.append(f"  {emoji} {check}")

        return "\n".join(lines)


# 运行模型
if __name__ == "__main__":
    # 场景 1: 健康的传统 SaaS
    model = FreemiumModel(
        monthly_free_users=100_000,
        cost_per_free_user=0.10,
        conversion_rate=0.03,
        arpu=25,
        monthly_churn=0.04,
        gross_margin=0.85,
    )
    print(model.summary())

    # 场景 2: AI 产品（高成本免费层）
    model_ai = FreemiumModel(
        monthly_free_users=500_000,
        cost_per_free_user=1.50,  # GPU 推理成本
        conversion_rate=0.02,     # 消费者付费意愿低
        arpu=20,
        monthly_churn=0.08,       # AI 产品 Churn 通常更高
        gross_margin=0.55,        # API 成本吃掉大量毛利
    )
    print("\n\n" + model_ai.summary())

用量墙 Middleware 实现

"""
Usage Wall Middleware — 限流 + 转化引导
适用于 Node.js / Express API
"""

const usageWall = (config) => {
  const {
    freeLimit,          // 免费上限（次数/月）
    planField = 'plan', // 用户对象上的计划字段
    wallMessage,        // 撞墙消息
    upgradeUrl,         // 升级链接
  } = config;

  return async (req, res, next) => {
    const user = req.user;
    if (!user) return next(); // 未登录，交给后续处理

    // 付费用户不受限
    if (user[planField] !== 'free') return next();

    // 获取当月使用量
    const usage = await getMonthlyUsage(user.id);
    const remaining = freeLimit - usage.count;

    // 设置响应头（帮助前端展示进度）
    res.setHeader('X-Usage-Limit', freeLimit);
    res.setHeader('X-Usage-Remaining', Math.max(remaining, 0));
    res.setHeader('X-Usage-Percentage', Math.round(usage.count / freeLimit * 100));

    // 接近上限时预警（80%）
    if (remaining > 0 && remaining <= freeLimit * 0.2) {
      res.setHeader('X-Usage-Warning', 'approaching_limit');
      res.setHeader('X-Upgrade-Url', upgradeUrl);
    }

    // 硬墙：超过上限
    if (usage.count >= freeLimit) {
      return res.status(402).json({
        error: 'usage_limit_reached',
        message: wallMessage || 'You have reached your free tier limit.',
        upgrade: {
          url: upgradeUrl,
          benefit: `Unlimited usage starts at $20/month`,
        },
        current_usage: {
          limit: freeLimit,
          used: usage.count,
          period_end: usage.periodEnd,
        },
      });
    }

    // 通过墙，继续处理
    next();
  };
};

// 使用示例
app.post('/api/completions',
  authenticate,
  usageWall({
    freeLimit: 2000,
    wallMessage: 'You\'ve used all 2,000 free completions this month. Upgrade to Pro for unlimited AI-powered completions.',
    upgradeUrl: '/pricing?ref=wall_completions',
  }),
  handleCompletion
);

// 关键设计决策：
// 1. 响应头暴露使用量进度 → 前端可以显示进度条
// 2. 80% 预警 → 在用户撞墙前就引导升级
// 3. 402 状态码 → 语义清晰（Payment Required）
// 4. 升级信息包含具体价值描述 → 不只是"升级"，而是"无限补全"
// 5. period_end → 告诉用户免费额度何时重置，减少焦虑

11. 相关深度阅读