usage-based-pricing — скилл для Claude Code: тарифы для разработчиков

---
name: usage-based-pricing
description: |
  Design pricing models that developers understand, accept, and can predict.
  Trigger phrases: usage-based pricing, API pricing, metered billing,
  developer pricing, pricing page, cost calculator, pay as you go,
  pricing transparency, competitive pricing, developer billing
metadata:
  version: 1.0.0
---

# Usage-Based Pricing

Design pricing models that developers understand, accept, and can predict—without surprise bills or confusing metrics.

## Overview

Developers are uniquely sensitive to pricing. They'll calculate unit economics, compare alternatives, and write blog posts about surprise bills. Usage-based pricing works well for developer tools because it aligns cost with value, but it can also create anxiety about unpredictable costs.

The best developer pricing is predictable, transparent, and obviously fair. Developers should be able to estimate their bill before they commit.

## Before You Start

Review the `/devmarketing-skills/skills/free-tier-strategy` skill to understand how free tiers connect to paid pricing. Your pricing model should feel like a natural extension of the free tier, not a completely different experience.

## Usage Metrics Developers Accept

### Good Metrics: Direct Value Correlation

**API calls/requests**
- Developers understand what triggers a call
- Easy to monitor and predict
- Scales with actual usage
- Example: Stripe charges per transaction, Twilio per message

**Compute time**
- Clear relationship to server costs
- Predictable for consistent workloads
- Fair for variable workloads
- Example: AWS Lambda per GB-second, Vercel build minutes

**Storage**
- Simple to understand
- Easy to predict growth
- Clear cost driver
- Example: S3 per GB stored, databases per GB

**Bandwidth/data transfer**
- Makes sense for CDN and hosting
- Can be surprising if not monitored
- Example: Cloudflare per GB, Vercel bandwidth

**Active users (MAU)**
- Works for auth and user-facing tools
- Aligns with customer's growth
- Example: Auth0, Firebase Auth

### Problematic Metrics

**"Compute units" or proprietary measures**
```
Bad: "1 CU = 0.25 CPU seconds at 1.5GHz equivalent with 256MB memory allocation"
Developers can't estimate usage.
```

**Compound metrics**
```
Bad: "Charged per operation, where operation = read OR write OR delete,
     multiplied by document size factor"
Too complex to predict.
```

**Metrics that punish success**
```
Bad: Per-user pricing that penalizes viral growth
Developer's successful launch becomes a cost crisis.
```

**Metrics with hidden multipliers**
```
Bad: "Per request, but each retry counts, and warming requests count,
     and health checks count"
Actual usage is unpredictable.
```

### Metric Selection Framework

| Metric | When It Works | When It Fails |
|--------|---------------|---------------|
| API calls | Discrete operations | Streaming, persistent connections |
| Compute time | Variable workloads | Idle resources still cost |
| Storage | Data products | Temporary/cache data |
| Bandwidth | CDN, media | Retry-heavy protocols |
| MAU | User-facing apps | Machine-to-machine |
| Seats | Collaboration tools | Individual developers |

## Pricing Page Clarity

### Essential Pricing Page Elements

1. **Price per unit, clearly stated**
```
$0.01 per 1,000 API calls
$0.10 per GB stored
$5 per team member
```

2. **Usage calculator**
```
Estimate your monthly cost:
API calls per month: [____]
Storage (GB): [____]

Estimated cost: $XX/month
```

3. **Tier comparison table**
```
                Free        Pro         Enterprise
API calls       10,000/mo   100,000/mo  Unlimited
Storage         1GB         50GB        500GB
Support         Community   Email       Priority
Price           $0          $29/mo      $299/mo
```

4. **FAQ answering real questions**
- "What happens if I exceed my limit?"
- "How do I monitor my usage?"
- "Are there any hidden fees?"
- "Can I set spending limits?"

### Pricing Page Examples

**Excellent: Stripe**
- Simple percentage per transaction
- Clear calculator
- All fees visible
- Volume discounts transparent

**Excellent: Cloudflare**
- Free tier generous
- Paid features clearly differentiated
- Per-feature pricing available
- Enterprise custom pricing framed simply

**Poor patterns:**
- "Contact sales" for any pricing information
- Prices hidden until signup
- Complex unit definitions
- Multiple interdependent metrics

### Price Communication Principles

1. **Lead with simple cases** - Show the "typical" cost first
2. **Reveal complexity gradually** - Edge cases in FAQ, not main pricing
3. **Use real numbers** - "$47/month for a typical SaaS app" beats "$0.001 per request"
4. **Compare to alternatives** - "50% less than AWS" (if true and provable)

