Enable, disable, and meter individual product features with LicenseSpring's licensing infrastructure. Grant customers access to specific modules, track feature usage, and enforce consumption limits without building custom entitlement logic from scratch.
ISO 27001
Trusted by global software vendors
Developer-first APIs & SDKsMost software products contain multiple modules, tiers, or premium capabilities. Feature-based licensing gives vendors precise control over which functionality each customer can access, making it possible to build flexible pricing models without restructuring your codebase.
| Use Case | Example |
|---|---|
Module-based pricing | Advanced analytics available only in Enterprise tier |
Pay-per-operation | Charge per report generation |
AI or compute usage | Meter GPU-intensive operations |
Add-on capabilities | Enable premium integrations |
Hardware-enabled features | Unlock capabilities in industrial equipment |
Feature controls in LicenseSpring are not limited to a specific license model. Feature gating works with all license types (perpetual, subscription, time-limited, floating, and node-locked). This means you can layer feature entitlements on top of whatever licensing model your product already uses.
A few things this makes possible that vendors often find useful:
Features can have their own expiry dates, independent of the license. A license valid until end of year can include a premium feature that expires after 30 days, useful for trials of specific capabilities, promotional access, or temporary unlocks without issuing a separate license.
Features can be added or removed at any time. If you want to temporarily enable a premium module for a customer for an evaluation period, an upsell trial, or a support scenario, you can do that without touching the underlying license. When the period ends, the feature expires or gets removed; the license continues as normal.
Both activation-based and consumption-based features work this way. Independent expiry and mid-term changes apply to both feature types, giving you the same flexibility regardless of whether a feature is a binary on/off or a metered usage allowance.
LicenseSpring supports two core approaches to feature entitlements, which can be used independently or together on the same license.
Activation-based features are straightforward: a feature is either enabled or disabled based on what the license grants. There's no usage tracking. Instead, the application checks whether the feature is on, and behaves accordingly.
Premium modules and product tiers
Feature flags
Add-on integrations
Hardware-enabled capabilities
Consumption features track how often a capability is used. Each feature carries a configurable maximum consumption limit, and usage increments against that limit as the application runs.
Maximum usage limits
Overage rules
Automatic usage period resets
Local or server-side consumption tracking
| Feature | Example Metering |
|---|---|
Report generation | 100 reports/month |
AI inference requests | 1,000 API calls |
Rendering operations | Per-frame billing |
Data exports | Limited export volume |
LicenseSpring lets developers define product features directly in the platform and assign them to licenses without custom backend work.
Create features in the LicenseSpring dashboard
Assign features to licenses with optional independent expiry dates
Retrieve feature state through the SDK
Enforce entitlement logic in your applicationDevelopers can check feature state using SDK methods available across multiple languages: C++, C#, Java, Python, Go, and Swift.
Use the feature code to check whether a capability is available on the current license:
Returns a LicenseFeature object, or throws an exception if the feature does not exist.
license->feature("feature_code");Retrieve every feature assigned to a license in a single call:
license->feature("feature_code");For consumption-based features, usage is incremented through the SDK as the application runs:
license->updateFeatureConsumption("feature_code", 1, true);| Parameter | Description |
|---|---|
feature_code | Unique identifier for the feature |
consumption value | Amount to increment |
local storage | Whether consumption is cached locally before syncing |
LicenseSpring supports two consumption tracking strategies, which can be combined depending on deployment requirements.
Usage is stored on the device first. This reduces API calls, improves runtime performance, and keeps consumption tracking functional in offline or air-gapped environments. Local data can be synchronized with the platform later.
Total consumption aggregates usage recorded on the LicenseSpring platform with any locally cached values. This is the right model when multiple users or devices are drawing from a shared usage pool, ensuring limits are enforced accurately across the full deployment.
When tracking shared consumption across users or devices, sync usage explicitly:
license->syncFeatureConsumption("feature_code");Features can expire independently of the license, or be removed at any time through the Vendor Platform. LicenseSpring returns both active and expired feature states to the application so you can handle transitions cleanly:
license->check(InstallFileFilter(), includeExpiredFeatures);LicenseSpring handles the licensing infrastructure so you don't have to build it. Feature-based controls work alongside every other model the platform supports:
Discover how feature flags improve software flexibility, control, and safer releases in this complete guide.
Read More →
Explore alternatives to LicenseSpring for software licensing in LicenseSpring's blog post. Discover other licensing solutions and their features.
Read More →
Explore LicenseSpring's glossary entry on floating licenses. Learn about the concept and benefits of floating licenses in software licensing.
Read More →