Skip to main content

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.

What the signature guarantees

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:

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.

ClaimMeaningTypical application check
issVendor or signing authorityEquals the expected issuer
idUnique license identifierPresent and well formed; optionally use for audit or revocation lookup
iatTime at which the license was issuedNot unreasonably in the future, allowing limited clock skew
expOptional expiration timeCurrent trusted time is before expiration
nodeinfoTarget installation or device identityExactly matches the local node information; absence means unlocked only if the product permits it
userLicensed customer identity snapshotApply any account or customer policy required by the product
product.nameLicensed applicationEquals the application that is running
product.optionsEnabled featuresEnable only the listed, recognized options
product.restrictionsVendor-defined limitsParse and enforce every restriction the product understands
librariesLicensed or required componentsConfirm 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.

CRYPTOGRAPHICCan I trust these bytes?
  • Require a compact three-part JWT.
  • Allow only RS256.
  • Select a trusted key by kid.
  • Verify the signature before using claims.
APPLICATION POLICYMay this installation run?
  • Check issuer, product, issue time, and expiry.
  • Compare nodeinfo with the local node.
  • Enable only signed options.
  • Enforce restrictions and revocation policy.

A safe validation sequence is:

  1. Read the .lic file as a compact JWT and reject malformed or oversized input.
  2. Parse the header without trusting it. Require alg to be exactly RS256; never accept none or let the token choose an unexpected algorithm.
  3. Resolve kid only within the vendor's preconfigured, trusted JWKS. Do not download a key from an arbitrary URL supplied by the token.
  4. Verify the signature. Stop immediately if verification fails.
  5. Validate iss, iat, and optional exp, allowing only a small documented clock skew. Use a trustworthy clock.
  6. Confirm product.name is this application and compare nodeinfo with the locally calculated node information. Treat a missing node as unlocked only when your product policy explicitly allows it.
  7. Read options, restrictions, and libraries from the verified payload and enforce only values the application recognizes. Unknown required values should fail closed.
  8. 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.