Seat Limits vs Per-Seat Pricing: Billing Organizations with Stripe in Next.js

Two ways to tie team size to billing in a multi-tenant Next.js app: seat limits per plan, or seat-based pricing with Stripe. Trade-offs and code for both.

SShiftFast Team
Published on November 2, 2026
Seat Limits vs Per-Seat Pricing: Billing Organizations with Stripe in Next.js

When your customers are teams, billing has to account for how many people are on each team. There are two common ways to do it. A seat limit is a cap on how many members an organization's plan allows, with a flat price per plan. Per-seat pricing, also called seat-based pricing, is a price per member, where the bill grows or shrinks with the team. This guide explains both, when to use each, and how to build them in a Next.js app with Stripe and Clerk Organizations.

We make ShiftFast, a Next.js SaaS starter kit that uses seat limits, so the first half shows that approach as it works in ShiftFast. The second half shows how to add Stripe per-seat pricing, which ShiftFast doesn't include. API details were checked against Stripe's and Clerk's docs on 2 November 2026.

Key takeaways

  • Seat limits keep billing simple: one flat price per plan, with the app blocking invitations past the limit. Per-seat pricing ties revenue to team size but needs a sync between your member count and Stripe.
  • In Stripe, per-seat pricing is a recurring price with a quantity equal to the number of seats. Changing the quantity is prorated by default.
  • In Clerk, maxAllowedMemberships enforces a seat limit, and the organizationMembership.created and .deleted webhooks tell you when to update a per-seat quantity.
  • The two combine well: charge per seat, and use a membership limit as a cap.

What's the difference between seat limits and per-seat pricing?

Both connect team size to billing. They differ in what the customer pays for:

Seat limits per planPer-seat pricing
What the customer paysA flat price for the planA price per member, times the number of members
Stripe subscription quantityAlways 1The number of seats
When a member joinsNothing changes in Stripe, if under the limitThe quantity goes up, usually with a prorated charge
When a team outgrows the planThe customer upgrades to a higher planThe bill grows automatically
What your app must keep in syncThe plan's limit in your auth providerThe member count in Stripe
Best forSimple tiers ("Pro: up to 10 members")Products whose value grows with each user

Neither is more correct. Seat limits are easier to build and easier for customers to predict. Per-seat pricing captures more revenue from large teams, at the cost of more billing logic and invoices that change month to month.

Which model should you use?

Start with the question your customers ask when they buy:

  • "Which plan do we need?" Use seat limits. Customers compare a few tiers and pick one. Most early-stage B2B products fit here.
  • "How much for our team of 40?" Use per-seat pricing. When each additional user gets similar value, as in collaboration and productivity tools, pricing per seat matches how customers think about cost.
  • Both: a per-seat price with a minimum or maximum number of seats per plan. The last section shows how.

How do you set seat limits per plan?

This is how ShiftFast does it: each plan has a member limit, the price stays flat, and Clerk enforces the limit.

1. Give each plan a member limit

Store the limit next to the plan. In ShiftFast, maxMembers is the number of seats, and -1 means unlimited. The prices and limits below are examples:

export const BILLING_PLANS = [
  { id: 'free', name: 'Free', prices: {}, limits: { maxMembers: 1 } },
  {
    id: 'pro',
    name: 'Pro',
    prices: { month: { amount: 2900, priceId: 'price_...' } },
    limits: { maxMembers: 10 },
  },
]

2. Check out with a quantity of 1, scoped to the organization

The Stripe price is flat, so the quantity is always 1. Put the organization ID in the subscription's metadata, so every later webhook can be traced back to the right organization:

const session = await stripe.checkout.sessions.create({
  mode: 'subscription',
  customer: customerId,
  line_items: [{ price: priceId, quantity: 1 }],
  metadata: { orgId },
  subscription_data: { metadata: { orgId } },
  success_url: successUrl,
  cancel_url: cancelUrl,
})

3. Apply the limit in Clerk when the plan changes

When a Stripe webhook tells you an organization's plan changed, set its Clerk membership limit with maxAllowedMemberships. Clerk's docs say "0 means unlimited" (reference), so map your "unlimited" value to 0:

import { clerkClient } from '@clerk/nextjs/server'

export async function applyMemberLimit(orgId: string, maxMembers: number) {
  const clerk = await clerkClient()
  await clerk.organizations.updateOrganization(orgId, {
    maxAllowedMemberships: maxMembers === -1 ? 0 : maxMembers,
  })
}

Clerk then blocks invitations past the limit. Pending invitations count toward it, so a team at 9 of 10 with one pending invitation can't invite anyone else.

4. Handle downgrades that leave too many members

A downgrade can leave an organization with more members than its new plan allows. Clerk won't remove anyone, so decide what your app does. ShiftFast counts members and pending invitations after every plan change. If the count is over the limit, it locks the app's gated pages behind a "Too many members" screen until an admin removes members or upgrades:

const clerk = await clerkClient()
const [memberships, invitations] = await Promise.all([
  clerk.organizations.getOrganizationMembershipList({
    organizationId: orgId,
    limit: 1,
  }),
  clerk.organizations.getOrganizationInvitationList({
    organizationId: orgId,
    status: ['pending'],
    limit: 1,
  }),
])
const seatsUsed = memberships.totalCount + invitations.totalCount
const exceeded = limit !== -1 && seatsUsed > limit

