Skip to content
Kleis
Dark theme
Contact us
Licensing for software vendors

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
Dashboard Sample data
Active licenses
248
Activations
391
Suspended
3
Licenses
Key hintPlanStatusSeats used
K1-YWPR4… Studio Pro Active 2 of 5
K1-7QK2M… Studio Pro Active 5 of 5
K2-D9XHT… Studio Floating Suspended 0 of 20
K1-B3HWW… Studio Trial Revoked 0 of 1
Signed lease on the device
Signature
Ed25519, verified
Bound to
this device's key
Works offline until
2027-03-28 09:20 UTC
The console's own components, with sample data.
Works with
  • .NET 10
  • ASP.NET Core
  • C and C++
  • Windows
  • Linux
  • PostgreSQL
  • Docker Compose
  • HashiCorp Vault
  • OpenTelemetry
  • Prometheus
  • Grafana
Why Kleis

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.

How it works

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.

  1. 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-…
  2. 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)
  3. 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.

    OnlineValid
  4. Validate 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
The life of a license, online and offline
Capabilities

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.

The full feature tour
Offline and air-gapped

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.
Offline leases in detail
Offline leaseOfflineValid
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
Day 5 of 14 without a connection9 days left
Sample data.
Entitlements and usage

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.
Entitlements, usage, and seats
Entitlements of a licenseRevision 14
  • export.pdfFeatureOn
  • projects.maxLimit50
  • render.engineCapabilitystandard, gpu
  • cloud.syncFeature, online onlyOn
  • beta.timelineFeature, until 2027-06-30On
usage.reportCredits this period640 of 1,000
Offline budget in this device's lease25
Sample data.
For developers

A 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.
Quick start and API overview
Check at the operation, not at the buttonC#
public void ExportPdf(Document document)
{
    var decision = kleis.CheckEntitlement("export.pdf");
    if (!decision.Granted)
    {
        throw new LicenseDeniedException(decision.Reason, decision.Recovery);
    }

    // ... export ...
}
Protect an endpoint by entitlementASP.NET Core
app.MapPost("/reports/advanced", GenerateReport).RequireAuthorization("Kleis:reports.advanced");

[RequireEntitlement("export.pdf")]
public IActionResult Export() { ... }
Security, in plain words

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.

The honest limitA person who controls a machine can modify the software on it. Kleis raises the cost and bounds the damage; hard guarantees need checks on a server you control. Read the limits we document.
The security model
Who it is for

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.

License your next release with Kleis.

Define a product and a plan, issue a key, and activate your first device. The console, the API, and the SDKs are ready for it.

The connection to the console was lost. Reconnecting…

The connection could not be restored. Nothing you had not saved was sent.

Reload the page