Free vs Pro vs Max: Claude Code Plan Calculator

Written by Michael Lip · Solo founder of Zovo · $400K+ on Upwork · 100% JSS Join 50+ builders · More at zovo.one

The free Claude tier gives you rate-limited chat but no Claude Code access. Pro at $20/month unlocks Claude Code with 5x free-tier limits. Max 5x at $100/month provides 25x free limits. Max 20x at $200/month gives 100x. Most developers pick a plan by gut feeling and overpay by $80/month – either spending $200/month when $20/month covers their needs, or spending $20/month and losing $550/month in productivity from rate limit waits. This calculator finds your optimal plan using actual usage data.

The Setup

Claude offers five consumer-facing tiers: Free ($0), Pro ($20/month or $17/month annual), Max 5x ($100/month), Max 20x ($200/month), and Team plans ($30-$150/seat). The right plan depends on three variables: how many sessions you run per day, how often you hit rate limits on your current plan, and what your time is worth when waiting. Free doesn’t include Claude Code at all – it’s web and mobile chat only. Pro is the entry point for Claude Code access. The jump from Pro to Max is purely about throughput: same Opus 4.6 model, same quality, just more capacity.

The Math

Plan comparison matrix:

Feature Free ($0) Pro ($20/mo) Max 5x ($100/mo) Max 20x ($200/mo)
Claude Code access No Yes Yes Yes
Usage level Base 5x free 25x free 100x free
Annual option N/A $17/mo ($200/yr) No No
Conversation memory No No Yes Yes
Priority access No No Yes Yes (highest)
Claude in PowerPoint No No Yes Yes
Early access features No No Yes Yes

Cost of being on the wrong plan:

Scenario A – Heavy user on Pro:

Scenario B – Light user on Max 20x:

The Technique

Use this interactive calculator to find your optimal plan.

from dataclasses import dataclass

@dataclass
class PlanRecommendation:
    plan_name: str
    monthly_cost: float
    total_cost: float  # subscription + productivity loss
    rationale: str

def calculate_optimal_plan(
    daily_sessions: int,
    rate_limit_waits_per_day: int = 0,
    avg_wait_minutes: float = 10.0,
    hourly_rate: float = 50.0,
    needs_claude_code: bool = True,
    team_size: int = 1,
    prefers_annual: bool = False,
) -> list[PlanRecommendation]:
    """Calculate cost of each plan including productivity loss."""

    workdays = 22

    monthly_wait_hours = (
        rate_limit_waits_per_day * avg_wait_minutes * workdays / 60
    )
    monthly_wait_cost = monthly_wait_hours * hourly_rate

    results = []

    if not needs_claude_code:
        results.append(PlanRecommendation(
            "Free", 0, 0,
            "You don't need Claude Code - Free works for chat"
        ))
        return results

    # Pro
    pro_cost = 17.0 if prefers_annual else 20.0
    pro_label = f"Pro ({'$17 annual' if prefers_annual else '$20 monthly'})"
    # Pro handles ~50-80 sessions/month without throttling
    pro_throttle_pct = max(0, (daily_sessions * workdays - 80) / (daily_sessions * workdays)) if daily_sessions > 0 else 0
    pro_wait_cost = monthly_wait_cost  # current waits on Pro

    # If they're currently on Pro, use their actual wait data
    # If not on Pro, estimate based on session volume
    if rate_limit_waits_per_day == 0 and daily_sessions > 4:
        # Estimate waits on Pro for heavy users
        estimated_waits = max(0, daily_sessions - 4) * 0.5
        pro_wait_cost = estimated_waits * avg_wait_minutes * workdays / 60 * hourly_rate

    results.append(PlanRecommendation(
        pro_label, pro_cost * team_size,
        pro_cost * team_size + pro_wait_cost * team_size,
        f"Base plan, ~{monthly_wait_hours:.0f}h waits/mo"
    ))

    # Max 5x
    max5_cost = 100.0
    max5_wait_cost = pro_wait_cost * 0.15  # ~85% fewer waits
    results.append(PlanRecommendation(
        "Max 5x ($100/mo)", max5_cost * team_size,
        max5_cost * team_size + max5_wait_cost * team_size,
        f"5x Pro throughput, ~{max5_wait_cost * team_size / hourly_rate:.1f}h waits/mo"
    ))

    # Max 20x
    max20_cost = 200.0
    results.append(PlanRecommendation(
        "Max 20x ($200/mo)", max20_cost * team_size,
        max20_cost * team_size,  # effectively zero waits
        "20x Pro throughput, no practical rate limits"
    ))

    # Team plans (if team_size > 1)
    if team_size > 1:
        team_std_cost = 25.0 if prefers_annual else 30.0
        team_std_label = f"Team Standard ({'$25' if prefers_annual else '$30'}/seat)"
        results.append(PlanRecommendation(
            team_std_label,
            team_std_cost * max(5, team_size),  # min 5 seats
            team_std_cost * max(5, team_size) + pro_wait_cost * team_size,
            f"SSO, admin, min 5 seats"
        ))

        team_prem_cost = 150.0
        results.append(PlanRecommendation(
            "Team Premium ($150/seat)",
            team_prem_cost * max(5, team_size),
            team_prem_cost * max(5, team_size),
            "Claude Code CLI, high limits"
        ))

    # Sort by total cost (subscription + productivity)
    results.sort(key=lambda r: r.total_cost)

    return results


