Software licensing that keeps working offline.
Kleis issues license keys for your product and turns every activation into a signed lease bound to one device. Your software verifies the lease itself, runs without a connection for 7 to 28 days, and picks up entitlement changes, suspensions, and revocations when it reconnects.
- Ed25519-signed leases
- Air-gapped activation by file
- C#, ASP.NET Core, and C/C++ clients
- Self-hostable
| Key hint | Status | Seats used |
|---|---|---|
K1-YWPR4… |
Active | 2 of 5 |
K1-7QK2M… |
Active | 5 of 5 |
K2-D9XHT… |
Suspended | 0 of 20 |
K1-B3HWW… |
Revoked | 0 of 1 |
- Signature
- Ed25519, verified
- Bound to
- this device's key
- Works offline until
- 2027-03-28 09:20 UTC
- .NET 10
- ASP.NET Core
- C and C++
- Windows
- Linux
- PostgreSQL
- Docker Compose
- HashiCorp Vault
- OpenTelemetry
- Prometheus
- Grafana
A license your product can check by itself.
Most licensing breaks at the edge of the network. Kleis puts a signed, expiring proof of the license on the device, so the decision is made where the software runs and still comes from your server.
Unforgeable and device-bound
A lease is signed with Ed25519 and names the device's own key. Editing it, or copying it to another machine, makes it worthless.
Offline by design
A device keeps working for the offline period you choose: 7, 14, 21, or 28 days. An outage of the server never stops a licensed product.
Changes reach devices
Switch a feature, suspend, or revoke in the console or through the API. Connected devices follow within moments, offline ones at their next contact.
Yours to run
Deploy the API, the worker, and the console with Docker Compose on PostgreSQL. Signing keys can stay in HashiCorp Vault.
From a key to a lease in four steps.
The license key is used once. After activation the device holds a lease, and every later decision is made from that lease.
Issue a key
Issue a license under a plan, in the console or through the API. The key is shown once; the server keeps a keyed hash and a short hint.
K1-YWPR4-B3HWW-…Activate
The SDK creates a key pair for the device, answers a one-time challenge, and presents the license key. The server takes a seat for the device.
ActivateAsync(key)Receive a signed lease
The server answers with a lease: the entitlements, the device's public key, and an expiration, signed with Ed25519. The SDK verifies it before trusting a word of it.
OnlineValidValidate and renew
While connected, the SDK renews the lease in the background. Offline, the held lease decides until it expires. Then one contact, or one file, renews it.
OfflineValid
Everything between a sale and a running product.
Each of these is built and tested today. The feature tour says exactly how each one behaves, including its limits.
License keys and plans
Perpetual, subscription, trial, and fixed-date licenses, with 128-bit or 256-bit keys shown once.
Offline leases
Signed leases that carry authority for 7 to 28 days without a connection.
Air-gapped activation
Activate, renew, and deactivate by exchanging a request file for a response file.
Entitlements and feature flags
Features, numeric limits, and capabilities per plan and per license, each with its own expiration.
Metered usage
Atomic reservations against a balance, and offline budgets set aside in the lease.
Floating seats
Shared seats on short server leases, and explicit checkout for work offline.
Revocation and suspension
Signed status notices reach connected devices at once and offline devices at their next contact.
Customers and a portal
Customer records, and a sign-in that shows a customer only their own licenses and devices.
Audit log and export
An append-only record of every administrative action, and a download of all your tenant's data.
Administration API and webhooks
Everything the console does, for your back end, with idempotency keys and signed deliveries.
Hardware-backed device keys
On Windows a host can keep the device key in the TPM, non-exportable.
Self-hosting and observability
Vault-backed signing, OpenTelemetry metrics, and ready Prometheus alerts and Grafana dashboards.
The lease is the license, wherever the device is.
A cached "yes" is not a license. Kleis clients accept only a lease they verified, and the lease carries its own expiration.
- A bounded offline period. You choose 7, 14, 21, or 28 days per tenant, product, plan, or license. Restarting or copying files never restarts it.
- Devices that never connect. The device writes a request file, someone exchanges it for a response file, and the device imports it. The license key is in neither file.
- Clock changes are noticed. Time is anchored to the server and tracked on the device. Setting the clock back asks for a connection; it never extends a lease.
- Signed by
lease-2027-01(Ed25519)- Trusted through
- manifest 7, root
root-2027 - Bound to
- this device's public key
- Issued
- 2027-03-14 09:20 UTC
- Offline period
- 14 days
- Expires
- 2027-03-28 09:20 UTC
Sell features, limits, and usage, not just a yes or no.
A plan grants entitlements; a license can override them. Your code asks one question at the operation it protects.
- Feature flags, limits, and capabilities. Each with its own optional expiration, and online-only where a feature must not outlive a connection.
- Metered usage. Reserve units against a period's balance on the server. A device can carry a budget in its lease for use offline, taken out of the balance in advance.
- Floating seats. Share seats across devices with short server leases, or check a seat out for a stretch offline.
export.pdfFeatureOnprojects.maxLimit50render.engineCapabilitystandard, gpucloud.syncFeature, online onlyOnbeta.timelineFeature, until 2027-06-30On
usage.reportCredits this period640 of 1,000A few calls in your product. The rest is an API.
The SDK decides from the verified lease with no I/O, so a check is safe on a UI thread and on a hot path. Your back end runs everything else through the administration API.
- C# and ASP.NET Core. A client for desktop, command-line, and worker applications, and registration, health checks, and authorization policies for web hosts.
- Native C and C++. A static library with a C header that verifies the same leases by the same rules.
- Administration API and webhooks. Idempotent creation, keyset paging, an OpenAPI description, and HMAC-signed event deliveries with retries.
public void ExportPdf(Document document)
{
var decision = kleis.CheckEntitlement("export.pdf");
if (!decision.Granted)
{
throw new LicenseDeniedException(decision.Reason, decision.Recovery);
}
// ... export ...
}app.MapPost("/reports/advanced", GenerateReport).RequireAuthorization("Kleis:reports.advanced");
[RequireEntitlement("export.pdf")]
public IActionResult Export() { ... }What protects a license, and what cannot.
Kleis makes licenses unforgeable and bound to a device, limits how long a device can go unchecked, and keeps one vendor's data invisible to another. It does not claim that offline software is uncrackable.
Signed leases
Every lease is signed with Ed25519 and verified on the device before anything in it is read.
Pinned roots
Your application pins the root key. Signing keys are trusted only through a manifest that root signed.
No replay, no rollback
Requests are signed by the device and used once. Older leases and older manifests are refused.
Tenants kept apart
PostgreSQL row-level security decides which rows exist for a request, under a role that cannot bypass it.
Built for vendors whose software leaves the building.
Desktop and on-premises products
Applications installed at the customer's site, on laptops that travel, in plants and labs where the network is not a given.
Restricted and air-gapped sites
Customers who cannot let a device call out. Activation and renewal work by file, and the key never travels in one.
Server products and services
Self-hosted server software and web applications that enforce entitlements on every request, with ASP.NET Core authorization.