# MakerKit 1.1.0: The Most Advanced Billing System in Any SaaS Starter Kit

> MakerKit 1.1.0 introduces multi-line item checkout, tiered pricing, optional add-ons, and dynamic per-seat billing. The most flexible billing in any SaaS boilerplate.

*Published: 2026-02-05*
*Canonical: https://makerkit.dev/blog/changelog/makerkit-1-1-0-advanced-billing*

---

MakerKit 1.1.0 ships with multi-line item checkout, tiered pricing, optional add-ons, and a recipe to enable automatic per-seat billing. 

You can now combine a base subscription fee, per-seat charges, and metered AI tokens in a single Stripe checkout session.

{% img src="/images/posts/advanced-billing-pricing-table.webp" width="1000" height="1000" alt="Advanced Billing Pricing Table" /%}

Billing is the feature that makes or breaks a SaaS product. Get it wrong and you leave money on the table. Get it right and your pricing becomes a competitive advantage. 

With 1.1.0, we're giving you the tools to do the latter (and we're not done yet...).

## What's New in 1.1.0

**Multi-line item checkout** creates subscriptions with multiple price components. Instead of a single `planId`, you define `lineItems` that combine in one checkout:

```typescript
lineItems: [
  {
    id: 'base',
    name: 'Pro Subscription',
    type: 'flat',
    priceId: 'price_pro_base',
    cost: 29,
  },
  {
    id: 'seats',
    name: 'Team Members',
    type: 'usage',
    unit: 'seat',
    priceId: 'price_pro_seats',
    tiers: [
      { cost: 0, upTo: 1 },      // First seat included
      { cost: 5, upTo: 'infinite' },
    ],
  },
  {
    id: 'ai-tokens',
    name: 'AI Tokens',
    type: 'usage',
    billingUsageType: 'metered',
    unit: 'tokens',
    priceId: 'price_ai_tokens',
    tiers: [
      { cost: 0, upTo: 5000 },
      { cost: 0.02, upTo: 50000 },
      { cost: 0.01, upTo: 'infinite' },
    ],
  },
]
```

This configuration does what typically takes months of custom Stripe integration: a base fee, tiered per-seat pricing with the first seat free, and metered AI token billing with volume discounts.

{% img src="/images/posts/multi-product-stripe-checkout.webp" width="1950" height="1538" alt="Multi-product Stripe checkout session with base fee, per-seat pricing, and metered usage" /%}

- **Tiered pricing** gives you volume discounts. The `tiers` array lets you define graduated pricing where the cost per unit decreases as quantity increases. Stripe handles all the proration math when customers upgrade mid-cycle.
- **Optional add-ons** let customers choose premium features during checkout. Mark a line item as `optional: true` and it appears as a toggleable option:

```typescript
{
  id: 'premium-support',
  name: 'Premium Support',
  type: 'flat',
  priceId: 'price_premium_support',
  cost: 49,
  optional: true,
}
```

**Dynamic per-seat billing** updates subscription quantities automatically when team members join or leave. We built this using organization lifecycle hooks that fire after membership changes:

```typescript
// When a member joins, update the subscription
afterInvitationAcceptRegistry.registerPolicy(seatBillingOnAcceptPolicy);

// When a member leaves, update the subscription
afterMemberRemoveRegistry.registerPolicy(seatBillingOnRemovePolicy);
```

The billing provider handles proration automatically. Add a member mid-cycle? Stripe charges a prorated amount. Remove one? Prorated credit.

{% img src="/images/posts/member-seats-product-creation.webp" width="1924" height="1412" alt="Stripe product creation for per-seat member billing with tiered pricing" /%}

{% img src="/images/posts/token-usage-product-creation.webp" width="1932" height="1428" alt="Stripe product creation for metered token usage with volume discounts" /%}

## Why This Matters

The SaaS pricing landscape has changed. Flat-rate plans are leaving money on the table. The companies winning in 2026 use hybrid pricing models: a base fee for core access, per-seat charges that scale with team size, and usage-based components for variable costs like AI or API calls.

Implementing this in Stripe requires custom code. A lot of it. Multi-line item checkout, subscription quantity updates, webhook handling for seat changes, proration logic. We've seen teams spend months on billing alone.

MakerKit 1.1.0 makes it possible to configure this in a few minutes.

## How It Works

### SimplePlan vs AdvancedPlan

MakerKit's billing configuration supports two plan structures:

**SimplePlan** uses a single `planId` for straightforward pricing:

```typescript
{
  name: 'starter-monthly',
  planId: 'price_starter_monthly',
  displayName: 'Starter',
  interval: 'month',
  cost: 19,
}
```

**AdvancedPlan** uses `lineItems` for complex scenarios:

```typescript
{
  name: 'pro-monthly',
  displayName: 'Pro',
  interval: 'month',
  cost: 29,
  lineItems: [
    // Multiple prices combined
  ],
}
```

Both work. Choose SimplePlan when you have one price per plan. Choose AdvancedPlan when you need multiple components.

### Provider Support

| Capability | Stripe | Polar |
|------------|:------:|:-----:|
| Multi-line item checkout | Yes | No |
| Tiered pricing | Yes | No |
| Optional add-ons | Yes | No |
| Subscription quantity updates | Yes | Yes |
| Metered billing | Yes | Yes |

Multi-line item checkout is Stripe-only. Polar's checkout model supports a single product per session. If you need complex pricing, use Stripe.

## Real Example: Complete Pro Plan

Here's a production-ready configuration that combines everything:

