Accounts for your customers, keys that unlock each feature for as long as you choose, and every key locked to their device.
Set up your first product in a minute.
Everything you need to license software, in one place
You decide what a key is worth. Keyfly makes sure only the right person, on the right device, gets it.
Split your software into the parts you sell: “pro”, “export”, “module_x”. One feature is enough if it is all-or-nothing.
Pick what a key unlocks and for how long. Make one, or 500 at once. Send one to each customer, by hand or from your store.
The customer logs in and redeems the key. Your app gets a signed list of what they can use on that device, and checks again while it runs.
The dashboard does the daily work. The API does the same from your own tools.
RAZ3B-ZMUP5-…-WM926proexportExpires in 12 monthsActiveJMEQR-G9FPF-…-VR9GSproExpires in 30 daysActiveXPHG3-ZU9P2-…-HENFVmodule_x1 year once redeemedUnusedSell the base app for a year and an add-on for a month. Each key carries what it unlocks and how long it lasts, and a customer can stack as many as they buy.
The first device to use a key is linked to it. A key passed to a friend is refused. Choose how many devices each key allows.
A refund, a renewal or a new laptop: each is one click, and takes effect the next time the app checks in.
Sign-up, login and bans, with passwords you never have to store yourself. Or skip accounts and use keys alone.
Logins, redeemed keys, wrong passwords and blocked devices, in one timeline you can filter.
A mod breaks after a game patch? Switch it off with a message. Your launcher stops it within minutes, everything else keeps running, and nobody loses their key.
1.5.0Security fix for saved sessionsLatestRequired1.6.0New export formatsBeta1.4.2Faster startupUpload a build and every copy of your software learns about it at its next check. Mark it required and older versions are refused until they update. Keyfly works out the checksum and hands out private links that expire, all inside the signed answer, so a swapped file is caught before it runs.
Send the request, check the signature, read what the user can use. No SDK to install: it is a few lines you can read in full.
import { createPublicKey, randomBytes, verify } from "node:crypto"
const API = "https://keyfly.mirandanetwork.es/api/v1/client"
const APP_ID = "app_YOUR_APP_ID"
const PUBLIC_KEY = "YOUR_PUBLIC_KEY" // safe to ship inside your app
const pub = createPublicKey({
key: Buffer.concat([Buffer.from("302a300506032b6570032100", "hex"), Buffer.from(PUBLIC_KEY, "base64")]),
format: "der",
type: "spki",
})
export async function keyfly(action, hwid, body = {}) {
const nonce = randomBytes(16).toString("hex")
const res = await fetch(`${API}/${action}`, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ app_id: APP_ID, hwid, nonce, version: "1.0.0", ...body }),
})
const r = await res.json()
if (!r.ok) throw Object.assign(new Error(r.error.message), { code: r.error.code })
// Never skip this: it is what stops a fake server from unlocking your app.
if (typeof r.payload !== "string" || typeof r.signature !== "string") throw new Error("bad signature")
if (!verify(null, Buffer.from(r.payload), pub, Buffer.from(r.signature, "base64"))) throw new Error("bad signature")
const data = JSON.parse(r.payload)
const fresh = Math.abs(Date.now() / 1000 - data.iat) < 300
const mine = data.app === APP_ID && data.action === action && data.nonce === nonce && data.hwid === hwid
if (!mine || !fresh) throw new Error("bad response")
return data
}
// Log in, then gate a feature
const me = await keyfly("login", hwid, { username, password })
const has = (feature) => me.entitlements.some((e) => e.feature === feature && e.status === "live")
if (!has("pro")) throw new Error("You need a Pro license")
// Redeem a key the user typed
await keyfly("redeem", hwid, { session: me.session, key: "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX" })
// Every few minutes while the app runs
await keyfly("check", hwid, { session: me.session })No black box. This is how each piece is protected, and the one thing no licensing service can promise.
125 random bits each. A key holds no data, so there is nothing to decode: the only way to learn what it unlocks is to ask the server.
Every answer is signed with a key pair unique to your product. A fake server, an edited answer or one replayed from yesterday fails the check in your app.
Each key is linked to the devices that first use it. Hardware IDs are stored only as a keyed hash, never as sent.
Passwords use Argon2id with a server-side secret. Sessions and API keys are stored as fingerprints. Keys are encrypted with a key kept outside the database.
Limits per address and per product on every call, and a growing wait after wrong passwords. Nobody can be locked out for good by someone else's guesses.
Every lookup is scoped to your account. An ID that belongs to another seller answers “not found”, the same as one that doesn't exist.
The honest limit. Code running on a customer's computer can be modified by that customer. Keyfly stops forged, shared and revoked keys; it can't stop someone patching your program. Keep the valuable part behind your own server for that.
# Create 5 keys that unlock "pro" for 30 days
curl -X POST https://keyfly.mirandanetwork.es/api/v1/apps/app_YOUR_APP_ID/licenses \
-H "Authorization: Bearer $KEYFLY_API_KEY" \
-H "Content-Type: application/json" \
-d '{"features": ["pro"], "duration": "30d", "count": 5}'
# A customer changed computer: unlink their devices
curl -X POST https://keyfly.mirandanetwork.es/api/v1/licenses/XXXXX-XXXXX-XXXXX-XXXXX-XXXXX/reset-hwid \
-H "Authorization: Bearer $KEYFLY_API_KEY"Everything in the dashboard is also one request away. Create a key the moment an order is paid. Let your support team reset a customer's devices from a slash command.
Straight answer: nobody can forge a key, share one across devices or keep using one you revoked. What no licensing service can stop is a skilled person modifying the program on their own computer to skip the check. To raise that bar, keep the valuable part behind your own server and have it check the user's features with Keyfly.
Whatever you name. You create features such as “pro”, “export” or “module_x”, and each key lists the ones it unlocks and for how long. A customer can hold several keys at once, each with its own expiry.
When the customer redeems it, not when you create it. A 30-day key you made in January and sold in March gives 30 days from March.
Open their key and choose Reset devices, or call the reset endpoint from your Discord bot. The next device to use the key is linked instead.
By default, yes: they sign up inside your software and redeem keys into their account. If your software has no login screen, turn on key-only mode and a key alone unlocks its features.
Yes. The Management API does everything the dashboard does: create keys when an order is paid, revoke them on a refund, reset devices from a slash command. The documentation includes a working Discord bot example.
Yes, it is built for it. Make each mod a feature. Before login the launcher asks for the product's status: your announcement, whether it must update itself, and each mod's state and version. After login it gets what this user owns, with each mod's newest release. Put one mod under maintenance and the launcher stops just that one, with your message.
Yes. Publish a release and mark it required: older versions are refused on every call and told where the update is. The download link and its checksum come inside the signed answer, so your software can check the file before running it.
Any language that can send an HTTPS request and check an Ed25519 signature, which covers C#, C++, Python, Node.js, Go, Rust, Java and the rest. There are ready-to-paste clients for Node.js and Python.
Your software decides. The signed answer includes when each feature expires, so you can keep a user working for a grace period you choose and check again later.
Create a product, name a feature, make a key. Then paste one function into your software.