The Subscrio entitlement library is open source and free to use. The Server App is a commercial add-on with a web console and REST API. Licensing details are on the Admin page.

Documentation lives at docs.subscrio.com. Source code is on GitHub at github.com/jasenf/subscrio.

Is Subscrio a billing system or feature-flag tool?

Neither. It is not feature flags for gradual rollouts and not a billing system for processing payments. It is the entitlement layer between them that knows what each customer can access.

The Entitlement Engine

Subscrio manages each user's subscription and entitlement profile.

Open source. Free to use.

Every time a user clicks a button, creates a resource, or calls an API endpoint, your application asks: "Is this customer allowed to do this?" Subscrio is the definitive answer.

Read the Docs View on GitHub

The hard way vs Subscrio

Eliminate 1,000s of lines of customer subscription management business logic.

You're probably doing subscription management with scattered conditional statements across dozens of files, checking plan names and hardcoding feature limits.

The hard way users.ts

let sub = await db.subscriptions.findOne({
  customerId: customer.id
});

if (!sub) {
  sub = await db.subscriptions.create({
    customerId: customer.id,
    plan: "default"
  });
}

// scattered across dozens of files
if (sub.cancelled) {
  throw new Error("User limit reached");
}

if (sub.expiresAt < Date.now()) {
  throw new Error("User limit reached");
}

if (sub.trialEndsAt && sub.trialEndsAt < Date.now()) {
  throw new Error("User limit reached");
}

if (customer.plan === "pro"
  || customer.plan === "enterprise") {
  if (userCount >= 10) {
    throw new Error("User limit reached");
  }
}

With Subscrio users.ts

const maxUsers = await subscrio.featureChecker
  .getValueForCustomer(
    customer.key, "my-application", "max-users", 0
  );

if (userCount >= maxUsers) {
  throw new Error("User limit reached");
}

await addUser();

getValueForCustomer automatically

Finds the subscription
Creates a default one if none exists
Checks if cancelled
Checks if expired
Checks for trial
Checks feature for admin override value
Auto-syncs with Stripe

You'll also maintain

Wiring and translating all Stripe webhook events (est. 1,200 lines of code)
Background processes for migrating dead subscriptions (est. 400 lines of code)
Failed payment dunning and access revocation (est. 600 lines of code)
Mid-cycle upgrades, downgrades, and proration (est. 800 lines of code)
Seat/usage sync and overage enforcement (est. 500 lines of code)

The Problem You're Solving

Right now, you have two disconnected systems, and lots of embedded business logic scattered throughout your app. This creates massive problems:

Who translates "Pro Plan" into actionable permissions throughout your app?
Change a plan? Requires code deployment
Custom deals? Engineers build one-off override logic
Multiple products? Conditional statements become unmaintainable
Sales flexibility? Product team can't experiment without engineering
Vendor lock-in? You're forced to parse your billing system's data structures

The Solution

Subscrio is the entitlement layer your application is missing.

It's not feature flags for gradual rollouts. It's not a billing system for processing payments. It's the authoritative system between them that knows exactly what each customer is entitled to access.

How It Works

Define Your Business Model (Once)

Configure products, features, and plans through a simple API. Set up your business model once and let Subscrio handle the complexity.

Config sync config.json

{
  "version": "1.0",
  "features": [
    {
      "key": "max-users",
      "displayName": "Maximum Users",
      "valueType": "numeric",
      "defaultValue": "0"
    },
    {
      "key": "advanced-reports",
      "displayName": "Advanced Reports",
      "valueType": "toggle",
      "defaultValue": "false"
    }
  ],
  "products": [
    {
      "key": "my-application",
      "displayName": "My Application",
      "features": ["max-users", "advanced-reports"],
      "plans": [
        {
          "key": "basic",
          "displayName": "Basic Plan",
          "featureValues": {
            "max-users": "5",
            "advanced-reports": "false"
          }
        },
        {
          "key": "pro",
          "displayName": "Pro Plan",
          "featureValues": {
            "max-users": "10",
            "advanced-reports": "true"
          }
        }
      ]
    }
  ]
}

Enforce Entitlements Throughout Your App

Query feature values for customers in real-time. Check limits, permissions, and access rights without hardcoded conditional logic.

Business Teams Control Configuration

Sales teams can grant custom overrides, product teams can experiment with new plans, and customer success can handle exceptions—all without requiring engineering deployments.

Key Features

Feature Resolution

Each access check walks override, then subscription, then plan, then default. The first match is the answer.

Products, Features, and Plans

Define the catalog in config or in code. Products own features; plans set the values a customer gets.

Customer Management

Find an account, see every subscription on it, and inspect what that customer can access.

Business Flexibility

Change a plan or grant an exception on a live account without shipping a new build.

Override System

Grant or revoke a feature on one subscription until the next renewal, without changing the plan.

Billing System Integration

Stripe is included. Forward webhook payloads to the library and subscriptions stay in sync with payment events.

Type Safety

Feature keys and plan values are checked at compile time in TypeScript and C#.

Status Calculation

Active, trial, and expired are computed from dates at read time, so you do not store a stale status flag.

Subscription Transitions

Upgrades and downgrades follow billing-cycle boundaries instead of cutting access mid-period.

Multiple Subscriptions

One customer can hold several active subscriptions, including across products, each with its own entitlements.

Trial Support

Trial start and end dates are first-class. Access follows the trial window without extra status logic.

Zero Configuration

Sensible defaults cover the common case, so you can check entitlements without wiring a custom policy layer first.

Extensible Hooks

Run your own code before and after create, update, and delete, for mail, audits, or calls to other systems.

Auto-Downgrade on Expiration

When a paid period ends, you can drop the customer to a lower plan automatically instead of leaving paid access open. This is optional.

Database Agnostic

PostgreSQL is supported in both stacks. The .NET library also works with SQL Server.

Why Subscrio Wins

vs. Building In-House

Saves 120+ hours of development
Production-tested with audit trails
No technical debt as your business model evolves

vs. Feature Flags

LaunchDarkly, Split

Feature flags roll out new code gradually
Subscrio manages what customers paid for and can access
Different problems, different solutions

vs. Billing Systems

Stripe, Paddle

Billing handles payments and invoices
Subscrio translates subscriptions into feature entitlements
Tightly integrated, not competing

Core Concepts

Entity relationship diagram of Features, Products, Plans, Billing Cycles, Subscriptions, and Customers

Open Source Library

Free

The Subscrio entitlement library is open source and free to use. Embed it in your stack, define your business model once, and enforce entitlements in code.

TypeScript

Full-featured TypeScript/Node.js implementation

subscrio

.NET

C#/.NET implementation with Entity Framework Core

Subscrio.Core

Extend the engine with hooks instead of forking it. An audit log extension ships out of the box: subscrio-audit-log and Subscrio.AuditLog.

Star on GitHub Read the Docs

Frequently Asked Questions

The Subscrio entitlement library is open source and free to use. The Server App is a commercial add-on: a web console and REST API. Licensing details are on the Admin page.

TypeScript/Node.js (subscrio) and C#/.NET (Subscrio.Core) are available today.

Documentation lives at docs.subscrio.com. Source code is on GitHub.

Neither. It's not feature flags for gradual rollouts. It's not a billing system for processing payments. It's the authoritative entitlement layer between them that knows exactly what each customer is entitled to access.

Start with the entitlement engine

Use the open-source library today, or license the Server App when you want a web console for the same catalog.

Read the Docs View on GitHub Get Admin