Why Your AI SaaS Pricing Is Bleeding Money: The Token Economics Problem

Mar 15, 2026

The Problem

I was building an AI-powered writing assistant. Simple enough—let users chat with GPT-4, charge $15/month. Seemed reasonable.

Then I ran the numbers:

My costs:
- Average user: 50 messages/day
- Average tokens per message: 2,000 input + 500 output
- GPT-4o-mini cost: $0.15/1M input, $0.60/1M output

Monthly cost per user:
- 50 messages * 30 days = 1,500 messages/month
- 1,500 * (2000/1M * $0.15 + 500/1M * $0.60) = $0.0675/month

Perfect! $15 - $0.07 = $14.93 margin per user.

Then I launched. A week later:

Reality check:
- Power users: 200+ messages/day
- Complex prompts: 10,000+ tokens per message
- Using GPT-4o instead of mini

Actual monthly cost per power user:
- 200 * 30 * (10000/1M * $2.50 + 3000/1M * $10.00) = $99/month

Revenue: $15
Cost: $99
Loss per power user: $84/month

I was losing money on every heavy user. And the 80/20 rule hit hard—20% of users were burning 80% of my API budget.

The Economics Problem Nobody Talks About

Here’s what I didn’t understand: consumer AI subscriptions are massively subsidized.

A Reddit thread on r/SaaS laid it out:

“Claude Max subscription ($200/mo) provides tokens equivalent to ~$8,000/mo at API rates. A single complex coding session can burn $20-30 in API credits.”

The math is brutal:

Tier	Consumer Price	API Equivalent	Subsidy
ChatGPT Plus	$20/month	~$200/month	10x
Claude Pro	$20/month	~$500/month	25x
Claude Max	$200/month	~$8,000/month	40x

This means I cannot compete on “AI access.” OpenAI and Anthropic are burning venture capital to acquire users. Their subscription prices are loss leaders, not sustainable business models.

Another commenter put it bluntly:

“No one is making money from it. Everything is subsidised.”

Why Direct API Resale Fails

I tried the “AI wrapper” model: expose API access with a markup. Here’s why it failed:

1. You can’t compete on price

My costs are API costs plus markup. Their costs are… whatever they want, because VC money subsidizes the difference.

2. Token costs are unpredictable

# Session costs can vary 20,000x
simple_query = 0.001      # "Hello"
complex_session = 20.00   # Multi-hour coding session with Claude

# You can't predict which user will be which
# And you can't price for the worst case

3. Users don’t understand tokens

I tried showing token counts. Users didn’t care. They wanted outcomes.

The comment that stuck with me:

“The margin only exists when the LLM is a component inside something that does a job, not the product itself.”

The Solution: AI as Component, Not Product

I pivoted. Instead of “Chat with AI,” I built “AI-Powered Contract Review.”

Here’s the difference:

WRONG: "Chat with AI" - $20/mo
       (Competing with Claude Max, losing money)

RIGHT: "AI-Powered Contract Review" - $200/mo
       (AI extracts risks, but value is in legal protection)

The AI isn’t the product. The AI helps deliver a valuable outcome. Users pay for the outcome, not the tokens.

Pricing Strategies That Actually Work

I tested several approaches. Here’s what worked:

Strategy 1: Tier by Model, Not Tokens

Price by capability, not usage:

TIERS = {
    "free": {
        "model": "haiku",
        "price": 0,
        "limit": "10 reviews/month"
    },
    "pro": {
        "model": "sonnet",
        "price": 29,
        "limit": "100 reviews/month"
    },
    "business": {
        "model": "opus",
        "price": 99,
        "limit": "unlimited reviews"
    }
}

Why this works:

Users understand “better model = better results”
You can optimize costs with model routing
Clear value ladder

Strategy 2: Smart Model Routing

Don’t use premium models for everything:

def select_model(task_complexity: str, user_tier: str) -> str:
    """Route to appropriate model based on task and tier"""

    ROUTING = {
        "free": {
            "simple": "haiku",     # Fast, cheap
            "medium": "haiku",     # Downgrade for free
            "complex": "haiku"     # Downgrade for free
        },
        "pro": {
            "simple": "haiku",     # Save money
            "medium": "sonnet",    # Good balance
            "complex": "sonnet"    # Premium tasks
        },
        "business": {
            "simple": "haiku",     # Still use efficient model
            "medium": "sonnet",
            "complex": "opus"      # Best model for complex
        }
    }

    return ROUTING[user_tier][task_complexity]

This reduced my API costs by 65% without degrading user experience.

Strategy 3: Cost-Plus Pricing with Buffers

I built a calculator to find sustainable prices:

from dataclasses import dataclass

@dataclass
class ModelCosts:
    input_per_m: float   # $ per 1M input tokens
    output_per_m: float  # $ per 1M output tokens

@dataclass
class TierPricing:
    avg_input: int       # Average input tokens per session
    avg_output: int      # Average output tokens per session
    sessions_per_month: int
    variance_buffer: float   # 1.3-1.5x for usage spikes
    target_margin: float     # 2-5x for sustainability


def calculate_sustainable_price(
    model: ModelCosts,
    tier: TierPricing
) -> dict:
    """Calculate sustainable tier pricing"""

    # Calculate cost per session
    input_cost = (tier.avg_input / 1_000_000) * model.input_per_m
    output_cost = (tier.avg_output / 1_000_000) * model.output_per_m
    cost_per_session = input_cost + output_cost

    # Calculate monthly cost with variance buffer
    monthly_cost = cost_per_session * tier.sessions_per_month
    buffered_cost = monthly_cost * tier.variance_buffer

    # Apply target margin
    final_price = buffered_cost * tier.target_margin

    return {
        "cost_per_session": round(cost_per_session, 4),
        "monthly_cost": round(monthly_cost, 2),
        "recommended_price": round_up_to_5(final_price),  # Round to nearest $5
        "margin_percent": round((final_price - monthly_cost) / final_price * 100, 0)
    }


