Lago vs Kill Bill vs Stripe Billing 2026: Open-Source Billing Engines

Billing is one of the most underestimated problems in SaaS. Every company starts with a Stripe Checkout integration, and then pricing gets complex: seats multiply, usage tiers get added, enterprise contracts need custom terms, and suddenly your billing code is the scariest part of your codebase.

Open-source billing engines exist precisely for this inflection point. Three platforms dominate the conversation: Lago (modern, OSS), Kill Bill (enterprise OSS veteran), and Stripe Billing (managed, ubiquitous). This guide breaks down which fits your stage, pricing model, and technical stack.

Related: Best Open Source Stripe Billing Alternatives 2026 · How to Self-Host Lago · How to Migrate from Stripe to Kill Bill

---

The Billing Complexity Problem

Most teams hit billing complexity in a predictable sequence:

1. Phase 1 (0–$10k MRR): Stripe Checkout + basic subscriptions. Fine.
2. Phase 2 ($10k–$50k MRR): Usage-based add-ons, trials, coupons. Stripe Billing starts working.
3. Phase 3 ($50k–$200k MRR): Metered billing, seat-based pricing, enterprise invoicing. Stripe's 0.5–0.7% billing fee costs $250–1,400/month. The pain begins.
4. Phase 4 ($200k+ MRR): Multi-currency, hybrid pricing, custom contracts. The question becomes: do we own our billing infrastructure?

This is the moment teams evaluate OSS billing engines.

---

Lago: Modern Open-Source Metered Billing

Lago is an open-source metering and usage-based billing API launched in 2022. It positions itself as the developer-friendly alternative to Chargebee, Recurly, and Stripe Billing. It's MIT-licensed, self-hostable, and has a managed cloud option.

GitHub stats (2026): 7,000+ stars, actively maintained, backed by YC funding.

Core Architecture

Lago is event-based at its core. You emit billing events (API calls made, GB stored, messages sent), and Lago aggregates them into charges based on your pricing configuration. This is fundamentally different from Stripe Billing, which requires pre-aggregated usage numbers.

Key capabilities:

• Ingest up to 15,000 billing events per second
• Usage-based billing (per-unit, tiered, volume, package)
• Seat-based and flat-rate subscriptions
• Hybrid pricing (flat fee + metered usage)
• Multi-currency support
• Coupons, trials, and free units
• Invoice customization (templates, branding)
• Payment orchestration (Stripe, Adyen, GoCardless)
• Revenue analytics dashboard
• Webhooks for all billing events
• GraphQL and REST API

Pricing Models Supported

Model	Example	Lago Support
Flat rate	$99/month flat	Yes
Per-seat	$15/user/month	Yes
Metered (per-unit)	$0.01 per API call	Yes
Tiered	First 1k calls free, then $0.01	Yes
Volume discount	>10k calls: $0.008/call	Yes
Package	$50 for 5k call bundle	Yes
Hybrid	$50 base + metered usage	Yes
Pay-as-you-go	No minimum, pure usage	Yes

---

Kill Bill: Enterprise Open-Source Billing

Kill Bill is the veteran of this space — a Java-based, plugin-driven billing platform that has been battle-tested in telecom, fintech, and enterprise SaaS for over a decade. It handles scenarios that newer platforms don't touch: complex subscription hierarchies, multi-tenant billing, revenue recognition (ASC 606), and telecom-grade scale.

GitHub stats (2026): 4,500+ stars, slower growth but deep enterprise adoption.

Core Architecture

Kill Bill uses a plugin architecture with a rich internal event bus. Every billing operation is represented as an immutable event, giving you a full audit trail and the ability to replay/reprocess events. The Java foundation means it runs on almost any JVM-compatible infrastructure.

Key capabilities:

• Subscription lifecycle management (trials, upgrades, downgrades, cancellations)
• Usage-based billing with pluggable metering backends
• Full invoice and payment management
• Multi-tenant support (SaaS operators can bill their own customers)
• Dunning management (retry logic for failed payments)
• Revenue recognition and reporting
• 30+ payment plugins (Stripe, PayPal, Braintree, Authorize.net, etc.)
• REST API with Swagger docs
• Kaui: web admin UI for operations teams

When Kill Bill Shines

Kill Bill is overkill for most SaaS startups but exactly right for:

• Telcos and ISPs: Complex usage rating, CDRs, multi-service bundles
• Marketplaces: Multi-sided billing with complex settlement
• Enterprise SaaS with legacy integrations: Kill Bill's plugin architecture integrates with SAP, Oracle, etc.
• Multi-tenant platforms: Bill your customers' customers

---

Stripe Billing: The Managed Option

Stripe Billing isn't open-source — it's Stripe's subscription and billing product, included when you use Stripe as your payment processor. It's the default choice for most funded startups because the developer experience is exceptional and the documentation is world-class.

