Implementing License Models

Once you have chosen a licensing model, you can implement it using license templates, or by overriding the properties of the license template when creating a license. The latter allows you to create a variant without creating a new template.

License template configuration for different licensing models

The sections below list the properties that implement each model. These properties are combinable, not mutually exclusive: a single license can be, for example, node-locked, subscription-based, and named-user all at once. Set the properties for each dimension your model needs.

Perpetual

A perpetual (lifetime) license does not have a subscription interval or an expiration date set.

Property	Value
`subscriptionInterval`	`null`

Perpetual controls payment, not access to updates. To limit which releases the application receives, attach a maintenance policy, configured separately from the license template.

Subscription

A subscription expires after a specific duration of time. When a license expires, LexActivator returns the LA_EXPIRED status code.

Property	Value
`subscriptionInterval`	`P1M`

Node-locked

A node-locked license is locked to the machines on which it is activated, up to its allowedActivations limit. Set the license type to node-locked.

Property	Value
`type`	`node-locked`

OS user-locked

An OS user-locked license is a node-locked license that additionally prevents different users (OS users) on the same machine from re-using the same license.

The userLocked property refers to operating system user accounts, so each OS user on a machine consumes a separate activation. It is unrelated to named user licensing, where the licensee logs in with Cryptlex credentials.

Property	Value
`type`	`node-locked`
`userLocked`	`true`

Hosted-floating

The hosted-floating type implements a floating licensing model without requiring your customer to install a license server, with Cryptlex's servers acting as the license server.

Property	Value
`type`	`hosted-floating`
`leaseDuration`	`>0`, or `0`/`-1` for an unlimited lease
`leasingStrategy`	`per-machine`

Do not call ActivateLicense() unconditionally on startup. See the recommended activation flow for hosted floating licenses.

To let the end user set the lease duration, enable the allow client lease duration property and call SetActivationLeaseDuration() in your app before activating.

An activation is held by a lease, and the Cryptlex servers free it once a lease is not renewed within the configured leaseDuration. A crashed app therefore holds its activation until the lease elapses, which is a zombie license, so release the activation when your app exits by invoking DeactivateLicense().

Hosted-floating (instance-locked)

Instead of locking a floating license to a machine, you can lock it to the application instance (process) by setting the leasing strategy to per-instance. Each running instance consumes a seat, regardless of whether instances share the same device fingerprint. This is what makes floating licenses work inside cloned VMs, Docker containers, and Kubernetes workloads (see Containers and Virtual Machines), and it lets you charge your customer per running instance.

An activation registered by an instance can only be deactivated from within that same instance.

Property	Value
`type`	`hosted-floating`
`leaseDuration`	`>0`, or `0`/`-1` for an unlimited lease
`leasingStrategy`	`per-instance`

On-premise-floating

The on-premise-floating type implements a floating licensing model in environments which may or may not be connected to the internet. Your customer installs LexFloatServer in their network. The allowedFloatingClients property sets how many application instances the server can serve concurrently.

For on-premise floating licenses, the activations limit defined in your plan applies only to the number of LexFloatServer instances that can be activated, while any number of LexFloatClient instances served by each activated LexFloatServer is not counted toward the on-premise floating license limit.

Property	Value
`type`	`on-premise-floating`
`leaseDuration`	`0`, `>0`
`allowedFloatingClients`	`>0`

Single-seat

The number of machines a license key can be used on is determined by the allowedActivations property.

Property	Value
`allowedActivations`	`1`
`type`	`node-locked`, `hosted-floating`

Multi-seat

A single key can be used on multiple machines if the value of the allowedActivations property is greater than one.

Property	Value
`allowedActivations`	`>1`
`type`	`node-locked`, `hosted-floating`

Unlimited-seat

You can allow an unlimited number of seats for a license (site license), and restrict the site using an IP address or location.

Property	Value
`allowedActivations`	`0`, `-1`
`type`	`node-locked`, `hosted-floating`
`allowedIpAddresses`	`[125.67.123.43]`

Named-user

A named-user license has no dedicated license type. You assign the license to a specific individual, typically identified by an email address, by linking the user to it at creation time, on top of any node-locked or floating configuration. The user logs in with their credentials to retrieve their license key, after which activation proceeds like any other license. To learn more, refer to Named User Licenses.

Linking a user to a license does not by itself make it a named user license, and does not change how the license is enforced. Your app must authenticate the user through the named user workflow, otherwise the linked user is just stored customer data.

Usage-based

A usage-based (metered) license has no dedicated license type. Instead, you add meter attributes to any license type defined above to track and enforce usage counts. To make specific meter attributes mandatory for every license, add them to the requiredMeterAttributes property of the license template. To learn more, refer to Usage-Based Licensing.

Choosing a Licensing Model Subscription Licensing

Last updated: 8/6/2026