```typescript
{
  id: 'pro',
  name: 'Pro',
  description: 'For growing teams',
  currency: 'USD',
  features: [
    'Unlimited projects',
    'Advanced analytics',
    'Priority support',
    'Generous AI credits included',
  ],
  plans: [
    {
      name: 'pro-monthly',
      displayName: 'Pro Monthly',
      interval: 'month',
      cost: 19.99,
      lineItems: [
        {
          id: 'pro-base',
          name: 'Pro Subscription',
          type: 'flat',
          priceId: process.env.STRIPE_PRICE_PRO_BASE!,
        },
        {
          id: 'pro-per-seat',
          name: 'Additional Seats',
          type: 'usage',
          unit: 'seat',
          priceId: process.env.STRIPE_PRICE_PRO_SEATS!,
          tiers: [
            { cost: 0, upTo: 1 },
            { cost: 5, upTo: 'infinite' },
          ],
        },
        {
          id: 'pro-ai-tokens',
          name: 'AI Tokens',
          type: 'usage',
          billingUsageType: 'metered',
          unit: 'tokens',
          priceId: process.env.STRIPE_PRICE_AI_TOKENS!,
          tiers: [
            { cost: 0, upTo: 5000 },
            { cost: 0.02, upTo: 50000 },
            { cost: 0.01, upTo: 'infinite' },
          ],
        },
      ],
    },
  ],
}
```

This creates a plan with:
- $19.99/month base fee
- First seat included, $5/seat after that
- 5,000 free AI tokens, then $0.02/token up to 50K, then $0.01/token

The pricing table component renders this automatically. The checkout creates a Stripe session with all three prices. The webhooks track everything.

## Recording Metered Usage

Metered line items (like AI tokens) require you to report usage via Stripe Billing Meters. MakerKit provides a unified API for this:

```typescript
import { getBilling } from '@kit/billing-api';

// Record usage when customer consumes tokens
const billing = await getBilling(auth);

await billing.recordMeterEvent({
  eventName: 'ai_tokens_used',      // Must match your Stripe meter
  customerId: stripeCustomerId,
  value: tokensConsumed,
});
```

Stripe aggregates the usage and bills at the end of each billing period using your tiered pricing. You can also query current usage:

```typescript
const usage = await billing.getUsage(
  meterId,
  stripeCustomerId,
  startOfBillingPeriod,
  now
);
```

See the [Metered Usage documentation](/docs/nextjs-drizzle/billing/metered-usage) for the complete setup including Stripe meter configuration.

## Current Limitations

**Stripe Checkout doesn't support mixing intervals.** All line items in a multi-price checkout must share the same billing interval (all monthly or all yearly). You can't combine a monthly base fee with a yearly add-on in a single checkout session. We're hoping Stripe adds this capability soon.

## Coming Soon: Credit Drawdown

We're working on prepaid credits billing for the next release. Buy a block of credits upfront (say, 10,000 AI tokens for $50) and draw them down as you use them. This pattern is huge for AI-powered SaaS where usage is unpredictable.

Stripe recently launched billing credits for exactly this use case. We're building the MakerKit integration now.

## Quick Recommendation

**MakerKit 1.1.0 advanced billing is best for:**
- SaaS products with hybrid pricing (base + seats + usage)
- Teams that need volume discounts or tiered pricing
- Products with optional premium features or add-ons
- Anyone tired of building custom Stripe integrations

**Skip advanced billing if:**
- You have a single flat-rate price per plan (use SimplePlan instead)
- You're using Polar or Lemon Squeezy (multi-line items are Stripe-only)

**Our pick**: If you're building a serious SaaS in 2026, you need flexible billing. MakerKit 1.1.0 has the most complete implementation of any starter kit. Start with the [Advanced Pricing documentation](/docs/nextjs-drizzle/billing/advanced-pricing) to see the full configuration options.

## Upgrade Notes

These features are additive. Your existing billing configuration continues to work unchanged. 

To use advanced pricing:

1. Replace `planId` with `lineItems` in plans that need multiple prices
2. Create the corresponding prices in Stripe (tiered, metered, etc.)
3. Set environment variables for each price ID
4. Update your pricing table if you want to show tier breakdowns

## Getting Started

**New to MakerKit?** Check out the [Next.js Drizzle SaaS Starter Kit](/nextjs-drizzle-saas-starter-kit) or [Next.js Prisma SaaS Starter Kit](/nextjs-prisma-saas-starter-kit).

**Existing user?** Read the full documentation:
- [Advanced Pricing](/docs/nextjs-drizzle/billing/advanced-pricing) for multi-line items, tiered pricing, and add-ons
- [Per-Seat Billing](/docs/nextjs-drizzle/billing/per-seat-billing) for automatic subscription quantity updates
- [Organization Lifecycle Hooks](/docs/nextjs-drizzle/organizations/lifecycle-hooks) for the hook system powering per-seat billing

{% faq
   title="Frequently Asked Questions"
   items=[
     {"question": "Does multi-line item checkout work with Polar?", "answer": "No. Multi-line item checkout is Stripe-only. Polar supports subscription quantity updates but not multi-price checkout."},
     {"question": "Can I migrate from planId to lineItems?", "answer": "Yes but if you have only one price per plan, you can just use the planId field."},
     {"question": "How do I show tiered pricing in my pricing table?", "answer": "The pricing table component reads the tiers array automatically. You can customize the display in packages/billing/ui/src/components/pricing-table.tsx."},
     {"question": "When will credits-based billing be available?", "answer": "Soon - we're working on it!"}
   ]
/%}

---

**Next:** Explore the [Advanced Pricing documentation](/docs/nextjs-drizzle/billing/advanced-pricing) for the complete configuration reference.