Centralized Licensing for Multiple Installations

[r-brown]

We have clients who want to do multiple installations of our software but pay from a single machine by credit card. Our pricing model is based on production volume, not on the number of software installations. In other words, a client can install five copies of our software but still pay the same price through a central machine.

We understand that your licensing model is currently based on a customer limit, and we are OK with that at the present time.
Currently, we create a Parent/Child relationship if our client has multiple installations but wants to pay through a single machine. This is not a problem at the moment, but we have to create a Bundle and an expiring license for the machine they use for payment, while the other machines are given a perpetual license. If they do not pay, we have to manually stop all the other licenses related to the company.
Is there a way to associate a machine's license in NetLicensing with other licenses so that your software can manage this manual process?

In other words, do you have a method to allow us to create this Parent/Child relationship? And how can it be added or configured?
We are getting more requests from clients with multiple locations who want to use our software but pay from a single machine.

[r-brown]

As far as we can see, the entitlement model you describe is already supported by NetLicensing, without requiring a manual Parent/Child relationship between the individual machine licenses.

The key is to separate the company-level entitlement from the individual machine entitlement.

Roles and participants

Based on your description, the setup can be modeled as follows:

• Licensee (Company) — represents the customer organization
• Machine / Node — is identified by its unique fingerprint

This allows the customer to have multiple installations, potentially across multiple locations, while maintaining a single centralized subscription.

Subscription and Node-Locked models

For this kind of customer setup, a combination of the Subscription and Node-Locked models works well.

• Subscription model — specifies the overall Licensee (Company) validity based on the subscription and its expiration
• Node-Locked model — allows specifying individual nodes (machines), which are identified by their unique fingerprint and can be pre-configured or assigned upon first usage

The customer can therefore have multiple installations without having to create a separate commercial subscription for every machine.

Validation

Each installation sends a validation request to NetLicensing, including the Licensee number and the machine fingerprint.

The validation response can then provide the status of both relevant product modules:

sequenceDiagram
    participant M as Software Installation
    participant NL as NetLicensing

    M->>NL: Validate Licensee + Machine Fingerprint
    NL->>NL: Evaluate Subscription
    NL->>NL: Evaluate Node-Locked entitlement
    NL-->>M: Validation result
    M->>M: Boolean AND
    M-->>M: Allow / deny usage

Loading

In your software, you would typically evaluate the response using a Boolean AND:

Subscription is valid
        AND
Machine is Node-Locked entitled
        =
Software is licensed

In this setup:

• Subscription — specifies the overall customer subscription status
• Node-Locked — specifies the individual capabilities or entitlement of the specific machine

Centralized enforcement

This setup also addresses the main issue with the current Parent/Child approach.

With the current approach, the machine used for payment has an expiring license, while the other machines have perpetual licenses. If the customer does not pay, you have to manually stop the other licenses.

With Subscription + Node-Locked, the Subscription can act as the central entitlement for the entire Licensee.

flowchart TD
    L[Licensee<br/>Customer / Company]

    S[Subscription<br/>Overall validity]

    N1[Machine 1<br/>Node-Locked]
    N2[Machine 2<br/>Node-Locked]
    N3[Machine 3<br/>Node-Locked]
    N4[Machine N<br/>Node-Locked]

    L --> S
    L --> N1
    L --> N2
    L --> N3
    L --> N4

    S -. overall entitlement .-> N1
    S -. overall entitlement .-> N2
    S -. overall entitlement .-> N3
    S -. overall entitlement .-> N4

Loading

If the Subscription expires or is manually deactivated/invalidated, the overall entitlement of the Licensee becomes invalid.

As a result, the individual machines will no longer pass the complete licensing check, without requiring you to manually deactivate each machine.

At the same time, the Node-Locked licenses provide the machine-level restriction, ensuring that only entitled machines can use the software.

Parent/Child relationship

So, rather than creating a technical Parent/Child relationship between the individual machine licenses, we would recommend modeling the relationship through the Licensee and the associated licensing models.

The Licensee acts as the common customer context, while:

• Subscription provides the centralized, company-level entitlement
• Node-Locked provides the individual machine-level entitlement

This gives you:

flowchart LR
    C[Customer / Company]
    L[Licensee]

    S[Subscription<br/>Company-level entitlement]
    N[Node-Locked<br/>Machine-level entitlement]

    C --> L
    L --> S
    L --> N

    N --> M1[Machine 1]
    N --> M2[Machine 2]
    N --> M3[Machine 3]
    N --> MN[Machine N]

Loading

In short:

Licensee → Subscription → overall customer entitlement

Licensee → Node-Locked → individual machine entitlement

And the application can enforce:

Subscription valid AND Node-Locked valid → software is licensed

This should allow you to support customers with multiple installations or locations while maintaining a single centralized subscription, without requiring manual deactivation of the individual machine licenses when the customer stops paying.