Sales are not open yet. You can create an account and use the free dev trial today; nothing can be bought until launch.

Software licensing for your app

Issue licence keys, set device limits and manage access through an API. Your app checks the licence while it runs, so a revocation takes effect at the next heartbeat.

One session, from activation to revocation
  1. POST /v1/sess/activate200Session issued, response signed
  2. POST /v1/sess/heartbeat200seq 1, next nonce returned
  3. POST /v1/sess/heartbeat200seq 2, still licensed
  4. YouRevoke the licence in your dashboard
  5. POST /v1/sess/heartbeat401 revokedThe running copy stops

Every response carries an X-Licentry-Sig signature your app checks against a key it ships with.

Licence protection

Device-bound sessions

With proof of possession enabled, copying a session token isn't enough to use it on another machine. Requests also need a signature from the device's private key.

Signed responses

Your app checks Licentry's signature before accepting a response, using a public key included in the app. This lets it reject forged replies from a fake licensing server.

Windows build watermarks

Watermarks help you trace a leaked Windows build to the account that downloaded it. Each marked executable includes a build token, account reference and file hash. If someone removes the watermark, that trace is lost.

Licence-sharing reports

Review the devices, IP addresses and locations associated with a licence. Licentry uses session activity and changes in these records to flag possible sharing, so you can inspect the evidence before acting.

Each activation records a device hash. Licentry enforces your device limits on the server.

The integration is five HTTPS calls

The API provides validate, activate, heartbeat, refresh and logout endpoints. Start by issuing a key, then connect your app's activation and session checks.

  1. 1

    Issue vendor API

    Create 28-character licence keys in the dashboard or through the vendor API. Licentry stores HMAC hashes, protected by an account-specific secret, rather than the keys themselves.

  2. 2

    Activate POST /activate

    Send the licence key and device hash to receive access and refresh tokens. Include a DPoP public key to bind the session to that device. Retry the same activation with its original idempotency key.

  3. 3

    Heartbeat POST /heartbeat

    Send regular heartbeats to check that the licence is still valid. Each request includes a sequence number and the previous server nonce, which Licentry uses to detect replays.

  4. 4

    Refresh and revoke POST /refresh

    Refresh tokens before they expire. If you revoke or freeze a licence, its sessions are refused at the next heartbeat.

Pseudocode: the loop your client runs

// 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 rising with each beat
every(heartbeatInterval, [&]{ 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();

Working examples in twelve languages, from C++ and C# to Rust and plain cURL, are in the integration docs.

Additional security controls

Use these controls alongside session checks to protect app configuration and review suspicious activity.

  • Consistent refusal responses. Activation returns the same refusal for an unknown, expired or revoked key. These refusals use the same minimum response delay to limit what someone can learn by trying keys.
  • Protected app configuration. Store configuration your app needs on the server and deliver it encrypted through an active session. Someone bypassing the licence check must also obtain that configuration, for example by extracting it from a licensed copy.
  • Audit records. Review records of login attempts, replayed heartbeats and device resets, including the actor, IP address and event details.
Response signing
ECDSA P-256
Proof of possession
DPoP, RFC 9449
Build watermarking
Per-download token, HMAC
Offline grace
ES256 JWT, device-bound
Sealed engine parameters
AES-256-GCM
Refusal timing
Minimum response delay
Sharing evidence
Devices, addresses, geography

How Licentry compares

Compare licence checks, device limits and tools for investigating shared keys or leaked builds.

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 -✓✓ ✓Limits enforced by the server
Revoked keys stop working while the app is running -Refund only~Next check-in~Varies ✓At the next heartbeat
Can bind tokens to a device -~Uncommon~Uncommon ✓DPoP, RFC 9449
Your app checks signed responses -~Varies~Varies ✓Signed, P-256
Trace a leaked build to the account that downloaded it -~Uncommon~Uncommon ✓Windows watermarks
Shows evidence of licence sharing -~Varies~Basic ✓Devices, IPs, locations
No SDK required ~Webhook only~Platform-specific SDK✓ ✓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

✓ supported   ~ varies by product or plan   - outside its scope. These columns summarise categories, not individual products. Check each provider's current features before choosing.

The first column shows checkout without a separate licensing service. You can keep your existing checkout and use Licentry to check licences while your software runs.

Product by product, with dated sources: Keygen, Cryptlex, LicenseSpring, KeyAuth, or all comparisons.

In production

Advanced Mechanics

A Belgian software company that issues its licence keys through Licentry.

advanced-mechanics.com

Early access pricing

Founding customers keep their launch price while their subscription remains active. If it lapses, that rate no longer applies. All payments go through Stripe, by card in the dashboard. The free dev trial includes 1 product, 3 licence keys and the full API. It stays open until release, and your trial data is kept during that time.

Indie

For a first product

$19 /mo

or $150/yr (34% off)

  • Hosted licensing API
  • 500 active licences
  • Up to 3 products
  • Device binding and session caps
  • Signed responses
  • DPoP sessions, offline grace and sharing evidence
Coming soon

Studio

For multiple products

$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
Coming soon

Self-hosted data

Studio customers can request a dedicated server for their licence data. We handle setup, security and updates. Capacity depends on the server hardware. You can use your own branded Discord bot and API domain after configuring DNS. Pricing includes the server and its maintenance; availability is limited.

Ask about a dedicated server
  • Card billing in the dashboard, through Stripe only. Monthly or yearly.
  • Prices exclude VAT; VAT is added at checkout where it applies.
  • Add up to 10,000 extra active licences to a paid plan at $1 per 100 per month.

Before you integrate

How long does integration take?

Allow an afternoon for the basic session flow and typically another day for pinned response signatures, proof of possession and offline access. The docs include examples for all five endpoints: validate, activate, heartbeat, refresh and logout.

Which languages and platforms are supported?

Your client needs HTTPS, JSON and ECDSA P-256 signature verification. Windows clients can use the built-in BCrypt library. The docs include examples in C++, C#, Python, Node.js, Go, Rust, Java, PHP, Swift, Kotlin, Ruby and cURL. Use the language selector to switch examples throughout the page.

What happens when a key leaks?

Your device and session limits restrict where and how often the key can be used. Check its device, IP and location history in the dashboard, then revoke it if needed. Its sessions are refused at the next heartbeat. A retained watermark can also help trace a leaked Windows build to its source account.

Do licensed apps work offline?

Yes. Activation can return an offline-grace token that your app verifies locally and checks against the current device. This ES256 JWT currently lasts 72 hours. A licence revoked while offline may keep working until that token expires.

Can we self-host Licentry?

You can request a dedicated server for your database and licence data. We set it up and maintain it, including the licensing engine. Licence capacity depends on the hardware. We can also host your branded Discord bot using the token you provide, and serve the API on your domain after you configure DNS. Pricing is per setup and availability is limited. Contact [email protected] with your requirements.

How do payments work?

Pay by card through Stripe in the dashboard. Stripe receives your card details; Licentry does not. Subscriptions renew automatically until you stop renewal in the dashboard. You keep access for the rest of the paid period. For annual plans, we email a reminder at least a month before renewal. Prices exclude VAT, which is added at checkout where applicable. All payments go through Stripe; we do not accept cryptocurrency sent directly to us.

Start a free dev trial

Test your integration with one product, three licence keys and the full API. Your trial data is kept until release.