Master Subscription Patterns with Stripe: From Flat-Rate to Usage-Based
The Shift Nobody Expected
Five years ago, almost every SaaS used the same model: a monthly plan, done. Today is different. Founders have discovered that charging based on what customers actually use is fairer, more scalable, and creates less friction.
And Stripe is there to make it happen.
The reality is brutal: if your business model doesn't adapt to how your customers actually consume your product, someone else will. That's why you need to understand these four patterns and know when to use them.
The Four Patterns That Matter
#### 1. Flat-Rate: Simplicity Is Your Weapon
One fixed price, always. No surprises, no calculations.
This model works when:
- Your product has clearly defined value
- Your customers don't vary much in consumption
- You want maximum simplicity in billing
Example: a design tool that costs the same for everyone, regardless of how many projects you create.
With Stripe, implementing it is trivial:
```javascript const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: 'price_flatrate_monthly', }, ], }); ```
The hard part isn't the code. It's choosing the right price.
#### 2. Per-Seat: Linear Scaling With Your Customer
You charge for each user your customer adds. You typically see this in collaboration tools.
Advantage: your customer feels they pay for what they use. Disadvantage: it can discourage them from inviting more people to their team.
Implementation with Stripe:
```javascript const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: 'price_per_seat', quantity: numberOfSeats, }, ], });
// When they add a new user await stripe.subscriptionItems.createUsageRecord( subscriptionItemId, { quantity: 1, action: 'increment' } ); ```
The key here is syncing your database with Stripe. Every time the number of users changes, Stripe needs to know.
#### 3. Tiered: Different Prices, Different Benefits
Three plans: basic, professional, enterprise. Each with more features.
This is the traditional model, but it's still powerful. Why: it creates a psychological "ladder" that guides your customers upward.
The trick: don't make too many plans. Three or four is the maximum. More than that confuses.
```javascript const plans = { basic: 'price_basic_monthly', pro: 'price_pro_monthly', enterprise: 'price_enterprise_monthly', };
const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: plans[selectedPlan], }, ], }); ```
#### 4. Usage-Based: The Future (And It's Already Here)
You charge based on what they actually consume. API calls, GB stored, processing minutes.
This is the fastest-growing model. Why: it's the fairest. A customer who uses little pays little. One who exploits your service pays more. Everyone's happy.
But it's more complex to implement.
With Stripe, you use "metered billing":
```javascript // Record usage in real-time await stripe.subscriptionItems.createUsageRecord( subscriptionItemId, { quantity: apiCallsThisMonth, action: 'set', // 'set' overwrites, 'increment' adds timestamp: Math.floor(Date.now() / 1000), } ); ```
The real complexity lies in: 1. Tracking usage accurately - you need a system that counts every action 2. Deciding the price per unit - too high scares people, too low isn't profitable 3. Communicating it well - your customers must understand what they're paying for
The Hybrid Model: Your Secret Weapon
Many SaaS now combine models. Example:
- Base fixed plan (flat-rate)
- More users if needed (per-seat)
- Extra usage billed above a certain limit (usage-based)
This is what you see in Vercel, Supabase, Stripe itself.
With Stripe, implementing it requires multiple items in the same subscription:
```javascript const subscription = await stripe.subscriptions.create({ customer: customerId, items: [ { price: 'price_base_plan', // Flat-rate }, { price: 'price_per_seat', // Per-seat quantity: 5, }, { price: 'price_usage_based', // Usage-based }, ], }); ```
How to Choose Your Model
There's no "best" model. It depends on your business:
Choose Flat-Rate if:
- Your product has uniform value
- You want maximum simplicity
- Your customers vary little in consumption
Choose Per-Seat if:
- Your product scales with users
- You want to grow with your customer
- It's easy to count "seats"
Choose Tiered if:
- You have clearly differentiated features
- You want to guide customers toward premium plans
- It's a proven model in your industry
Choose Usage-Based if:
- Consumption varies enormously between customers
- You want them to pay only for what they use
- You have infrastructure to track usage
The Reality of Implementing This
Stripe's API is solid. But there are details many developers miss:
1. Webhooks - you need to listen for `invoice.payment_succeeded` to know when to bill 2. Synchronization - your database and Stripe must stay in sync 3. Testing - it's easy to break billing. Test everything. 4. Customer documentation - explain how your model works
```javascript // Basic webhook to process billing app.post('/webhooks/stripe', async (req, res) => { const event = req.body;
if (event.type === 'invoice.payment_succeeded') { const invoice = event.data.object; // Your logic here: send confirmation, update access, etc. }
res.json({ received: true }); }); ```
The Psychological Factor
Here's what nobody says: pricing model is pure psychology.
Usage-based sounds fair, but scares customers who don't know how much they'll spend. Flat-rate is predictable, but some customers feel they pay for what they don't use.
The best strategy: offer a model that makes sense for your business, but communicate it so your customer understands exactly what they pay and why.
My Recommendation
If you're starting out: start with flat-rate or tiered. It's simple, it works, and your customers understand it.
When you grow and have enough data: experiment with usage-based. Many SaaS discover it's more profitable.
And always: use Stripe. It's not the only option, but it's the most reliable. Documentation is good, the API is stable, and support works.
Next Steps
You don't need to implement all models today. You need to choose one, implement it well, and iterate.
Look at your competition. Look at your customers. Choose the model that makes the most sense.
And remember: the best pricing model is the one your customers understand and accept without friction.
---
What model do you use in your SaaS? What was your biggest pain implementing it with Stripe? Share in the comments.