Licers › Documentation

Licers — Full Reference

Licers (https://licers.com) is a software license-key management platform for developers. Issue license keys, bind them to devices/hardware, and validate them at runtime with tamper-proof Ed25519-signed responses that a cracked "fake license server" cannot forge. It works with Python via an official SDK and with any language over a simple REST API. Free to start.

This document gives language models a complete overview of what Licers does and how to integrate it. Canonical pages: Home https://licers.com/ · Docs https://licers.com/docs · Blog https://licers.com/blog · Sign up https://licers.com/register

Why signed validation matters

Most licensing schemes fail to one trick: a fake local server (or patched DLL) that always answers "valid". Licers defeats this by signing every validation response with an Ed25519 private key that never leaves the server. Your application embeds only the matching public key and verifies the signature locally, so a forged or replayed reply is cryptographically impossible. Each request carries a client-generated nonce and the response includes a timestamp, which the SDK checks to reject stale or replayed messages.

Core concepts

• Product: a piece of software you protect. Each product has its own Ed25519 signing keypair; you embed the public key in your distributed app.
• License key: issued to a customer (format like PY-XXXXXXXXXXXXXXXX). Can carry an expiry, a device/seat limit, and arbitrary feature entitlements.
• HWID (hardware id): a device fingerprint. Keys can be bound to a maximum number of devices.
• Features: key/value entitlements returned on validation (e.g. pro: true, seats: 5) so you can gate functionality.
• Floating (concurrent) licenses: a key with a maximum number of simultaneous sessions; clients lease a seat, heartbeat while running, and release on exit.
• Offline license files: a signed .lic file you ship with the app for air-gapped machines; verified locally with zero network calls.

Quickstart (Python SDK)

Install:

pip install pylicensify

Validate a key:

from pylicensify import LicenseClient

client = LicenseClient(public_key="YOUR_PUBLIC_KEY") result = client.validate("PY-XXXXXXXXXXXXXXXX") if result: print("Licensed. Features:", result.features) if result.feature("pro"): enable_pro_features() else: print("Not licensed:", result.error) raise SystemExit(1)

validate() sends a nonce, verifies the Ed25519 signature, and rejects stale/replayed responses automatically. It raises SignatureError on tampering and NetworkError if the server is unreachable. Get your product's public key from the Licers dashboard → Integration page; it is safe to embed in distributed apps because the private key never leaves the server.

REST API (any language)

Base URL: https://licers.com. The validation endpoint is public (no auth) and returns a signed payload you verify with the product public key.

• Validate: POST https://licers.com/api/v1/validate
• Body: {"key": "PY-...", "hwid": "<device-fingerprint>", "nonce": "<random-per-request>"}
• Returns an Ed25519-signed result including validity, expiry, bound-device info, and features. Verify the signature client-side.
• Floating / concurrent seats:
• POST https://licers.com/api/v1/lease — check out a seat
• POST https://licers.com/api/v1/heartbeat — keep the seat alive
• POST https://licers.com/api/v1/release — free the seat on exit
• Update check: GET https://licers.com/api/v1/update — report the client's current version, learn if a newer release exists.
• Gated download: GET https://licers.com/api/v1/download/<release-id>?key=<license-key> — download a release build only with a valid key.

Automation endpoints for managing products, keys, and releases are authenticated with an API key you create in the dashboard.

Floating (concurrent) licenses in Python

from pylicensify import LicenseClient, SeatUnavailable

client = LicenseClient(public_key="YOUR_PUBLIC_KEY") try: with client.session("PY-XXXX...") as sess: print("Seat acquired:", sess.seats) # {'used': 1, 'max': 5} run_app() # released automatically on exit except SeatUnavailable: print("All seats are in use — try again later.")

Offline license files (air-gapped)

Issue a signed .lic file from a license in the dashboard, ship it with the app, and verify it locally with no network:

from pylicensify import verify_offline_license

data = verify_offline_license("YOUR_PUBLIC_KEY", "license.lic") print("Valid for:", data.get("customer"), data.get("features"))

Verification checks the signature, expiry, device binding, and OS lock.

Update checks in Python

info = client.check_update("PY-XXXX...", current_version="1.0.0") if info["update_available"]: print("New version:", info["version"], info["notes"]) # info["download_url"] is a license-gated download link

Custom hardware id

By default the SDK derives a machine id from uuid.getnode(). Pass your own for a stronger fingerprint:

client.validate(key, hwid=my_custom_fingerprint())

Errors (Python SDK)

• InvalidLicense — server rejected the key (invalid / expired / revoked / blocked)
• SignatureError — signature, nonce, or timestamp failed (forged or replayed)
• NetworkError — could not reach the license server
• SeatUnavailable — a floating license has no free seats

All inherit from LicenseError.

Hardening

Obfuscate your client so the license check itself cannot be trivially patched out — for example with PyObfuscate (https://pyobfuscate.com).

Links

• Home: https://licers.com/
• Documentation: https://licers.com/docs
• Blog (licensing & anti-piracy guides): https://licers.com/blog
• Get started (free): https://licers.com/register
• Terms: https://licers.com/terms
• Privacy: https://licers.com/privacy