Features

Built to monetize software, end to end

License keys, Stripe billing, offline Ed25519 validation, and container-aware device fingerprinting — plus the developer experience to ship it in an afternoon.

The licensing engine underneath

Everything you need to monetize software

The agent control plane sits on a production licensing engine — Stripe billing, key issuance, offline signing, and device fingerprinting for your human users. Same platform, same API, both sides of your product.

Core licensing capabilities

Stripe in, license out

Connect Stripe in 2 clicks. Every paid checkout automatically issues a license key, syncs the customer, and emails the credentials. No webhook code, no billing logic to maintain.

Works offline, signed by Ed25519

Issue cryptographically signed license files your software verifies without ever calling our API. Built for air-gapped deployments, unreliable networks, and enterprise security reviews.

Knows every device, even in containers

Identify devices by stable hardware fingerprint. Cap activations per license, transfer cleanly between machines, and stay accurate inside Docker and Kubernetes — where hardware UUIDs lie.

Developer experience

5-line SDK install

Validate licenses, activate devices, and gate features with a single SDK call from Python, TypeScript, or any language that speaks HTTP.

Self-serve customer portal

Customers manage their own devices, recover lost keys, and check license status — without filing a support ticket or waiting on you.

Insights inside the dashboard

Activations, validation patterns, expiry forecasts, and license status trends live alongside your licenses. No analytics integration to wire up.

Migrate in, not just sign up

Import existing licenses from Keygen, Cryptlex, or LemonSqueezy with a CSV upload. Zero downtime, every key intact, your customers never notice.

How it works

Stripe in. License out. Three deliberate steps.

Most licensing tools ask you to glue together checkout, key generation, email delivery, and validation. Licentric ships the entire pipeline as one platform — the same one that gives your AI agents identity, budgets, and governance.

Customer pays in Stripe Checkout→Licentric issues + signs the license→Your app validates with one SDK call

Customer pays through Stripe
You connect Stripe in two clicks. Customer completes Checkout. Licentric receives the webhook, generates a license key, and emails it to them — without you writing the integration.
Licentric stores, signs, and serves
The key is hashed in our database, the offline license file is cryptographically signed with your account's Ed25519 keypair, and your dashboard reflects the new customer instantly.
Your software validates with five lines
The SDK calls our validate endpoint or verifies the signed file locally. The user starts the app. You earned revenue without writing a webhook handler or maintaining licensing logic.

Integration

5 lines. That's it.

One SDK validates licenses, issues agent credentials, and meters usage — in any language that speaks HTTP.

npm install @licentric/sdk

Without Licentric

webhooks.ts

// 200+ lines of webhook handling, billing sync,
// key generation, device tracking...
app.post('/webhook/stripe', async (req, res) => {
  const event = stripe.webhooks.constructEvent(/*...*/);
  if (event.type === 'checkout.session.completed') {
    const license = await generateLicenseKey();
    await db.licenses.create({ key: license, /*...*/ });
    await sendLicenseEmail(customer, license);
    // ... 50 more lines of error handling
  }
  // ... 10 more event types
});

With Licentric

validate.ts

import { Licentric } from "@licentric/sdk";

const client = new Licentric({ apiKey: "lk_live_..." });
const result = await client.validate({ key: licenseKey });

if (result.valid) {
  startApp(result.entitlements);
}

Stripe billing? Connect in two clicks.Webhooks, customer sync, and key delivery handled for you.