Integrate license checking into your tool

Every key is validated live, server-side, HWID-locked to one device, and every response is cryptographically signed. Pick your language below and drop in the client — no build step required.

How it works

1. In your admin dashboard, create a product for each tool you sell, then generate license keys for it (optionally with an expiry and a customer email). Each key is either device-locked (the default) or public — see key types below.
2. Give the key to your customer. Your tool calls the SDK's check(key) on startup — it activates the key to the current device the first time, and verifies it on every subsequent run.
3. Manage keys any time from the dashboard: revoke a leaked key, extend an expiry, or reset a key's bound device so a customer can move to a new machine.

Key types: device-locked or public

You choose the type when you generate a key — the Public key switch in the Generate keys dialog, or "keyType": "public" in the Automation API. Your software and the SDKs work the same way with both.

Anyone who has a public key can use your software, so hand one out only where that is what you want, and revoke it (or let it expire) when it should stop. The full rules are in the API reference and the security model.

SDKs

Each SDK is dependency-light source code meant to be copied into your own project, not a published package. The SDKs & API wrapper page covers every option, exactly what each library protects against, and the Automation client (Python and Node.js) for creating keys from your own server.

Quick start

Python

pip install cryptography

from license_client import LicenseClient

client = LicenseClient(
    base_url="...",
    product="YOUR_PRODUCT_ID",
    public_key_b64="...",
)
result = client.check(license_key)
if not result.valid:
    print("License invalid:", result.reason)
    sys.exit(1)

Node.js

const { LicenseClient } = require('./licenseClient');

const client = new LicenseClient({
  baseUrl: '...',
  product: 'YOUR_PRODUCT_ID',
  publicKeyB64: '...',
});
const result = await client.check(licenseKey);
if (!result.valid) {
  console.error('License invalid:', result.reason);
  process.exit(1);
}

Go

client, _ := licenseclient.New(
    "...",
    "YOUR_PRODUCT_ID",
    "...",
)
result := client.Check(licenseKey)
if !result.Valid {
    log.Fatal("License invalid: ", result.Reason)
}

Rust

let client = LicenseClient::new(
    "...",
    "YOUR_PRODUCT_ID",
    "...",
)?;
let result = client.check(license_key);
if !result.valid {
    eprintln!("License invalid: {:?}", result.reason);
    std::process::exit(1);
}

What this system protects against — and what it doesn't

See the Security Model page for the full HWID and signature spec, and the API Reference for the raw HTTP contract if you're integrating from a language without a ready-made SDK.