Licensing & Monetization

The commercial engine your SaaS infrastructure needs.Built into the control plane.

Licenses, add-ons, prices and vouchers: four primitives that turn your commercial contracts into infrastructure rules. Kaiten composes each invoice from them and from the usage it accepted; Stripe taxes, sends and collects it, or your own accounting system takes it from a queue. Billing stays provider-agnostic by design.

The Problem

Your licensing service is quietly killing you.

Every B2B SaaS ends up having the same conversation: "We need to let the AE grant a temporary Pro access." Then: "+2 extra seats for this deal." Then: "Turn on the beta dashboard for Acme for 6 months." Three tickets, three deploys, three ways to break production.

Hardcoded plans

if (plan === 'enterprise') scattered across your codebase. Every pricing change requires a deploy. Every negotiated contract becomes a code exception.

Coupons that only discount

A billing coupon gives you -20%. It can't grant 500 extra API calls. It can't turn on a feature flag. So your team writes custom code for every negotiated deal.

Vendor lock-in

Entitlements tied to one billing provider make every provider change a rewrite of your monetization stack. You're paying for lock-in, not flexibility.

The Kaiten Way

Four primitives. One unified model.

Kaiten's licensing model is built into the control plane — not bolted on. All four ship today, on one model, versioned and audited: licenses are queryable through the API, the SDKs and the MCP server, and add-ons, prices and vouchers through the API, the console and the MCP server.

01

License

The Kaiten plan

The commercial contract as code, and it ships today. Types: DEVELOPMENT, TRIAL, PAID, COMMUNITY. Each license is a numbered version of a product: publish a new version and existing customers stay on theirs until you move them. Grants entitlements — on/off features, quotas, AI credits and JSON config.

license.name = "Pro"
license.type = PAID
license.version = "3"
license.lifecycleState = PUBLISHED
02

Add-on

Modular extensions

Add-ons mirror the license structure: versioned, with their own entitlements and prices, and held by an instance in a quantity — attached when it subscribes, later from the console or the API, or bought by the customer from your portal. An overrideBehavior (ADD, OVERRIDE, MAX) decides how an add-on's quotas combine with the license — "+5 delivery drivers" ADDs, "unlimited drivers" OVERRIDEs.

addon.name = "Extra delivery drivers"
addon.maxQuantity = 10
entitlement.overrideBehavior = ADD
instance.addon.quantity = 2
03

Price

3 shapes, 2 timings

Native pricing on every license version, in three shapes — a flat fee per period, a usage-based price from the first unit, an overage price above the grant — billed in advance or in arrears, monthly to yearly. One version carries several, with a default for each period, and a published price never changes under what it bills.

price.billingModel = OVERAGE
price.billingTiming = ARREARS
price.metered.entitlementSlug = "monthly-orders"
price.unitAmountDecimal = "50"
04

Voucher

Beyond coupons

Four types — PRICE (discount), ENTITLEMENT_BOOST (modify quotas), FLAG_GRANT (activate a feature flag), COMPOSITE (combine all three). One voucher acts on price, quotas and flags at once, so Sales can negotiate a whole deal package in one instrument — redeemed by your backend, or by the customer from your portal.

voucher.voucherType = COMPOSITE
voucher.priceDiscountType = PERCENTAGE
voucher.priceDiscountValue = 30
voucher.durationInPeriods = 12

Voucher Types

The commercial instrument your Sales team always needed.

A voucher that acts on three dimensions at once — price, entitlement limits and feature flag access. One code replaces three tickets.

PRICE

Classic discount

Percentage or fixed amount off the price. Duration: one-time, repeating for N periods, or forever. Kaiten applies it to the lines it composes; on Stripe, each discount reaches the invoice as a one-off coupon.

Example

code: "WELCOME20"
discount: -20% FOREVER
ENTITLEMENT_BOOST

Modify quotas

Multiply, add, set, or lift the limit on an entitlement value for a duration. Perfect for onboarding: give 2x quotas for the first 3 months to reduce activation friction.

Example

code: "SUMMER_BOOST"
api-calls: MULTIPLY x2
duration: 3 months
FLAG_GRANT

Feature flag activation

Temporarily turn on a feature flag for a customer — without reassigning them to a different plan. Ideal for beta access, Sales-negotiated early access, or support overrides.

Example

code: "BETA_DASH"
flag: new-dashboard = true
expires: 2026-12-31
COMPOSITE

Big deal combo

Combine the three. For enterprise negotiations: "-30% + quotas ×2 + white-label flag on for 12 months." One voucher code, full audit trail, clean lifecycle.

Example

code: "ACME_2026"
discount: -30% 12mo
quotas: x2
flag: white-label
Native Billing

Kaiten writes the invoice. Your provider collects it.

Kaiten doesn't replace your billing provider. It composes each invoice — every line, quantity and amount — from the contract it enforces and the usage its gate accepted, and pushes it to Stripe, which taxes, sends and collects it. Kaiten then reads the invoice back and reconciles it to the cent.

With no provider at all, the same invoices wait in a handoff queue for your accounting system to claim, book and acknowledge. Lago, Chargebee or others follow, depending on the roadmap. And the event stream stays the open seam: every accepted usage report, license change and invoice commits an event through the transactional outbox.

Native billing with Stripe or your own accounting system today · Lago, Chargebee or others depending on the roadmap

Your commercial team

Kaiten Licensing Model

Licenses · Add-ons · Prices · Vouchers

Invoices, composed by Kaiten
Stripe
Your ERP
More to come
Your Customer’s Side

One contract, from the pricing page to the invoice.

A restaurant buys a license on Kaiten Sushi Shop’s site, with no account and no sales call, reaches a limit, adds delivery drivers from its portal and finds its invoices there — while the vendor’s console follows every step.