def print_recommendation(
    daily_sessions: int,
    rate_limit_waits: int,
    hourly_rate: float,
    team_size: int = 1,
):
    """Print formatted plan recommendation."""
    results = calculate_optimal_plan(
        daily_sessions=daily_sessions,
        rate_limit_waits_per_day=rate_limit_waits,
        hourly_rate=hourly_rate,
        team_size=team_size,
    )

    print(f"\n{'='*60}")
    print(f"CLAUDE CODE PLAN CALCULATOR")
    print(f"Sessions/day: {daily_sessions} | "
          f"Waits/day: {rate_limit_waits} | "
          f"Rate: ${hourly_rate}/hr | "
          f"Team: {team_size}")
    print(f"{'='*60}\n")

    print(f"{'Plan':<30} {'Subscription':>12} {'Total Cost':>12}")
    print(f"{'-'*54}")
    for r in results:
        marker = " <-- BEST" if r == results[0] else ""
        print(f"{r.plan_name:<30} "
              f"${r.monthly_cost:>10.2f} "
              f"${r.total_cost:>10.2f}{marker}")

    best = results[0]
    print(f"\nRecommendation: {best.plan_name}")
    print(f"Rationale: {best.rationale}")
    if len(results) > 1:
        savings = results[-1].total_cost - results[0].total_cost
        print(f"Saves ${savings:.2f}/month vs worst option")


# Run scenarios
print_recommendation(daily_sessions=3, rate_limit_waits=0, hourly_rate=50)
print_recommendation(daily_sessions=15, rate_limit_waits=4, hourly_rate=75)
print_recommendation(daily_sessions=30, rate_limit_waits=8, hourly_rate=100)
print_recommendation(daily_sessions=10, rate_limit_waits=2, hourly_rate=60, team_size=5)

Quick reference for common developer profiles:

# Hobbyist (weekends only, 5-10 sessions/week)
# Recommendation: Pro at $20/month (or $17/month annual)
# Total cost: ~$20/month

# Part-time developer (20 sessions/week)
# Recommendation: Pro at $20/month, some occasional waits
# Total cost: ~$70/month (sub + productivity)

# Full-time developer (40-60 sessions/week)
# Recommendation: Max 5x at $100/month
# Total cost: ~$115/month

# Power user (100+ sessions/week)
# Recommendation: Max 20x at $200/month
# Total cost: $200/month (zero waits)

# Team of 5 engineers
# Recommendation: Team Standard at $25/seat/year ($125/month)
# or Team Premium at $150/seat ($750/month) for CLI access

The Tradeoffs

The calculator uses estimated productivity loss, which varies by individual. Some developers use rate limit waits productively (code review, documentation, thinking time). Others lose flow state and take 15-20 minutes to re-engage after each interruption, making the effective cost of each wait 2-3x the raw wait time. Use the calculator’s output as a starting point, then adjust based on your personal flow sensitivity. Also consider: Pro with annual billing at $17/month might be the right choice even for moderate users, saving $36/year over monthly billing.

Implementation Checklist

Measuring Impact

The plan calculator’s value is measured in monthly savings: the difference between what you’re paying now (subscription + productivity loss) and what the optimal plan costs. Track rate limit encounters before and after switching plans. If you downgrade from Max to Pro and rate limits increase by more than 2 per day, the downgrade may not be worth it. If you upgrade from Pro to Max and rate limits drop to zero, calculate whether the eliminated wait time justifies the premium. Re-evaluate every quarter as your usage patterns evolve.