Complete guide to implementing user-based pricing models with automatic seat tracking, tiered pricing, and flexible billing rules.

Seat-Based Pricing

Seat-based pricing allows you to charge customers based on the number of users, seats, or licenses they have active in their account. This model is perfect for team collaboration tools, SaaS platforms, and enterprise software where value scales with team size.

Platform documentation aims at business operators. For SDKs, endpoints, and code samples head to the Developer Library Quick Start.

Why seat-based pricing

Seat-based pricing creates predictable revenue while aligning costs with customer team growth. As teams expand, revenue grows proportionally, making it one of the most popular SaaS pricing models.

Problems it solves:

Unpredictable revenue from usage-only models
Complex capacity planning for unlimited user access
Difficulty pricing multi-user products fairly
Tracking who's using your product and how much
Managing enterprise contracts with minimum commitments

Business outcomes:

Predictable monthly recurring revenue (MRR)
Revenue scales automatically with customer growth
Clear pricing that's easy to understand and forecast
Flexible seat management with minimums and overages
Enterprise-ready with tiered volume discounts

How seat-based pricing works

┌─────────────────┐
│  User Management│  Admin adds/removes team members
│                 │  (Slack, GitHub, Notion, etc.)
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Seat Balance   │  Real-time tracking of active seats
│                 │  { customer, seatType, quantity }
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Pricing Engine │  Applies seat-based pricing model
│                 │  (Linear, Tiered, with minimums)
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Invoice        │  "20 seats × $50 = $1,000"
│                 │  + prorated additions if mid-cycle
└─────────────────┘

1. Define seat types

Create different seat types for various user roles:

// Example: Different seat types by role
{
  id: "admin-seat-uuid",
  name: "Admin Seat",
  key: "admin_seat",
  description: "Full platform access with admin privileges"
}

{
  id: "editor-seat-uuid",
  name: "Editor Seat",
  key: "editor_seat",
  description: "Content creation and editing access"
}

{
  id: "viewer-seat-uuid",
  name: "Viewer Seat",
  key: "viewer_seat",
  description: "Read-only access"
}

2. Configure seat pricing

Set up pricing for each seat type:

// Linear pricing: $50 per admin seat
{
  pricingModel: "per_unit",
  unitAmount: 5000,         // $50 per seat
  currency: "USD",
  billingInterval: "monthly",
  billInAdvance: false,     // Arrears (charge at end)
  quantitySource: "seat_balance",
  seatTypeId: "admin-seat-uuid"
}

3. Automatic seat tracking

Commet tracks seat changes in real-time:

Seat additions: Automatically prorated for mid-cycle adds
Seat removals: Applied at next billing cycle or immediately
Seat balance: Current count of active seats per type
History: Audit trail of all seat changes

4. Billing automation

Invoices are generated automatically:

Admin Seats
20 seats × $50.00 = $1,000.00

Editor Seats
5 seats × $30.00 = $150.00

Total: $1,150.00

Seat-based pricing models

Linear seat-based pricing

Same price per seat regardless of quantity. Simple and predictable.

{
  pricingModel: "per_unit",
  unitAmount: 5000,         // $50 per seat
  currency: "USD",
  billingInterval: "monthly",
  billInAdvance: false,     // Arrears
  quantitySource: "seat_balance",
  seatTypeId: "standard-seat-uuid"
}

// 20 seats × $50 = $1,000
// 100 seats × $50 = $5,000

Real-world examples:

Figma: $15/editor/month (flat rate)
Notion: $10/user/month (flat rate for Plus)
Linear: $8/user/month (flat rate)

When to use:

Simple, transparent pricing needed
No volume discount strategy
Small to medium team sizes (< 50 users)
Want to keep pricing straightforward

Graduated seat-based pricing

Price per seat decreases as quantity increases, rewarding larger teams.

{
  pricingModel: "tiered",
  tierType: "graduated",
  quantitySource: "seat_balance",
  seatTypeId: "enterprise-seat-uuid"
}

// Tiers configured separately
price_variant_tier: [
  {
    tierOrder: 1,
    upTo: 15,
    unitAmount: 5000,       // First 15 seats @ $50
    flatFee: 0
  },
  {
    tierOrder: 2,
    upTo: 50,
    unitAmount: 4000,       // Next 35 seats @ $40
    flatFee: 0
  },
  {
    tierOrder: 3,
    upTo: null,             // 50+ seats
    unitAmount: 3000,       // @ $30
    flatFee: 0
  }
]

Calculation example for 60 seats:

Tier 1: 15 seats × $50 = $750
Tier 2: 35 seats × $40 = $1,400
Tier 3: 10 seats × $30 = $300
────────────────────────────
Total: $2,450/month

Real-world examples:

Slack: Volume discounts for larger teams
GitHub: Enterprise pricing scales with seats
Salesforce: Progressive per-user pricing

When to use:

Targeting enterprise customers
Want to incentivize team growth
Competitive in large team market
Need volume discount strategy

Seat pricing with contracted minimums

Guarantee minimum seats billed, charge for overages.

// Agreement configuration
{
  minimumSeats: 50,         // Contracted minimum
  actualSeats: 45,          // Current usage
  billedSeats: 50           // Bill for minimum
}

// Next month if seats grow
{
  minimumSeats: 50,
  actualSeats: 65,          // Grew beyond minimum
  billedSeats: 65           // Bill for actual (overage)
}

How it works:

Scenario	Minimum	Actual	Billed	Calculation
Under minimum	50	35	50	50 × $50 = $2,500
At minimum	50	50	50	50 × $50 = $2,500
Over minimum	50	75	75	75 × $50 = $3,750

Real-world examples:

Enterprise contracts: "Minimum 100 seats commitment"
Annual deals: Guaranteed minimums for discount
Volume agreements: "Minimum $10K/month spend"

When to use:

Enterprise sales contracts
Annual commitments with discounts
Guaranteed revenue minimums
Protect against seat fluctuation

Billing timing: Advance vs Arrears

Arrears billing (charge at end)

Charge for seats used during the previous billing period.

{
  billInAdvance: false      // Arrears
}

How it works:

March 1-31: Customer uses 20 seats
April 1: Invoice generated for March usage
Customer billed: 20 × $50 = $1,000

Advantages:

Charge for actual usage
Fair for customers adding/removing seats
No refunds needed for seat removals
Easier to explain "you pay for what you used"

Use cases:

Monthly seat fluctuations expected
Trial/onboarding periods
Startups with changing team sizes

Advance billing (charge upfront)

Charge for seats for the upcoming billing period.

{
  billInAdvance: true       // Advance
}

How it works:

March 1: Invoice for March 1-31 usage
Customer pre-pays: 20 × $50 = $1,000
March 1-31: Customer uses the pre-paid seats

Advantages:

Predictable cash flow
Revenue recognized upfront
Reduces churn (prepaid = commitment)
Standard SaaS practice

Use cases:

Stable enterprise teams
Annual contracts
SaaS standard practice
Need cash flow predictability

Proration for mid-cycle changes

Adding seats mid-cycle

When seats are added during a billing period, customers are charged a prorated amount.

Example: Monthly billing, arrears

Billing period: March 1-31 (31 days)
Starting seats: 10 @ $50/seat

March 15: Add 5 seats (17 days remaining)

Calculation:
- Original 10 seats: 31 days × $50 = $500
- New 5 seats: 17/31 days × $50 × 5 = $137.10
- Total March invoice: $637.10

Proration formula:

proratedAmount = (daysRemaining / totalDays) × seatPrice × seatsAdded

// Admin seats: Full access
{
  seatTypeId: "admin-seat",
  unitAmount: 10000        // $100/seat
}

// Editor seats: Content access
{
  seatTypeId: "editor-seat",
  unitAmount: 5000         // $50/seat
}

// Viewer seats: Read-only
{
  seatTypeId: "viewer-seat",
  unitAmount: 1000         // $10/seat
}

Real-world examples:

Figma: Editors ($15) vs Viewers (free)
Miro: Full members vs Guests
Notion: Members vs Guests pricing

When to use:

Clear value difference between roles
Want to monetize all user types
Encourage wider adoption with cheap viewers
Complex permission systems

Strategy 2: Hybrid seat + usage

Combine seat-based baseline with usage overages.

// Base: Seat pricing
{
  seatTypeId: "developer-seat",
  unitAmount: 5000,        // $50/seat
  includedUsage: 10000     // 10K API calls included per seat
}

// Overage: Usage pricing
{
  pricingModel: "per_unit",
  unitAmount: 100,         // $0.01/call for overages
  usageMetricId: "api-calls"
}

Example billing:

10 Developer Seats × $50 = $500/month
Included: 100K API calls (10K per seat)

Actual usage: 150K calls
Overage: 50K × $0.01 = $500

Total: $500 (seats) + $500 (overage) = $1,000

When to use:

Usage varies significantly per user
Want predictable base + flexible ceiling
Avoid bill shock from pure usage pricing
Common in API platforms, infrastructure

Strategy 3: Tiered plans with seat limits

