License
A product license is a signed JSON Web Token (JWT). The software vendor chooses the license information - such as the application name, target node, expiration, enabled options, restrictions, customer, and required libraries - and License Center signs that information with the vendor's private key.
Because JWT is an industry-standard format, the consuming application can be written in any language with a maintained JWT library. It does not need a License Center-specific runtime: it needs the signed token, the vendor's trusted public key, and the application's licensing rules.
A successful signature check proves that the signed header and payload have not been changed since the holder of the corresponding private key issued them. It also proves which trusted signing key was used. JWT payloads are encoded, not encrypted, so do not put passwords, private keys, or other secrets in a license.
🧬 Anatomy of a license
The .lic file contains a compact JWT with three Base64URL-encoded parts:
alg · typ · kidproduct · node · optionsRS256(header.payload)For a Vendor RS256 v1 license, a decoded header resembles:
{
"alg": "RS256",
"kid": "vendor-key-2026-01",
"typ": "JWT"
}
The kid identifies the public key that verifies the signature. License Center
publishes current and retired public keys at the product owner's tenant license
JWKS endpoint:
https://licenses.example.com/tenants/<tenant-slug>/.well-known/license-jwks.json
Cache keys according to your deployment policy, refresh the JWKS when an
unknown kid appears, and retain trusted retired keys so previously issued
licenses remain verifiable. Legacy License Manager tokens use RS256 but may not
contain a kid; License Center's legacy format omits it. Verify those tokens
with the explicitly configured legacy public key.
📄 Example payload
The following example uses the Legacy License Manager payload shape. The actual .lic file is
the signed, three-part compact JWT—not plain JSON.
{
"iss": "MyCompany",
"id": "01a0afc1-1a52-76ac-b136-0ff2fd593195",
"iat": 1789655063,
"exp": 1792247063,
"nodeinfo": "NI-MYAPP-0C712067-EBAB7834-5F8F43F4-AF1ACA8E",
"user": {
"email": "johnd@company.com",
"firstName": "",
"lastName": "",
"name": "johnd"
},
"product": {
"name": "MyApp",
"options": [
"Recast",
"Record",
"Detect"
],
"restrictions": []
},
"libraries": []
}
iat and exp are Unix timestamps in seconds. In this example the license was
issued on September 17, 2026 and expires on October 17, 2026. When exp is
absent, License Center treats the license as having no expiration; the
application should implement the same policy deliberately.
Vendor RS256 v1 additionally includes tenant_id, uses an object for product
restrictions, and represents library names as strings. Legacy format uses an
array of restriction objects and library objects such as {"name":"Decoder"}.
Its serialized payload is limited to 475 bytes. Do not assume these two payload
shapes are interchangeable when implementing a verifier.
| Claim | Meaning | Typical application check |
|---|---|---|
iss | Vendor or signing authority | Equals the expected issuer |
id | Unique license identifier | Present and well formed; optionally use for audit or revocation lookup |
iat | Time at which the license was issued | Not unreasonably in the future, allowing limited clock skew |
exp | Optional expiration time | Current trusted time is before expiration |
nodeinfo | Target installation or device identity | Exactly matches the local node information; absence means unlocked only if the product permits it |
user | Licensed customer identity snapshot | Apply any account or customer policy required by the product |
product.name | Licensed application | Equals the application that is running |
product.options | Enabled features | Enable only the listed, recognized options |
product.restrictions | Vendor-defined limits | Parse and enforce every restriction the product understands |
libraries | Licensed or required components | Confirm any product-specific library requirements |
Claims are vendor-defined application data. A valid signature does not, by itself, mean that the license is valid for the current machine or product.
✅ Validation in the application
Use a well-maintained JWT library for the application's language. Do not write custom signature or Base64URL code.
- Require a compact three-part JWT.
- Allow only
RS256. - Select a trusted key by
kid. - Verify the signature before using claims.
- Check issuer, product, issue time, and expiry.
- Compare
nodeinfowith the local node. - Enable only signed options.
- Enforce restrictions and revocation policy.
A safe validation sequence is:
- Read the
.licfile as a compact JWT and reject malformed or oversized input. - Parse the header without trusting it. Require
algto be exactlyRS256; never acceptnoneor let the token choose an unexpected algorithm. - Resolve
kidonly within the vendor's preconfigured, trusted JWKS. Do not download a key from an arbitrary URL supplied by the token. - Verify the signature. Stop immediately if verification fails.
- Validate
iss,iat, and optionalexp, allowing only a small documented clock skew. Use a trustworthy clock. - Confirm
product.nameis this application and comparenodeinfowith the locally calculated node information. Treat a missing node as unlocked only when your product policy explicitly allows it. - Read options, restrictions, and libraries from the verified payload and enforce only values the application recognizes. Unknown required values should fail closed.
- Apply any online revocation or local deny-list policy your product defines.
In language-neutral pseudocode:
token = readLicenseFile()
header = peekHeader(token)
require header.alg == "RS256"
publicKey = trustedVendorKeys.find(header.kid)
claims = jwt.verify(token, publicKey, algorithms = ["RS256"])
require claims.iss == "MyCompany"
require claims.product.name == "MyApp"
require claims.exp is absent or trustedNow() < claims.exp
require (claims.nodeinfo is absent and productPolicy.allowsUnlocked) or
claims.nodeinfo == localNodeInfo()
features.enableOnly(recognized(claims.product.options))
restrictions.enforce(claims.product.restrictions)
The private signing key remains with the vendor. Distribute only public keys or JWKS data to applications. Plan for signing-key rotation, offline key caching, clock errors, malformed claims, and failure behavior before shipping the validator.