Categories: Licensing

Shared License Pools: Flexible Software Licensing through a Shared Token Pool

Not every use of software has to permanently consume license units. With a Shared License Pool, software vendors can provide a shared allocation of tokens that applications and features draw on as needed. CodeMeter supports this licensing model on individual computers as well as in local networks and cloud environments.

Using Tokens Rather Than Consuming Them

In token-based software licensing, there is a fundamental difference between consumable units and reusable tokens. In a consumption-based model, tokens are permanently deducted for each action performed. In a Shared License Pool, tokens are reserved for the duration of their use and then become available again.

When an application closes or a feature finishes running, it releases its reserved tokens. These tokens are then available to other applications or features. The total allocation remains unchanged.

A Shared License Pool therefore allows different users to use different features flexibly. Instead of providing a separate license for each feature or user, multiple features can draw on a shared pool. What matters is how many tokens are needed at the same time.

This model is particularly suitable for software products with different sets of features or fluctuating workloads. Higher-value features can reserve more tokens than basic features. As long as enough unallocated tokens are available, the features can be used in parallel.

License Quantity as the Technical Foundation

CodeMeter uses the License Quantity option for Shared License Pools. It specifies how many tokens within a license allocation are available for simultaneous use.

As with Unit Counter for consumable units, the software vendor can set the initial License Quantity and change it later through license updates.

The key difference from Unit Counter lies in what happens during use. With Unit Counter, the counter is permanently reduced. With License Quantity, the total allocation is preserved. Only the number of tokens currently available changes according to the active reservations.

This makes it possible to manage reusable tokens without having to issue a new license each time a feature runs.

Dynamic Allocation Across Features

An application with three different features illustrates how this works in practice.

The first feature requires ten tokens, the second twenty tokens, and the third just one token. The customer has a Shared License Pool containing a total of 25 tokens.

When the customer starts the first feature, CodeMeter reserves ten tokens, leaving 15 tokens available. The third feature can run in parallel, reducing the available allocation to 14 tokens.

The second feature, however, requires twenty tokens and therefore cannot start in this situation. Only after the first feature finishes running and releases its ten tokens are 24 tokens available again. The second feature can now run as well.

This example illustrates how a Shared License Pool controls the simultaneous use of different features. With 25 tokens, either the first or the second feature can run alongside the third. Running all three features simultaneously would require at least 31 tokens.

If the customer needs more capacity on an ongoing basis, they can expand their allocation by purchasing additional tokens. This requires no changes to the software itself.

Automatic Release After Application Crashes

An important question with shared license allocations is what happens when an application terminates unexpectedly.

Under normal circumstances, the software reserves the required tokens when a feature starts and releases them when it finishes. If the application crashes, however, this release mechanism can no longer be executed.

CodeMeter handles this situation by monitoring the processes using licenses. The CodeMeter service runs in the background and regularly checks whether the processes that have reserved licenses are still running.

This verification occurs once a minute. If a process has terminated, its reserved tokens are released automatically.

This prevents a crashed application from tying up tokens indefinitely. Once released, the tokens are available to other applications again.

For software vendors, this mechanism simplifies implementation because the application itself does not have to handle every aspect of these crash scenarios.

Linger Time: Keeping Tokens Reserved Longer

Not every business model calls for tokens to become available again immediately after a feature finishes running.

For these cases, CodeMeter offers the Linger Time option. It allows a license reservation to remain in effect beyond the actual end of use.

For example, a software vendor can specify that reserved tokens become available to other features again only after an hour or a day.

This is useful when the goal is to prevent users from rapidly switching between features to access a large number of different features with a small token allocation.

Linger Time therefore expands the options for designing a Shared License Pool. It allows vendors to limit the number of features used simultaneously and to influence the time interval before tokens can be reused.

The specific configuration depends on the business model. For some applications, immediate release is ideal, while for others, an extended reservation better suits the intended licensing model.

From Individual Computers to the Cloud

A Shared License Pool is not tied to a particular deployment location. CodeMeter supports this model on individual computers, across local area networks (LANs), and wide area networks (WANs), and in cloud environments.

In a local network, for example, multiple workstations can access a shared license allocation. A VPN connection allows such a pool to be used in a wide area network as well.

Alternatively, tokens can be provided through a CmCloudContainer.

Support for offline environments is particularly valuable for many scenarios. CodeMeter allows license allocations to be used without a connection to an external license server on the Internet. This enables software vendors to deploy Shared License Pools in industrial environments where production systems are disconnected from the Internet for security reasons.

The actual reach of a pool depends on the chosen container technology and the accessible licensing infrastructure. A local pool requires no Internet connection, while a pool spanning multiple networks requires communication between the systems involved.

Providing and Expanding License Capacity

Shared License Pools are provisioned through CodeMeter’s established licensing processes. The software vendor defines a corresponding license item in CodeMeter License Central, such as a package of 25 pool tokens.

A ticket is generated for the customer, who can redeem it through CodeMeter License Portal or WebDepot. During activation, the customer selects the desired license container and confirms the license transfer.

Once activation is complete, the tokens are available to the application. The software can then reserve the required number of tokens when individual features start.

To expand the allocation later, the software vendor can offer an upgrade that increases the pool size, for example, from 25 to 50 tokens. This allows software vendors to give customers a smaller pool initially and offer additional capacity as their needs grow.

Visibility Through CodeMeter WebAdmin

Managing a Shared License Pool requires visibility into both the total token allocation and the tokens currently reserved.

CodeMeter provides CodeMeter WebAdmin as an administration tool for this purpose.

It displays existing licenses and their respective license options. License Monitoring can also be used to check how many tokens are currently reserved.

This information is displayed through CodeMeter’s standard tools. Software vendors therefore do not have to develop their own administration interface to view basic information about license allocations and usage. With Shared License Pools, this visibility helps identify bottlenecks and assess whether the allocation is appropriately sized.

Flexible Licensing Models for Different Requirements

Shared License pools allow software vendors to define the scope of a license independently of a fixed number of individual features. Instead of licensing each feature separately, they can provide a shared allocation from which different features draw according to their respective token requirements.

This makes it possible to cover different combinations of features with the same license package. Within the available allocation, the customer decides which features to use simultaneously.

For software vendors, this creates additional options for structuring their product offerings. Different token packages can represent different capacity levels. Customers can start with a smaller allocation and expand it as their requirements grow.

Unlike consumption-based tokens, repeated use does not automatically require another purchase. Instead, additional revenue is generated when customers need greater license capacity to use more features simultaneously.

The two models therefore address different requirements: Consumption-based tokens (Unit Counter) enable billing for individual instances of use, while Shared License Pools (License Quantity) control the simultaneous availability of features.

The Key Advantage: One License Pool, Many Ways to Use It

A Shared License Pool makes software licensing more flexible while maintaining control over use. Instead of licensing individual features separately, software vendors can provide a shared token allocation that is distributed dynamically based on current demand. CodeMeter handles secure reservation, automatic release, and monitoring of license capacity locally, across a network, or in the cloud. Rather than licensing every possible use separately, vendors license only the simultaneous capacity customers actually need.

 

KEYnote 52 - Edition Fall/Winter 2026

To top