React SDK

Your plan UI and paywalls, as React components.

Prebuilt React components for pricing tables, checkouts, customer portals, usage meters and paywalls, on a headless core you can also use alone. The paywall checks an entitlement and a feature flag in one gate.

Prebuilt, or headless.

@kaitencloud/react-ui draws the components — PricingTable, CheckoutFlow, CustomerPortal, UsageMeters, Paywall, PlanBadge and more — with every style scoped under one root, so none of it reaches the rest of your app. @kaitencloud/react is the headless core underneath: the provider, the hooks and a Gate, for teams who draw in their own design system.

Signed in, the provider reads one customer's license, entitlements, usage and flags from your Kaiten API, and reads them again every five minutes. The pricing table reads your public catalog with a publishable key, the checkout sells a license to a customer you know or to a visitor with no account, and the portal shows the customer its limits, add-ons and invoices. Both packages are on npm, and their code is open source in kaitencloud/sdk-js.

npm install @kaitencloud/react-ui · Open source in kaitencloud/sdk-js · Vue, Svelte and Angular on the roadmap

@kaitencloud/react-ui
import { KaitenProvider, KaitenStyleRoot, Paywall }
  from "@kaitencloud/react-ui";
import "@kaitencloud/react-ui/styles.css";

function App() {
  return (
    <KaitenProvider
      mode="authenticated"
      apiUrl="https://app.kaiten.sh/api"
      accessToken={getSessionToken} // called on every request
      customerId="cust_123"
      instanceId="inst_456"
    >
      <KaitenStyleRoot>
        {/* One gate: the entitlement's usage AND the flag */}
        <Paywall
          entitlement="api-calls"
          flagKey="premium-feature"
          threshold={0.8}
          onUpgrade={(action) => openUpgrade(action?.type)}
        >
          <ApiPlayground />
        </Paywall>
      </KaitenStyleRoot>
    </KaitenProvider>
  );
}

Domain Events

Every change. Fully audited. Stream-ready.

Licenses, their families and their prices emit 15 of the 117 event types Kaiten publishes as webhook contracts; usage reports emit the signals billing listens to, and subscriptions, invoices, add-ons and vouchers emit their own. Each event is committed through a transactional outbox, in the same transaction as the change, then carried by the event pipeline to the audit trail and, on Kaiten Cloud, to your webhook endpoints.

Event nameDescriptionType
LICENSE_CREATEDNew license createdcreate
LICENSE_UPDATEDLicense details updatedupdate
LICENSE_DELETEDLicense deleteddelete
LICENSE_PUBLISHEDLicense version publishedlifecycle
LICENSE_ARCHIVEDLicense version archived; instances on it keep itlifecycle
LICENSE_UNARCHIVEDArchived license version back in uselifecycle
LICENSE_FAMILY_CREATEDA product opened by its first versioncreate
LICENSE_FAMILY_UPDATEDThe version a product serves changedupdate
LICENSE_FAMILY_DELETEDA product closed with its last versiondelete
LICENSE_ENTITLEMENT_ASSIGNEDEntitlement granted by a licenseassign
LICENSE_ENTITLEMENT_UPDATEDGrant's value or overage allowance changedupdate
LICENSE_ENTITLEMENT_UNASSIGNEDEntitlement no longer granted by a licenseunassign
LICENSE_PRICE_CREATEDPrice added to a license versioncreate
LICENSE_PRICE_UPDATEDPrice of a draft version editedupdate
LICENSE_PRICE_DEPRECATEDPrice retired; what it already bills keeps billinglifecycle
INSTANCE_ENTITLEMENT_USAGE_WARNING_THRESHOLD_REACHEDUsage crossed the entitlement's early-warning percentageusage
INSTANCE_ENTITLEMENT_CAP_EXCEEDEDUsage went past a soft-limit grant, within its allowanceusage
ENTITLEMENT_USAGE_REPORT_ACCEPTEDUsage report recorded, overage includedusage
ENTITLEMENT_USAGE_REPORT_REJECTEDUsage report refused with a 409; usage left unchangedusage

The 19 events above are 19 of the 117 webhook contracts. The other 98, and the payload schema of every one, are in the OpenAPI document. See the full API reference.

Pairs naturally with the rest of Kaiten.

FAQ

Licensing and billing, in the words teams search for.

How do I change my plans without breaking existing customers?
Publish a new license version. Versions are numbered, and every instance stays on the version it was sold until you move it: new customers get the new packaging while existing ones keep their price and their grants. A subscription that already bills a version keeps it until its next billing boundary.
What is a license version?
A license is one version of a product in a license family: its entitlements, its prices and its type — development, trial, paid or community. A family can name a default version, the one the public catalog lists and the one an instance falls back to when a subscription ends.
How do I handle negotiated terms for one customer?
On the contract object, without a new plan or a deployment: a per-instance exception for a limit that differs for a time, an add-on for a capability sold on top of the license, a voucher for a discount, a temporary quota boost or a feature switched on. Each is dated, and each is in the audit trail.
What can a voucher do?
Four things: cut a price, raise a quota for a period, switch a feature flag on, or combine the three in one code. The customer redeems it, the effect is dated and audited, and the invoice reflects it.
Who composes the invoice?
Kaiten does, from the license, the usage and the vouchers it already knows: activation, renewal and final invoices, one subscription per instance. Stripe numbers, taxes, sends and collects them; without a provider, your accounting system takes each invoice from the handoff queue.

Stop hardcoding plans.
Start enforcing contracts.

Licenses, the entitlements they grant and native billing are in the open-source engine and in every Kaiten Cloud tier — Kaiten Cloud is in private beta.