## Cost Predictability and Caps

### Why Predictability Matters

Developers fear:
- Unexpected month-end bills
- Usage spikes from bugs or attacks
- Being unable to explain costs to managers
- Services that punish success

### Providing Predictability

**Usage dashboards:**
```
Current billing period: March 1-31

API calls:     45,000 / 100,000 (45%)
Storage:       12GB / 50GB (24%)
Bandwidth:     89GB / 100GB (89%) ⚠️

Projected bill: $47 (current: $38)
```

**Usage alerts:**
```
Alert settings:
[ ] 50% of monthly limit
[x] 75% of monthly limit
[x] 90% of monthly limit
[x] 100% of monthly limit
[ ] Daily usage spike (>2x average)
```

**Spending caps:**
```
Monthly spending cap: $100

When reached:
( ) Hard stop - service pauses
(x) Soft stop - alert and require approval
( ) No stop - continue and alert
```

### Cap Implementation Considerations

**Hard caps:**
- Service stops at limit
- Best for: Development, non-critical
- Risk: Production outages

**Soft caps:**
- Service continues, alerts sent
- Best for: Production, alert required
- Risk: Unexpected overages

**Burst allowance:**
- Short-term overage allowed
- Best for: Handling legitimate spikes
- Risk: Abuse potential

**Automatic scaling:**
- Auto-upgrade tier temporarily
- Best for: Predictable growth
- Risk: Confusion about costs

## Billing Transparency

### The Bill Should Tell a Story

**Bad invoice:**
```
Usage charges: $147.00
Total: $147.00
```

**Good invoice:**
```
API Usage
- Requests: 245,000 @ $0.01/1,000 = $2.45
- Bandwidth: 150GB @ $0.10/GB = $15.00

Compute
- Function invocations: 50,000 @ $0.0001 = $5.00
- Compute time: 10,000 GB-sec @ $0.0000166 = $0.17

Storage
- Database: 25GB @ $0.50/GB = $12.50

Platform fee: $29.00 (Pro plan base)

Subtotal: $64.12
Credits applied: -$10.00 (new user credit)

Total: $54.12
```

### Usage Visibility

**Dashboard requirements:**
- Real-time or near-real-time usage
- Daily/weekly/monthly views
- Breakdown by resource/project
- Comparison to previous periods
- Export for internal analysis

**API for usage data:**
```bash
curl https://api.example.com/usage \
  -H "Authorization: Bearer sk_live_xxx"

{
  "period": "2024-03-01/2024-03-31",
  "api_calls": 245000,
  "bandwidth_gb": 150,
  "cost_to_date": 54.12,
  "projected_cost": 62.00
}
```

### Billing Cycle Best Practices

- **Monthly billing** - Standard, predictable
- **Prepaid credits** - Discount for commitment, reduces uncertainty
- **Annual contracts** - For enterprise, discount for commitment
- **Billing date choice** - Let customers align with their accounting

## Communicating Value vs Cost

### The Value Conversation

Don't just communicate price—communicate value relative to alternatives.

**Alternative cost comparisons:**
```
Running this yourself:
- Server costs: $200/mo
- Engineer time: $5,000/mo
- Maintenance: $500/mo
Total: $5,700/mo

Our service: $99/mo
You save: $5,601/mo
```

**Time savings:**
```
Without [Product]:
- 2 weeks to build
- 4 hours/month to maintain

With [Product]:
- 30 minutes to integrate
- Zero maintenance

Developer time saved: 120+ hours/year
```

### ROI Calculators

For enterprise sales, provide ROI tools:

```
Your company:
- Developers: [10]
- Hours/week on auth: [5]
- Fully-loaded cost/hour: [$150]

Current cost: $3,000/week = $156,000/year

With [Product]:
- Integration: 20 hours one-time = $3,000
- Annual cost: $12,000
- Maintenance: Near zero

First year savings: $141,000
```

### Pricing Justification

When prices seem high, justify with:
1. **Feature completeness** - "Includes what others charge extra for"
2. **Reliability** - "99.99% uptime saves you from outages"
3. **Support** - "Engineering support, not offshore scripts"
4. **Scale** - "Handles 10x traffic without config changes"
5. **Security** - "SOC 2, GDPR, HIPAA included"

## Competitive Pricing Research

### Understanding the Landscape

**Map competitors by:**
1. Direct competitors (same solution)
2. Adjacent competitors (different approach, same problem)
3. Build-it-yourself (internal development cost)
4. Status quo (doing nothing)