def round_up_to_5(price: float) -> int:
    return int((price // 5 + 1) * 5)


# Example: Contract review feature with Sonnet
sonnet = ModelCosts(input_per_m=3.0, output_per_m=15.0)
contract_tier = TierPricing(
    avg_input=2000,       # Contract text + context
    avg_output=1500,      # Review + suggestions
    sessions_per_month=100,  # Daily reviews
    variance_buffer=1.4,    # Account for power users
    target_margin=3         # Sustainable margin
)

result = calculate_sustainable_price(sonnet, contract_tier)
print(result)
# {'cost_per_session': 0.0285, 'monthly_cost': 2.85,
#  'recommended_price': 15, 'margin_percent': 81.0}

Strategy 4: Hybrid Subscription + Metered

For variable usage:

class HybridPricing:
    def __init__(self):
        self.base_price = 29  # Covers fixed costs
        self.included_sessions = 50
        self.overage_rate = 0.50  # Per session

    def calculate_monthly_bill(self, sessions: int) -> float:
        if sessions <= self.included_sessions:
            return self.base_price

        overage = sessions - self.included_sessions
        return self.base_price + (overage * self.overage_rate)

    def calculate_margin(self, sessions: int, cost_per_session: float):
        bill = self.calculate_monthly_bill(sessions)
        cost = sessions * cost_per_session
        return {
            "revenue": bill,
            "cost": round(cost, 2),
            "margin": round(bill - cost, 2),
            "margin_percent": round((bill - cost) / bill * 100, 0)
        }

This protects margins while showing transparent value.

Common Mistakes I Made

Mistake 1: Competing on token price

“I’ll offer cheaper AI access” — You can’t. The providers set the floor.

Mistake 2: Exposing token economics

“Your request used 1,234 tokens” — Users don’t care. They pay for outcomes.

Mistake 3: Ignoring session variance

“Average cost is $0.10” — But power users cost $10+. The 80/20 rule applies to AI costs.

Mistake 4: Using premium models everywhere

“Let’s use GPT-4 for everything” — Reserve premium models for high-value tasks. Use Haiku/mini for the rest.

Mistake 5: Flat pricing without limits

“Unlimited AI for $10/mo” — A few power users will bankrupt you.

Complete Pricing Model

Here’s the sustainable approach I settled on:

from dataclasses import dataclass
from typing import Literal

@dataclass
class PricingTier:
    name: str
    price: int
    model: Literal["haiku", "sonnet", "opus"]
    sessions_per_month: int
    features: list[str]

    def calculate_break_even(self, cost_per_session: float) -> float:
        """Calculate minimum sessions to break even"""
        monthly_cost = cost_per_session * self.sessions_per_month
        return monthly_cost / self.price  # Cost as % of revenue


# Define tiers
TIERS = [
    PricingTier(
        name="Free",
        price=0,
        model="haiku",
        sessions_per_month=10,
        features=["Basic contract review", "Email support"]
    ),
    PricingTier(
        name="Pro",
        price=29,
        model="sonnet",
        sessions_per_month=100,
        features=["Advanced review", "Risk scoring", "Priority support"]
    ),
    PricingTier(
        name="Business",
        price=99,
        model="opus",
        sessions_per_month=500,
        features=["Full analysis", "Custom rules", "API access", "Dedicated support"]
    )
]

# Calculate sustainability
def audit_pricing(tiers: list[PricingTier], costs: dict[str, float]):
    """Audit pricing sustainability"""
    print("Pricing Audit:")
    print("-" * 60)

    for tier in tiers:
        if tier.price == 0:
            print(f"{tier.name}: Free tier (loss leader for acquisition)")
            continue

        cost_per_session = costs[tier.model]
        monthly_cost = cost_per_session * tier.sessions_per_month
        margin = tier.price - monthly_cost
        margin_pct = (margin / tier.price) * 100

        status = "SUSTAINABLE" if margin_pct > 60 else "AT RISK"

        print(f"{tier.name} (${tier.price}):")
        print(f"  Model: {tier.model}")
        print(f"  Sessions: {tier.sessions_per_month}")
        print(f"  Cost: ${monthly_cost:.2f}")
        print(f"  Margin: ${margin:.2f} ({margin_pct:.0f}%)")
        print(f"  Status: {status}")
        print()


# Run audit
MODEL_COSTS = {
    "haiku": 0.002,   # Per session average
    "sonnet": 0.03,
    "opus": 0.15
}

audit_pricing(TIERS, MODEL_COSTS)

Output:

Pricing Audit:
------------------------------------------------------------
Free: Free tier (loss leader for acquisition)

Pro ($29):
  Model: sonnet
  Sessions: 100
  Cost: $3.00
  Margin: $26.00 (90%)
  Status: SUSTAINABLE

Business ($99):
  Model: opus
  Sessions: 500
  Cost: $75.00
  Margin: $24.00 (24%)
  Status: AT RISK

The Business tier shows thin margins—I should either raise price or reduce sessions.

Summary

In this post, I showed why AI SaaS pricing is broken and how to fix it. The key insight: AI is a component, not a product. Sustainable pricing comes from the value your product delivers, not the tokens it consumes.

What I learned:

Consumer AI subscriptions are subsidized by VC money—you can’t compete on token price
Token costs vary 20,000x—you need buffers for variance
Users pay for outcomes, not tokens—hide the complexity
Smart model routing cuts costs 65%—don’t use premium models everywhere
Price tiers by value delivered, not API costs passed through

The formula that works:

Sustainable Price = (Average Session Cost * Sessions * Variance Buffer) * Target Margin

Where:

Variance Buffer = 1.3-1.5x (for the 80/20 rule)
Target Margin = 2-5x (for sustainable business)

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Reddit: Why AI SaaS pricing is broken
👨‍💻 Anthropic API Pricing
👨‍💻 OpenAI API Pricing

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!