Fixed plans with included seat ranges.

Starter Plan: $99/month
├── Up to 5 seats included
└── $20 per additional seat

Professional Plan: $299/month
├── Up to 20 seats included
└── $15 per additional seat

Enterprise Plan: Custom pricing
├── Unlimited seats
└── Volume discounts available

When to use:

Want simple plan tiers
Packaging strategy (good-better-best)
Small teams prefer all-inclusive pricing
Reduce pricing complexity

Seat management best practices

Tracking seat usage

Automatic sync from your app:

// Add seat
await commet.seats.add({
  customerId: "customer-uuid",
  seatTypeId: "admin-seat-uuid",
  userId: "user-123",
  email: "john@acme.com",
  effectiveDate: new Date()
});

// Remove seat
await commet.seats.remove({
  customerId: "customer-uuid",
  seatId: "seat-uuid",
  effectiveDate: new Date()  // or future date
});

// Get current balance
const balance = await commet.seats.getBalance({
  customerId: "customer-uuid",
  seatTypeId: "admin-seat-uuid"
});
// Returns: { quantity: 20, lastUpdated: "2025-01-15" }

Customer transparency

Real-time seat dashboards:

Show current seat count vs contracted minimum
Display cost per seat and total monthly cost
Preview impact of adding/removing seats
Show proration calculations before confirming

Seat usage alerts:

Notify when approaching contracted minimum
Alert when adding seats mid-cycle (proration warning)
Remind before billing cycle for seat optimization

Governance and controls

Seat limits:

{
  minimumSeats: 10,        // Contract minimum
  maximumSeats: 100,       // Hard cap (optional)
  currentSeats: 45,        // Actual usage
  allowOverages: true      // Can exceed minimum
}

Approval workflows:

Require admin approval for seat additions
Finance approval for overages beyond threshold
Automatic notifications for seat changes

Troubleshooting seat-based billing

Issue	Cause	Solution
Seats not appearing on invoice	Seat added after period close	Ensure seats added before billing cycle ends
Proration incorrect	Wrong effective date	Verify seat addition date is accurate
Billed for removed seats	Seats not removed in system	Audit seat balance vs active users
Customer disputes seat count	Mismatch between app and billing	Implement daily seat sync reconciliation
Minimum not enforced	Agreement configuration missing	Check agreement has minimumSeats set
Overage charges unexpected	Customer unaware of minimums	Display seat limits in customer dashboard

Real-world examples by industry

SaaS Collaboration Tools

Example: Project management platform

Product: "TaskFlow Pro"

Seat Types:
├── Admin Seat: $50/month (unlimited projects)
├── Member Seat: $30/month (assigned projects only)
└── Guest Seat: $10/month (view-only, limited projects)

Pricing Strategy:
- Graduated tiers: 1-15 seats (full price), 16-50 (10% off), 51+ (20% off)
- Annual discount: 20% off when billed annually
- Minimum: Enterprise contracts require 25 seat minimum

Developer Tools

Example: API development platform

Product: "DevTools API Platform"

Seat Types:
├── Developer Seat: $99/month
│   ├── Included: 100K API calls/month
│   ├── Included: 5 projects
│   └── Overage: $0.01/call beyond included

Pricing Strategy:
- Hybrid: Seat-based + usage overages
- Team discounts: 10+ seats get 15% off
- Arrears billing: Charge for actual seats used

Enterprise Software

Example: CRM platform

Product: "SalesPro CRM"

Plans:
├── Starter: $25/user/month (up to 10 users)
├── Professional: $75/user/month (11-100 users)
└── Enterprise: Custom pricing (100+ users)

Features:
- Volume discounts on Professional (10% off 50+ seats)
- Annual contracts: Minimum 50 seats, 25% discount
- Advance billing: Lock in pricing for 12 months

Seat-Based Pricing

Seat-Based Pricing

Why seat-based pricing

How seat-based pricing works

1. Define seat types

2. Configure seat pricing

3. Automatic seat tracking

4. Billing automation

Seat-based pricing models

Billing timing: Advance vs Arrears

Arrears billing (charge at end)

Advance billing (charge upfront)

Proration for mid-cycle changes

Adding seats mid-cycle

Removing seats mid-cycle

Common seat-based pricing strategies

Strategy 1: Role-based seat pricing

Strategy 2: Hybrid seat + usage

Strategy 3: Tiered plans with seat limits

Seat management best practices

Tracking seat usage

Customer transparency

Governance and controls

Troubleshooting seat-based billing

Real-world examples by industry

SaaS Collaboration Tools

Developer Tools

Enterprise Software

On this page