**Pricing model analysis:**
```
Competitor A: $0.015/request, no free tier, 99.9% SLA
Competitor B: $0.008/request, generous free tier, 99.5% SLA
Open source: $0 + hosting costs (~$0.005/request) + maintenance
```

### Pricing Position Options

**Premium pricing:**
- Higher price, higher perceived value
- Works with: Superior product, enterprise focus
- Requires: Clear differentiation

**Value pricing:**
- Comparable price, more features
- Works with: Feature-rich products
- Requires: Clear comparison

**Penetration pricing:**
- Lower price, gain market share
- Works with: Commoditized features
- Requires: Path to profitability

**Usage-aligned pricing:**
- Aligned with customer value
- Works with: Variable usage patterns
- Requires: Clear value correlation

### Competitive Analysis Template

For each competitor:
```
[Competitor Name]
Pricing model: [Per-seat / usage-based / flat]
Free tier: [Yes/No, limits]
Starting price: [$X/mo or $/unit]
Enterprise: [Custom / listed price]
Key differentiator: [Feature/price/market]
Developer sentiment: [From Twitter, HN, Reddit]
```

### Price Testing

**A/B testing considerations:**
- Test different price points (carefully, ethically)
- Test different packaging (bundles vs. à la carte)
- Test annual vs. monthly emphasis
- Test value framing ("save $X" vs. "costs $Y")

**Qualitative research:**
- Win/loss analysis: Why did they choose us/competitor?
- Price sensitivity interviews: What would change their decision?
- Value perception: What do they think is fair?

## Pricing Anti-Patterns

### The Surprise Bill

Developers share horror stories:
- "My $20/month bill became $2,000"
- "A bug caused infinite loops and I owe $500"
- No warning, no cap, no mercy

**Solution:** Spending caps, usage alerts, anomaly detection

### The Pricing Maze

- Requires spreadsheet to calculate
- Different metrics for different features
- Hidden fees discovered later
- Changes frequently without notice

**Solution:** Simple, clear, stable pricing

### The Negotiation Game

- "Contact sales" for all meaningful tiers
- List price is 10x actual price
- Every customer gets different deal
- Penalizes customers who don't negotiate

**Solution:** Transparent pricing, volume discounts listed

### The Bait and Switch

- Free tier gets worse over time
- Prices increase without grandfathering
- Features move from free to paid
- "New pricing" disadvantages existing customers

**Solution:** Grandfathering, clear migration paths, community communication

## Examples: Pricing That Works

### Stripe

- Per-transaction percentage (2.9% + 30¢)
- Aligns with customer revenue
- Predictable and simple
- Volume discounts for scale

### Twilio

- Per-message/per-minute pricing
- Clear unit costs
- Usage dashboard and alerts
- Prepaid credits for discount

### Vercel

- Clear tier structure
- Generous free tier
- Usage-based for bandwidth/builds
- Team pricing separate

### DigitalOcean

- Predictable monthly pricing
- Clear size/price relationship
- Hourly billing option
- Bandwidth included in pricing

## Examples: Pricing Problems

### Confusing Unit Pricing

Some cloud providers:
- Per "compute unit" (undefined)
- Multiple meters per service
- Different rates for different operations
- Bill requires expert interpretation

### Enterprise Tax

Some companies:
- SSO requires enterprise tier
- SSO tier is 10x team tier
- No intermediate option
- Punishes security-conscious teams

### Punishing Success

Some user-based pricing:
- Free tier: 100 users
- Paid tier: $0.10/user
- Viral success = immediate $$$
- Discourages growth

## Tools

### Billing Platforms

- **Stripe Billing** - Subscription and usage-based billing
- **Orb** - Usage-based billing infrastructure
- **Lago** - Open source billing platform
- **Metronome** - Usage metering and billing
- **Chargebee** - Subscription management

### Usage Metering

- **Segment** - Event tracking for usage
- **Rudderstack** - Open source alternative
- **Custom** - Most companies build their own metering

### Pricing Pages

- **PricingPage.io** - Templates and inspiration
- **ProfitWell** - Pricing analytics
- **Baremetrics** - SaaS metrics and pricing tools

### Competitive Intelligence

- **Competitors.app** - Track competitor pricing changes
- **Manual monitoring** - Sign up for competitor newsletters
- **Community research** - Reddit, HN, Twitter sentiment

## Related Skills

- `/devmarketing-skills/skills/free-tier-strategy` - Free tier design
- `/devmarketing-skills/skills/developer-signup-flow` - Getting to the pricing page
- `/devmarketing-skills/skills/developer-onboarding` - Demonstrating value before price