Requesting limit: 1 keeps the call small, since you only need totalCount. Keep the organization settings reachable while locked, so an admin can fix it.

One Clerk limit to know: without its Enhanced B2B Authentication add-on, an organization can have at most 20 members (Clerk pricing), so an "unlimited" plan means 20 until you add it.

How do you add per-seat pricing with Stripe?

Stripe describes per-seat pricing as "a linear pricing model where the number of seats (for example, software licenses) maps to the number of units (for example, users)" (Stripe docs). You create a recurring price per seat and set the subscription's quantity to the number of seats.

1. Create a per-seat price and start the subscription with the team size

Create a recurring price in Stripe, for example 10 USD per seat per month. At checkout, set the quantity to the organization's current member count:

const clerk = await clerkClient()
const { totalCount: seats } =
  await clerk.organizations.getOrganizationMembershipList({
    organizationId: orgId,
    limit: 1,
  })

const session = await stripe.checkout.sessions.create({
  mode: 'subscription',
  customer: customerId,
  line_items: [{ price: perSeatPriceId, quantity: Math.max(seats, 1) }],
  metadata: { orgId },
  subscription_data: { metadata: { orgId } },
  success_url: successUrl,
  cancel_url: cancelUrl,
})

If you'd rather let customers choose how many seats to buy up front, Checkout supports adjustable_quantity on a line item. By default the minimum is 0 and the maximum is 99, and the maximum can go up to 999,999 (Stripe docs).

2. Keep the quantity in sync when members join or leave

Clerk sends organizationMembership.created and organizationMembership.deleted webhooks. Verify each one with Clerk's verifyWebhook, recount the members, and update the subscription item's quantity:

// app/api/webhooks/clerk/route.ts
import { clerkClient } from '@clerk/nextjs/server'
import { verifyWebhook } from '@clerk/nextjs/webhooks'

export async function POST(req: Request) {
  const evt = await verifyWebhook(req) // uses CLERK_WEBHOOK_SIGNING_SECRET

  if (
    evt.type === 'organizationMembership.created' ||
    evt.type === 'organizationMembership.deleted'
  ) {
    const orgId = evt.data.organization.id
    const subscriptionId = await getSubscriptionIdForOrg(orgId) // your database
    if (!subscriptionId) return new Response('ok')

    const clerk = await clerkClient()
    const { totalCount } =
      await clerk.organizations.getOrganizationMembershipList({
        organizationId: orgId,
        limit: 1,
      })

    const subscription = await stripe.subscriptions.retrieve(subscriptionId)
    await stripe.subscriptions.update(subscriptionId, {
      items: [
        {
          id: subscription.items.data[0].id,
          quantity: Math.max(totalCount, 1),
        },
      ],
      proration_behavior: 'create_prorations',
    })
  }

  return new Response('ok')
}

Two details matter here. First, recount instead of adding or subtracting 1: webhooks can arrive out of order or more than once, and a recount always lands on the right number. Second, keep the webhook route public. Clerk's docs warn to ensure the webhook route "isn't protected anywhere", because the request comes from Clerk, not a signed-in user (Clerk docs).

3. Choose how changes are billed

Changing a subscription item's quantity creates a proration by default. Stripe offers three options through proration_behavior (Stripe docs):

  • create_prorations (the default) adds prorated charges or credits to the next invoice.
  • always_invoice calculates the proration and invoices it immediately.
  • none skips prorations, so the new quantity is billed in full from the next invoice.

Most products use the default, so adding a member mid-month costs a partial seat on the next invoice. Use always_invoice if you want to collect right away, or none if you only bill whole periods.

Can you combine both?

Yes, and it's often the best option. Charge per seat in Stripe, and also set maxAllowedMemberships in Clerk as a cap, for example a plan that bills per seat up to 50 members, with larger teams moving to a contract. The cap stops an organization from growing past what its plan supports, and the per-seat quantity keeps the bill matched to the team.

Common pitfalls

  • Losing the organization ID. Stripe webhooks arrive with a customer or subscription ID. Store the organization ID in the subscription's metadata at checkout, so every event resolves to the right organization. Our guide to multi-tenant auth with Clerk Organizations covers why everything should be keyed by organization.
  • Counting pending invitations inconsistently. Decide whether an invitation uses a seat. Clerk counts pending invitations toward maxAllowedMemberships, so a per-seat count that ignores them can disagree with the limit.
  • Charging for zero seats. If an organization's only member leaves, a quantity of 0 may not be what you want. Keep a minimum of 1, as the examples above do.
  • Surprising customers. Per-seat bills change month to month. Show the seat count and the next charge in your billing page, and use Stripe's invoice preview before large changes.

Summary

Seat limits and per-seat pricing answer different questions. Seat limits give each plan a flat price and a member cap, enforced in Clerk with maxAllowedMemberships. Per-seat pricing charges for each member through a Stripe subscription quantity that you keep in sync from Clerk's membership webhooks. Many products end up combining the two.

ShiftFast ships the seat-limit model, including the downgrade lock described above; see the Billing docs. If you're choosing a starter kit and per-seat billing matters to you, our comparison of Next.js SaaS boilerplates notes which kits list it.