Pricing: 0.5% of revenue for basic subscriptions, 0.7% for usage-based billing (Stripe's flexible billing)

What Stripe Billing Does Well

• Developer experience is industry-best — SDKs for every language, excellent docs
• Hosted payment pages that handle SCA, 3DS, local payment methods
• Tax calculation (Stripe Tax, additional fee)
• Revenue reporting built-in
• Radar fraud detection integrated
• Customer portal (hosted billing management)

Where Stripe Billing Falls Short

• Not event-based: You must pre-aggregate usage and report it to Stripe. There's no real-time metering.
• Percentage fee: At $200k MRR with usage billing, you're paying $1,400/month just for the billing layer — before processing fees
• Vendor lock-in: Migrating off Stripe Billing is painful. Customer billing history, payment methods, and subscription state are all in Stripe
• Pricing model limits: Complex tiered models, multi-attribute pricing, and conditional billing logic hit hard limits

---

Comparison Table

Feature	Lago	Kill Bill	Stripe Billing
License	MIT	Apache 2.0	Proprietary
Self-Host	Yes	Yes	No
Event-Based Metering	Yes (15k events/sec)	Yes (with plugins)	No (pre-aggregate only)
Seat-Based Billing	Yes	Yes	Yes
Metered/Usage Billing	Yes	Yes	Limited
Hybrid Pricing	Yes	Yes	Yes
Multi-Currency	Yes	Yes	Yes
Payment Providers	Stripe, Adyen, etc.	30+ plugins	Stripe only
Revenue Recognition	Via webhooks	Built-in	Via Stripe data
Multi-Tenant	Enterprise plan	Yes	No
REST API	Yes	Yes	Yes
Web Admin UI	Yes	Kaui	Yes (dashboard)
Dev Experience	Modern, great docs	Complex, steep curve	Excellent
Cost at $100k MRR	~$200/mo (hosting)	~$200/mo (hosting)	~$700/mo (0.7%)
Cost at $500k MRR	~$500/mo (hosting)	~$500/mo (hosting)	~$3,500/mo (0.7%)
GitHub Stars (2026)	~7k	~4.5k	N/A

---

Code Examples: Creating a Subscription

Lago (REST API)

# Create a customer
curl -X POST "https://api.getlago.com/api/v1/customers" \
  -H "Authorization: Bearer $LAGO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "customer": {
      "external_id": "cust_123",
      "email": "user@example.com",
      "name": "Acme Corp"
    }
  }'

# Assign a subscription plan
curl -X POST "https://api.getlago.com/api/v1/subscriptions" \
  -H "Authorization: Bearer $LAGO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "subscription": {
      "external_customer_id": "cust_123",
      "plan_code": "growth_monthly",
      "external_id": "sub_123",
      "billing_time": "anniversary"
    }
  }'

# Emit a usage event (metered billing)
curl -X POST "https://api.getlago.com/api/v1/events" \
  -H "Authorization: Bearer $LAGO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "event": {
      "transaction_id": "evt_abc123",
      "external_subscription_id": "sub_123",
      "code": "api_calls",
      "timestamp": 1710000000,
      "properties": {
        "count": 150
      }
    }
  }'

Stripe Billing (Node.js SDK)

const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

// Create a customer
const customer = await stripe.customers.create({
  email: 'user@example.com',
  name: 'Acme Corp',
});

// Create a subscription
const subscription = await stripe.subscriptions.create({
  customer: customer.id,
  items: [{ price: 'price_growth_monthly' }],
  payment_behavior: 'default_incomplete',
  expand: ['latest_invoice.payment_intent'],
});

// Report usage (must pre-aggregate yourself)
await stripe.subscriptionItems.createUsageRecord(
  'si_item_id',
  {
    quantity: 150,
    timestamp: Math.floor(Date.now() / 1000),
    action: 'increment',
  }
);

Note the key difference: Lago receives raw events and handles aggregation. Stripe requires you to pre-aggregate usage into a single quantity value.

---

When OSS Billing Makes Financial Sense

The breakeven calculation is straightforward:

Stripe Billing cost at $X MRR: X * 0.007 per month (usage billing)

Lago/Kill Bill self-host cost: ~$200–500/month depending on infrastructure

Monthly MRR	Stripe Billing Cost	Lago/Kill Bill Cost	Monthly Savings
$50k	$350	$200	$150
$100k	$700	$250	$450
$200k	$1,400	$300	$1,100
$500k	$3,500	$500	$3,000

The breakeven point is roughly $40–50k MRR for usage-based billing. Below that, Stripe Billing's DX advantages outweigh the cost.

There's also the migration cost to factor in: a team of 2–3 engineers will spend 2–4 weeks migrating billing infrastructure. At typical engineering salaries, that's $15–30k in one-time cost. This means the actual breakeven might be closer to $80–100k MRR when total cost of migration is included.

---

Self-Hosting Lago: Docker Compose

version: "3.8"
services:
  lago-api:
    image: getlago/api:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://lago:password@db:5432/lago
      - REDIS_URL=redis://redis:6379
      - SECRET_KEY_BASE=your_secret_key_base
      - LAGO_RSA_PRIVATE_KEY=your_rsa_key
      - LAGO_SIDEKIQ_WEB=true

  lago-front:
    image: getlago/front:latest
    restart: unless-stopped
    ports:
      - "80:80"
    environment:
      - API_URL=http://lago-api:3000

  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=lago
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=lago
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

---

Recommendation

Use Stripe Billing if:

• You're pre-product-market-fit or under $50k MRR
• Your pricing model is straightforward (flat or per-seat)
• Your engineering team doesn't want to own billing infrastructure
• Time-to-market is critical

Use Lago if:

• You have usage-based or complex metered pricing
• You're approaching $50–100k MRR and the 0.7% fee is becoming material
• You want modern tooling with good DX and active development
• You need to self-host for compliance (fintech, healthcare adjacent)

Use Kill Bill if:

• You're building a multi-tenant billing platform (billing your customers' customers)
• You're in telecom, fintech, or have complex enterprise pricing structures
• You need 10+ year battle-tested enterprise stability
• Your team has Java expertise

For most growing SaaS companies in 2026, Lago is the right OSS billing choice — it's built for the usage-based pricing era that Stripe Billing wasn't designed for.