Hardware-bound activation
Every activation binds the session to a device fingerprint. A leaked key stops working the moment it leaves the machine it was activated on. Device caps are enforced server-side.
Not open for business yet. Create an account and run the free trial to try the whole system. Nothing can be bought until we launch properly.
Licensing infrastructureLicences that
defend themselves.
Keys get shared. Builds get patched. Licentry is the licensing API that notices and fights back: hardware-bound activations, proof-of-possession sessions, cryptographically signed responses and per-customer watermarked builds.
P-256 SIGNED RESPONSES· DPoP RFC 9449· HOSTED OR DEDICATED
P-256every signature channel
314-bitbuild token entropy
< 1 heartbeatrevocation propagation
5 endpointsfull client integration
Why Licentry
Most licensing checks return a boolean.
Most licensing checks return a boolean.
Attackers patch booleans.
Licentry treats licensing as a live, signed, device-bound session, not a one-shot yes/no your attacker flips in a debugger.
Proof-of-possession sessions
Short-lived access tokens can be DPoP-bound to a P-256 key held by the client. A stolen token is useless without the private key that never leaves the device.
Signed responses
Every licence response carries an ECDSA P-256 signature your app verifies against pinned public keys. A spoofed server, patched DNS or MITM'd reply fails closed.
Watermarked Windows builds
Windows executables are patched per download with a unique build token, owner hint and self-hash. When a copy leaks, one query names the account it came from, unless the file has been repacked to strip the mark.
Sharing detection
Concurrent-session caps, per-key device limits, heartbeat sequence tracking and geo evidence trails surface resellers and "family plans" you never approved.
Kill switch
A revocation bump invalidates every running session within one heartbeat. A shared licence stops working while someone is holding it, rather than at the next launch.
Integration lifecycle
Five endpoints. One afternoon.
The whole client integration is a small, strict state machine. The order below is the order your code runs in.
01
Issue
Issue vendor API
Mint 28-character licence keys from your dashboard or the vendor API. Keys are HMAC-peppered at rest with a pepper unique to your account, so a database leak alone reveals nothing usable.
02
Activate
Activate POST /activate
Your app sends the key, a device hash, and optionally a DPoP public key. It gets back a short-lived session: access + refresh tokens, signed, idempotent on retry.
03
Heartbeat
Heartbeat POST /heartbeat
A monotonic sequence counter keeps the session provably alive. Replays and skipped counters are rejected, so cloned sessions surface immediately.
04
Refresh & revoke
Refresh & revoke POST /refresh
Tokens rotate before expiry. When you revoke or freeze a licence, the bump invalidates every bound session on its next beat. No waiting for expiry.
// 1. activate once per install auto s = licentry.activate(key, deviceHash(), dpopJwk()); // 2. verify the response signature (pinned P-256) if (!verify(s.header("X-Licentry-Sig"), pinnedKeys)) fail_closed(); // 3. heartbeat on a timer, seq strictly increasing every(minutes(15), [&]{ licentry.heartbeat(++seq); }); // 4. refresh before expiry; re-activate on stale_revocation before(s.expiresAt, [&]{ s = licentry.refresh(s.refreshToken); }); // offline? verify the ES256 grace JWT (device-bound) if (offline && graceJwt.dev == deviceHash()) run_grace_period();
Client integration
Ship it in any language.
The client side is five HTTPS calls with JSON bodies, so anything with an HTTP client can run the licensing loop. Signatures are ECDSA P-256: most of these verify it straight from the standard library, the rest with one well-known package. The docs carry copy-paste examples for twelve languages.
Defense in depth
Built by people who
Built by people who
watch software get attacked.
Every layer assumes the one above it eventually fails, so removing any single check still does not leave someone with a working copy.
- Indistinguishable failures. Unknown, expired and revoked keys all fail identically, on the same response schedule, so activation can't be used as an oracle to sort live keys from dead ones.
- Server-held engine parameters. Ship config your app actually needs, sealed to the live session key. Patch the licence check out and there is nothing to run with, so the cheapest attack is no longer a one-byte edit: someone has to buy a copy, extract the payload and redistribute a much larger file.
- An append-only audit trail. Wrong-owner logins, replayed heartbeats and HWID resets are recorded with actor, IP and evidence.
L7Response signingECDSA P-256
L6Proof-of-possessionDPoP · RFC 9449
L5Build watermarking.lcmrk · HMAC
L4Offline graceES256 JWT · device-bound
L3Sealed engine parametersAES-256-GCM
L2Timing normalizationAnti-oracle
L1Sharing evidenceAudit trail
Deployment
Shared infrastructure. Or a server of your own.
Licentry Cloud
We run the API, the database, the key management and the on-call. You get an endpoint, a vendor dashboard and scoped API keys. There is nothing to provision.
Your own server
A single-tenant server provisioned for your account: your database, your licence data, optionally your own Discord bot and API domain. We set it up by hand, harden it and keep it patched. Part of the self-hosted data plan, enabled on request.
Compare
Most tools hand over a key. Then stop.
A key on its own is a string in a database. Everything below is about what happens after the buyer has it: whether anything still checks, and what you can prove when a copy walks.
| Capability | Checkout aloneGumroad, Paddle | Licensing suitesCryptlex, LicenseSpring | Key systemsKeyAuth and similar | Licentry |
|---|---|---|---|---|
| Checks the licence while your app is running | - | ✓ | ✓ | ✓Live session |
| Ties a licence to one machine | - | ✓ | ✓ | ✓Server-enforced caps |
| Revoking kills sessions already running | -Refund only | ~Next check-in | ~Varies | ✓Within one heartbeat |
| A stolen token is useless on another machine | - | ~Uncommon | ~Uncommon | ✓DPoP, RFC 9449 |
| Your app can prove the reply really came from us | - | ~Varies | ~Varies | ✓Signed, P-256 |
| A leaked build points back to one buyer | - | ~Uncommon | ~Uncommon | ✓Watermarked, Windows |
| Evidence when a key gets shared | - | ~Varies | ~Basic | ✓Devices, IPs, geography |
| Works in any language, no SDK to wait for | ~Webhook only | ~SDK per platform | ✓ | ✓Five HTTPS calls |
| Costs a flat fee, not a share of sales | -Takes a cut | ✓ | ✓ | ✓Flat monthly fee |
| Start without talking to a salesperson | ✓ | ~Varies | ✓ | ✓From 19 dollars |
✓ does it ~ depends on the vendor or the tier - not what it is for. Columns describe the usual shape of a category rather than one product, so check the current feature list of anything you are shortlisting.
A note on the first column, because it is not a rival product. Checkout platforms take payments, which they do well, and none of them set out to enforce a licence afterwards. That column is what you have when payment is the only step, which is where most vendors start. Most keep their checkout exactly as it is and put Licentry underneath it.
The four rows almost nobody else ticks
A stolen token is dead on arrival
Sessions can be bound to a keypair the device generates and never shares. Switch it on and a token copied to another machine stops working, because the thief cannot sign for it.
A fake server cannot answer for us
Every session response is signed with ECDSA P-256 and verified against a key pinned in your binary. Patched DNS, a proxy or a spoofed host all fail closed instead of replying "valid".
Every Windows download is watermarked
Each executable carries its own build token, owner hint and self-hash. When a copy shows up on a forum, one query names the account it was issued to, unless the file has been repacked to strip the mark.
Sharing leaves a trail
Concurrent sessions, device counts, network changes and heartbeat gaps become a verdict you can act on, with the device, address and geography history behind it in the dashboard.
Selling, not enforcing
Gumroad, Lemon Squeezy, Paddle
They take the payment and email a key. Nothing checks that key while your software runs, so a copy posted in a forum keeps working forever. Many vendors keep theirs and add Licentry underneath: they handle checkout, we enforce the licence.
Built for large software vendors
Cryptlex, LicenseSpring, Thales Sentinel
Mature suites with native SDKs, floating licences, offline activation and dongles. If you sell into enterprises with air-gapped installs and procurement paperwork, that is genuinely their ground. The cost is an SDK per platform and a sales process to get started.
Closest in spirit
Keygen
Developer-first licensing over an HTTP API with a source-available core you can host yourself. Same instinct as ours: no SDK to wait for. We put our effort lower down, into the anti-tamper layer and the forensics that name the account behind a leak.
Same audience, different build
KeyAuth and similar
Cheap, quick to bolt on, hardware locking and reseller flows included. We cover that ground and add the hardened session protocol above, with every vendor's signing keys and key hashes sealed under their own crypto so one tenant's bad day is not everyone's.
Partners
Proven in production.
Licentry keys are in production today.
Advanced Mechanics PARTNER 001
Our first official partner. Belgium-based Advanced Mechanics licenses its software with Licentry: hardware-bound keys, runtime sessions and signed responses for 1,500+ customers.
advanced-mechanics.com
Plans
Early access. Founding rates.
Licentry is onboarding its first wave of vendors. Founding integrations keep their launch rate for as long as the subscription stays active, and a lapse ends the lock. You pay by card in the dashboard; crypto is available on request through support. A new account can start a free one-week dev trial: 1 product, 3 keys, wiped unless you subscribe.
Indie
For a first product
$19 /mo
or $150/yr (34% off)
- Hosted licensing API
- 500 active licences
- Up to 3 products
- Device binding & session caps
- Signed responses
- DPoP sessions, offline grace and sharing evidence
Studio
For serious catalogs
$59 /mo
or $468/yr (34% off) · founding rate
- Everything in Indie
- 5,000 active licences
- Up to 15 products
- Discord bot: redeem panel, key commands, activity logs
- Self-hosted data: your own dedicated server, on request
- Priority support
Self-hosted data
Your own dedicated server, fully managed, on the Studio plan
- A dedicated server provisioned for your account alone. We set it up by hand, secure it and keep it patched
- Your database and licence data live on that server; the licence cap is what the hardware holds, not a plan number
- Your own Discord bot: hand us the token and it runs from your server, under your branding, separate from the shared Licentry bot
- API on your own domain once you point DNS at us, or the standard licentry.cc endpoints
- Everything in Studio, plus dedicated priority support from the engineer who runs your server
- Priced per setup, server and upkeep included · limited slots
CARD BILLING IN THE DASHBOARD · CRYPTO ON REQUEST THROUGH SUPPORT · MONTHLY OR YEARLY · FOUNDING INTEGRATIONS KEEP THE LAUNCH RATE WHILE THE SUBSCRIPTION STAYS ACTIVE.
PRICES EXCLUDE VAT. VAT IS ADDED AT CHECKOUT WHERE IT APPLIES.
NEED MORE ROOM? ADD EXTRA ACTIVE LICENCES TO ANY PAID PLAN, $1 PER 100 PER MONTH, UP TO 10,000 EXTRA.
FAQ
Common questions
How long does integration take? +
The core loop is five endpoints: validate, activate, heartbeat, refresh, logout. A minimal integration is an afternoon; adding response-signature pinning, DPoP and offline grace is typically another day. The docs walk through every step with copy-paste examples.
Which languages and platforms are supported? +
Anything that speaks HTTPS and JSON. There is no SDK to wait for: the client side is five endpoints. Every signature channel is ECDSA P-256 specifically so native Windows clients can verify with built-in BCrypt and no extra crypto dependencies. The docs carry working examples in twelve languages, C++, C#, Python, Node.js, Go, Rust, Java, PHP, Swift, Kotlin, Ruby and plain cURL, and you can switch the whole page to yours with one click.
What actually happens when a key leaks? +
Device caps stop it activating on new machines. Concurrent-session caps stop parallel use. The sharing-evidence view shows you devices, IPs and geography per key. One click bumps the revocation version and every bound session dies on its next heartbeat. If the leak was a whole Windows binary, its watermark tells you which account it came from.
Do licensed apps work offline? +
Yes. Activation can return a short-lived, device-bound offline-grace token (an ES256 JWT your app verifies locally). It currently lasts 72 hours, which is long enough to cover a weekend of downtime on our side without your customers noticing. Revoked licences run out of grace instead of running forever, so the window is also the longest a revoked key keeps working offline.
Can we self-host Licentry? +
The self-hosted data plan gives you a dedicated server of your own. We provision it manually, secure it and keep it updated; your database and licence data live there instead of on shared infrastructure, with room for as many licences as the hardware holds. It can also run your own branded Discord bot (you hand us the token, we host and wire it up) and serve the API from your own domain once you point DNS at us. The licensing engine itself stays managed by us, so there is nothing for you to patch. Pricing is per setup since needs differ, and slots are limited because every server is maintained personally. Write to [email protected] to talk it through.
How do payments work? +
Card, from the dashboard. The card form is served by Stripe inside our page, so your card number goes straight to Stripe and never reaches us. Each payment buys one period and does not authorise a later charge, so you start the next period yourself when you want it. Prices exclude VAT, and VAT is added at checkout where it applies. Crypto is still available on request: write to [email protected] and we raise an invoice naming a currency, an exact amount, an address and a chain. A payment matching all four is what we can credit automatically; a late one, or one sent on a chain we did not quote, has to be sorted out by hand.
Get started
Ship software that
Ship software that
stays paid for.
Integrate in an afternoon. Sleep through the next bypass attempt.