Built for real-world licensing

Everything you need to protect your software, from desktop apps to CLI tools to air-gapped deployments.

Start Free Trial View on GitHub

🔐

Offline Validation

🖥️

Hardware Binding

🎛️

Feature Flags

📄

All License Types

💻

Open Source

🔔

Webhooks

Offline-First Validation

Licenses validate locally using RSA signatures embedded in the key itself. No server round-trip required.

RSA-2048 cryptographic signatures
All license data encoded in the key
Validate in air-gapped environments
No network latency on startup
Works with firewalls and proxies

// Validation happens entirely offline
let verifier = LicenseVerifier::new(PUBLIC_KEY)?;
let license = License::from_file("license.key")?;

// No network call - cryptographic verification only
match verifier.verify(&license) {
    Ok(claims) => println!("Valid: {}", claims.licensee),
    Err(e) => eprintln!("Invalid: {}", e),
}

Hardware Binding

Lock licenses to specific machines. Prevent unauthorized copying and sharing.

CPU ID fingerprinting
MAC address binding
Disk serial number
Custom hardware identifiers
Configurable binding strength

// Create a verifier with hardware binding
let verifier = LicenseVerifier::new(PUBLIC_KEY)?
    .with_hardware_binding()
    .with_binding_options(BindingOptions {
        cpu_id: true,
        mac_address: true,
        disk_serial: false,
        custom: Some(get_custom_fingerprint()),
    });

// Verification fails if hardware doesn't match
verifier.verify(&license)?;

Feature Flags

Encode feature entitlements directly in the license. No server calls to check what's enabled.

Arbitrary key-value metadata
Boolean feature toggles
Numeric limits (seats, usage)
Tiered feature sets
Runtime feature checking

// Check features directly from the license
let claims = verifier.verify(&license)?;

if claims.features.contains("pro") {
    enable_pro_features();
}

if let Some(seats) = claims.metadata.get("max_seats") {
    enforce_seat_limit(seats.parse()?);
}

Flexible License Types

Support any licensing model: perpetual, subscription, trial, floating, or custom.

Perpetual licenses with optional maintenance
Time-limited subscriptions
Trial licenses with feature limits
Floating/concurrent licenses
Node-locked deployments

// Generate different license types
let perpetual = generator.generate(LicenseType::Perpetual {
    maintenance_until: Some(next_year),
})?;

let subscription = generator.generate(LicenseType::Subscription {
    expires: next_month,
    auto_renew: true,
})?;

let trial = generator.generate(LicenseType::Trial {
    expires: in_14_days,
    features: vec!["basic"],
})?;

Open Source Client

MIT-licensed Rust library. Inspect the code, audit the security, contribute improvements.

Full source code on GitHub
MIT license - use anywhere
Community contributions welcome
Security auditable
No hidden dependencies

# Add to your Cargo.toml
[dependencies]
licenz-core = "0.1"

# Or build from source
git clone https://github.com/licenz/licenz-core
cd licenz-core && cargo build --release

Webhook Integrations

Get notified when licenses are created, activated, or expire. Integrate with your existing tools.

License created/activated events
Expiration warnings
Validation failures
Custom event payloads
Retry with exponential backoff

// Webhook payload example
{
  "event": "license.activated",
  "timestamp": "2024-01-15T10:30:00Z",
  "data": {
    "license_id": "lic_abc123",
    "customer_email": "user@example.com",
    "product": "pro",
    "hardware_id": "hw_xyz789"
  }
}

How it works

Secure, simple, and offline-capable

Generate a key pair

Create an RSA key pair. The private key stays on your server, the public key goes in your application.

Create licenses

Generate cryptographically signed licenses with customer info, expiration dates, and feature flags.

Validate offline

Your app validates the license using the embedded public key. No network calls, no server dependencies.

Manage via dashboard

Track activations, revoke licenses, and get analytics through our web dashboard or API.

Ready to get started?

Start your free trial today. No credit card required.

View Pricing Read the Docs