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.

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
quantityequal to the number of seats. Changing the quantity is prorated by default.- In Clerk,
maxAllowedMembershipsenforces a seat limit, and theorganizationMembership.createdand.deletedwebhooks 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 plan | Per-seat pricing | |
|---|---|---|
| What the customer pays | A flat price for the plan | A price per member, times the number of members |
| Stripe subscription quantity | Always 1 | The number of seats |
| When a member joins | Nothing changes in Stripe, if under the limit | The quantity goes up, usually with a prorated charge |
| When a team outgrows the plan | The customer upgrades to a higher plan | The bill grows automatically |
| What your app must keep in sync | The plan's limit in your auth provider | The member count in Stripe |
| Best for | Simple 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 > limitRequesting 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_invoicecalculates the proration and invoices it immediately.noneskips 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.