Skip to main content

Usage-Based Pricing Models for SaaS

Usage-Based Pricing Overview​

Definition: Charge based on consumption (API calls, storage, compute) rather than fixed seats/features

Also called: Consumption-based, pay-as-you-go, metered billing

When to use:

  • ✅ Value scales with usage (more API calls = more value)
  • ✅ Variable customer usage patterns
  • ✅ Transparent cost structure
  • ✅ Easy to measure/meter
  • ✅ Aligns cost with value delivered

When NOT to use:

  • ❌ Hard to measure usage
  • ❌ Unpredictable revenue (hard to forecast)
  • ❌ Customers want predictable bills
  • ❌ High fixed costs (doesn't scale with usage)

Common Usage Metrics​

Infrastructure/Cloud​

  • Compute: CPU hours, GPU hours
  • Storage: GB stored, GB transferred
  • Bandwidth: Data transfer (in/out)
  • Requests: API calls, function invocations

Examples: AWS, Vercel, Cloudflare

APIs/Services​

  • API calls: Per request
  • Messages: Emails sent, SMS sent
  • Webhooks: Events triggered
  • Processing: Documents processed, images analyzed

Examples: Twilio, SendGrid, OpenAI API

SaaS Applications​

  • Seats: Active users (hybrid model)
  • Actions: Tasks completed, workflows run
  • Data: Records stored, rows processed
  • Time: Minutes used (calls, meetings)

Examples: Zapier (tasks), Calendly (meetings), Airtable (records)

Pricing Models​

1. Pure Pay-As-You-Go​

How it works: Pay exactly for what you use, no minimums

Pros:

  • Low barrier to entry ($0 to start)
  • Customers only pay for value received
  • Scales naturally with customer growth

Cons:

  • Unpredictable revenue
  • Low revenue from small customers
  • Requires billing infrastructure

Example: AWS Lambda

$0.20 per 1M requests
$0.0000166667 per GB-second of compute

Customer usage:
- 5M requests/month
- 100,000 GB-seconds

Bill = (5 × $0.20) + (100,000 × $0.0000166667)
     = $1.00 + $1.67
     = $2.67/month

Best for: Infrastructure, APIs with highly variable usage

2. Tiered Usage Pricing​

How it works: Price per unit decreases as usage increases

Pros:

  • Volume discounts (incentivizes growth)
  • More predictable than pure pay-as-you-go
  • Rewards power users

Cons:

  • More complex to communicate
  • Can create weird incentives at tier boundaries

Example: Twilio SMS

First 1,000 messages: $0.0075/message
Next 9,000 messages: $0.0070/message
Next 90,000 messages: $0.0060/message
100,000+ messages: $0.0050/message

Customer sends 15,000 messages/month:
- First 1,000: 1,000 × $0.0075 = $7.50
- Next 9,000: 9,000 × $0.0070 = $63.00
- Next 5,000: 5,000 × $0.0060 = $30.00
Total = $100.50/month

Best for: APIs, communication services, high-volume usage

3. Credits/Quota System​

How it works: Buy credits upfront, consume as you use

Pros:

  • Predictable revenue (prepaid)
  • Simpler mental model ("I have 1,000 credits")
  • Encourages commitment (buy in bulk)

Cons:

  • Can be confusing (what is a "credit"?)
  • Unused credits = waste (customer frustration)
  • Requires credit tracking system

Example: OpenAI API

$10 = 10M tokens (GPT-3.5)
$10 = 500K tokens (GPT-4)

Customer buys $50 credits
Uses GPT-4 for 2M tokens
Bill = 2M / 500K × $10 = $40
Remaining credits: $10

Best for: AI services, communication APIs, complex pricing

4. Hybrid: Base + Usage​

How it works: Fixed monthly base + usage overage

Pros:

  • Predictable base revenue
  • Customers have budget certainty
  • Upside from power users

Cons:

  • More complex to explain
  • Need to set right base/overage split

Example: Vercel

Pro Plan: $20/month base includes:
- 100 GB bandwidth
- 1,000 build minutes

Overages:
- Additional bandwidth: $0.10/GB
- Additional build minutes: $0.05/minute

Customer usage:
- 150 GB bandwidth
- 1,200 build minutes

Bill = $20 (base)
     + (50 × $0.10) (bandwidth overage)
     + (200 × $0.05) (build overage)
     = $20 + $5 + $10
     = $35/month

Best for: Most SaaS (balances predictability + growth alignment)

Pricing Strategy Design​

Step 1: Choose Your Unit of Value​

Good units:

  • ✅ Easy to measure (API calls, storage GB)
  • ✅ Aligns with customer value (more usage = more value)
  • ✅ Predictable for customer (can estimate costs)
  • ✅ Hard to game (can't abuse free tier)

Bad units:

  • ❌ Confusing ("credits" that vary by feature)
  • ❌ Doesn't align with value (charge per page view but value is conversions)
  • ❌ Easy to game (unlimited free tier loophole)

Examples:

  • API testing tool: API requests/month
  • AI chatbot: Conversations/month
  • Reminder assistant: People tracked/month
  • Email service: Emails sent/month

Step 2: Set Price Per Unit​

Cost-plus method:

Your cost to serve: $0.001 per API call
Target margin: 80%
Price = $0.001 / (1 - 0.80) = $0.005 per call

Value-based method:

Customer saves $1,000/month using your API
Customer makes 100,000 API calls/month
Acceptable price (10% of savings): $100/month
Price per call = $100 / 100,000 = $0.001 per call

Competitor benchmarking:

Competitor A: $0.01 per call
Competitor B: $0.005 per call
Your price: $0.007 per call (middle ground)

Step 3: Design Tiers (Hybrid Model)​

Free Tier:

  • 100 units/month (enough to test)
  • No credit card required
  • Community support

Starter ($10/month):

  • 1,000 units included
  • $0.02 per unit overage
  • Email support

Pro ($30/month):

  • 5,000 units included
  • $0.015 per unit overage
  • Priority support

Enterprise (Custom):

  • 50,000+ units included
  • Custom volume pricing
  • Dedicated support

Advantages of Usage-Based Pricing​

For Customers​

  1. Pay for what you use - No waste
  2. Low barrier to entry - Free or cheap to start
  3. Scales with business - Cost grows with value
  4. Transparent - Clear what you're paying for
  5. No vendor lock-in - Easy to reduce usage

For Vendors​

  1. Revenue scales - Customer growth = revenue growth
  2. Land and expand - Start small, grow naturally
  3. Competitive differentiation - Alternative to per-seat
  4. Customer success alignment - More usage = more value = happy customer
  5. Natural segmentation - Small/medium/large customers pay accordingly

Challenges & Solutions​

Challenge 1: Revenue Unpredictability​

Problem: Usage fluctuates month-to-month

Solutions:

  • Hybrid model (base + usage)
  • Commit tiers (pre-purchase $100/month)
  • Annual contracts (guaranteed minimums)
  • Cohort analysis (predict future usage patterns)

Challenge 2: Bill Shock​

Problem: Customer gets unexpectedly high bill

Solutions:

  • Usage alerts ("You've used 80% of your limit")
  • Spending caps ("Stop at $100/month")
  • Predictive billing ("On track for $X this month")
  • Gradual ramp-up (don't let first month be huge)

Challenge 3: Pricing Complexity​

Problem: Customers don't understand what they'll pay

Solutions:

  • Pricing calculator on website
  • Clear examples ("Typical customer: 10K API calls = $50/month")
  • Transparent unit pricing (not confusing credits)
  • Free tier to test (estimate before committing)

Challenge 4: Low-Value Customers​

Problem: Free tier users never convert, cost money to serve

Solutions:

  • Free tier limits (100 calls/month, then pay)
  • Credit card upfront (even for free tier)
  • Sunset inactive users (no usage for 90 days)
  • Generous but finite (50-100 units, not unlimited)

Usage-Based Pricing Examples​

Example 1: API Service (OpenAI-style)​

GPT-4 API: $0.03 per 1K tokens input, $0.06 per 1K tokens output

Customer usage:
- 1M input tokens
- 500K output tokens

Bill = (1,000 × $0.03) + (500 × $0.06)
     = $30 + $30
     = $60/month

Free tier: $5 credits (try before buy)

Example 2: Hybrid (Vercel-style)​

Starter: $20/month
- 100 GB bandwidth included
- Overages: $0.15/GB

Pro: $40/month
- 1 TB bandwidth included
- Overages: $0.10/GB

Customer (Starter):
- Uses 150 GB
- Bill = $20 + (50 × $0.15) = $27.50/month

Example 3: Tiered Pricing (Twilio-style)​

Email API:
- 0-10K emails: $1.00 per 1K emails
- 10K-100K emails: $0.75 per 1K emails
- 100K+ emails: $0.50 per 1K emails

Customer sends 50K emails/month:
- First 10K: 10 × $1.00 = $10
- Next 40K: 40 × $0.75 = $30
Total = $40/month

Implementation Checklist​

  • Choose clear unit of value
  • Calculate cost per unit (COGS)
  • Set target margin (70-90% for SaaS)
  • Price per unit (cost-plus or value-based)
  • Design free tier (100-1000 units)
  • Design paid tiers (hybrid or pure usage)
  • Implement usage tracking/metering
  • Build billing infrastructure (Stripe, etc.)
  • Add usage alerts (prevent bill shock)
  • Create pricing calculator (help customers estimate)
  • Monitor: conversion rate, ARPU, churn by usage cohort

Resources​