rymga Licenses

Your own license system for the software you sell. Issue keys, lock them to machines, gate features by plan, and revoke the ones that leak — checked from your app in any language, over a plain HTTP endpoint whose answers are signed and impossible to forge.

What it is

rymga Licenses is a hosted licensing backend. You get a private space (a tenant) where you define your products, issue license keys to your customers, and see every activation. Your software calls one endpoint to ask “is this key valid, here, right now?” and gets back a signed verdict it can trust.

It is not tied to any language or platform. Anything that can make an HTTPS request can integrate — a Java plugin, a Node service, a Python tool, a C# desktop app, a Go binary. There's a zero-dependency Java SDK, and the raw contract is documented so any other language integrates directly.

Server-locked keys — cap a key to N machines, with an IP limit per machine.
Signed validation — every response is signed with your private key; your app verifies it.
Tiers & feature flags — unlock exactly what a customer paid for.
Expiries — perpetual or time-boxed licenses.
Blacklist & revoke — kill a key, IP, server or customer everywhere at once.
Panel & Discord bot — issue and manage keys from a dashboard or from Discord.

Concepts

Term	What it means
Tenant	Your private space, addressed by a `slug`. Its own keys, products and signing keypair.
Product	One piece of software you sell, addressed by a `productCode`. A license belongs to one product.
License key	The credential you give a customer, e.g. `RYMGA-XXXX-XXXX-XXXX`.
Tier	The plan a license is on (e.g. `BASIC`, `PRO`). Drives what unlocks.
Feature flags	An arbitrary map returned with a valid key — your app reads it to switch features on.
Server cap	How many distinct machines a key may run on, keyed by a `serverId` fingerprint.
IP limit	How many distinct IPs are allowed per activated machine.

Issuing keys

You never write a line of code to create licenses. Two ways:

Web panel — create products, issue keys, set tiers, caps and expiries, and watch activations. Blacklist or revoke with one click.
Discord bot — issue and look up keys, grant time, and link a key to a customer from your own server. Customers can self-serve their keys with /mylicenses.

Keys live on our side, not in your build. You ship the same binary to everyone; what a given customer can do is decided at validation time from their key — so you can change tiers, extend expiries or revoke access without re-shipping.

Checking a key

Your software sends the key, the product code and a machine fingerprint to the validation endpoint. The backend answers with a signed verdict; your software verifies the signature and acts on it.

Collect the customer's license key (from a config file, env var, or first-run prompt).
Compute a stable serverId for the machine (see Validation API).
POST to the validate endpoint with a fresh nonce.
Verify the signature on the response with your embedded public key.
Trust the verdict only if the signature checks out — then read tier and featureFlags.

Do this at startup and periodically while running — not just once.

Where to start

Read the Validation API — the endpoint, request and response.
Then Verifying the signature — the part you must get right.
On the JVM? Drop in the Java SDK. Elsewhere, the same page has complete, working HTTP examples.

Validation API →