How to Set Up Per-Seat Pricing in Stripe: Complete Implementation Guide 2026

Per-seat pricing (also called per-user pricing) charges customers based on the number of users or seats in their account. If a team has 10 people using your app and your price is $15 per seat per month, they pay $150/month. Simple.

This model works really well when your product's value scales with team size. More users means more value delivered, so it makes sense to charge accordingly. It also gives you predictable, scalable revenue as your customers grow.

Ideal use cases for per-seat billing include team productivity apps (think project management or wikis), collaboration platforms, developer tools used by engineering teams, CRM and sales software, and any SaaS where individual logins are a core part of the experience.

Compared to flat-rate pricing, per-seat billing scales better with customer growth. Compared to usage-based pricing, it's more predictable for both you and your customers. The trade-off is that customers sometimes try to share accounts to avoid paying for more seats, so you'll want to think about how you enforce seat limits.

Once your product and price are configured in Stripe, you can create per-seat subscriptions programmatically. The key is the quantity parameter, which tells Stripe how many seats the customer is subscribing to.

Here's how to create a per-seat subscription in Node.js (using the stripe npm package):

const stripe = require('stripe')('sk_live_your_secret_key');

// Create a per-seat subscription
const subscription = await stripe.subscriptions.create({
  customer: 'cus_customer_id',
  items: [
    {
      price: 'price_your_price_id', // the price ID from your Stripe dashboard
      quantity: 5, // number of seats
    },
  ],
  trial_period_days: 14, // optional: 14-day free trial
});

console.log(subscription.id);

And here's the same thing in Python:

import stripe

stripe.api_key = 'sk_live_your_secret_key'

subscription = stripe.Subscription.create(
    customer='cus_customer_id',
    items=[
        {
            'price': 'price_your_price_id',  # price ID from Stripe dashboard
            'quantity': 5,  # number of seats
        },
    ],
    trial_period_days=14,  # optional
)

print(subscription['id'])

To update the seat count mid-subscription (for example, when a customer adds a new team member), use the subscription item update endpoint:

// Update seat count (Node.js)
const updatedSubscription = await stripe.subscriptions.update(
  'sub_subscription_id',
  {
    items: [
      {
        id: 'si_subscription_item_id',
        quantity: 8, // new seat count
      },
    ],
    proration_behavior: 'create_prorations', // handles mid-cycle charges
  }
);

The proration_behavior parameter is important here. We'll cover that in detail in the next section.

For webhook handling, listen for customer.subscription.updated events to sync seat changes back to your app:

// Webhook handler (Node.js / Express)
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['stripe-signature'];
  let event;

  try {
    event = stripe.webhooks.constructEvent(req.body, sig, 'whsec_your_webhook_secret');
  } catch (err) {
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  if (event.type === 'customer.subscription.updated') {
    const subscription = event.data.object;
    const quantity = subscription.items.data[0].quantity;
    // Update seat count in your database
    console.log(`Seats updated to: ${quantity}`);
  }

  res.json({ received: true });
});

Pro-rating is how Stripe handles billing fairly when a customer changes their seat count in the middle of a billing cycle.

For example: if a customer is on a $15/seat/month plan with 5 seats and adds 3 more seats halfway through the month, they shouldn't pay the full price for those 3 new seats since they're only using them for half the month. Stripe automatically calculates the prorated amount and adds it to the next invoice.

You control this behavior with the proration_behavior parameter when updating a subscription:

- create_prorations (default): Stripe creates a prorated credit or charge on the next invoice.
- none: No proration is applied. The new quantity takes effect at the next billing period.
- always_invoice: Stripe immediately creates a new invoice for the prorated amount.

For most SaaS products, create_prorations is the right default. Customers get charged fairly, and you collect revenue for the actual usage.

When a customer removes seats, Stripe issues a prorated credit that gets applied to their next invoice. If you want to issue a refund instead, you'll need to handle that manually via the Stripe Dashboard or the Refunds API.

A few best practices for handling seat changes:

- Notify customers via email when their seat count (and bill) changes.
- Show a preview of the prorated charge before the customer confirms the change.
- Use Stripe's retrieveUpcomingInvoice endpoint to calculate and display the prorated cost before applying it.

// Preview prorated cost before applying change (Node.js)
const upcomingInvoice = await stripe.invoices.retrieveUpcoming({
  customer: 'cus_customer_id',
  subscription: 'sub_subscription_id',
  subscription_items: [
    {
      id: 'si_subscription_item_id',
      quantity: 8,
    },
  ],
});

console.log('Proration amount due:', upcomingInvoice.amount_due);

Once you've got basic per-seat billing working, you can tackle more complex setups.

Tiered (volume) pricing lets you offer discounts as seat counts grow. In Stripe, you set up tiered pricing on the price object. For example: $20/seat for seats 1-10, $15/seat for seats 11-50, $10/seat for 51+. Stripe handles the tier calculation automatically based on the quantity at billing time.

Per-seat with add-ons means attaching multiple price items to a single subscription. A customer might have a base per-seat price plus an add-on price for a premium feature. Both items appear on the same invoice.

// Subscription with base per-seat + add-on (Node.js)
const subscription = await stripe.subscriptions.create({
  customer: 'cus_customer_id',
  items: [
    { price: 'price_base_per_seat', quantity: 10 }, // 10 seats at base price
    { price: 'price_addon_feature', quantity: 1 },  // flat add-on
  ],
});

Enterprise seat licensing often involves negotiated pricing. You can handle this in Stripe by creating custom prices for specific customers, or by using coupons to apply agreed-upon discounts.

Team vs. seat counts can get nuanced when organizations have sub-teams. One approach: count total active users at the organization level and bill accordingly. Another: allow each team to have its own subscription. The right approach depends on your product's structure.

Seat-based feature gating means your app unlocks features based on the number of seats purchased. Stripe doesn't enforce this in your app directly; you'll track the seat count from your database (synced via webhooks) and gate features on your side.

Here are the things that trip people up most often with per-seat Stripe implementations.

Here are three concrete examples of how per-seat pricing works in practice, with actual numbers.

Use this simple formula to project monthly recurring revenue (MRR) from your per-seat model:

MRR = (Number of customers) x (Average seats per customer) x (Price per seat)

For example, if you have 50 customers averaging 8 seats at $15/seat:

MRR = 50 x 8 x $15 = $6,000/month

As customers grow their teams, your MRR grows with them without any additional sales effort. This is why per-seat pricing creates natural expansion revenue, making it a strong model for B2B SaaS products with collaborative workflows.