Every answer to your software is signed

Sell your software. Decide who can run it.

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.

Your software
License key
RAZ3B-ZMUP5-ZL8ZJ-S77LN-WM926
Pro editor30 days left
Export module1 year left
Behind the scenes
  1. Customer pastes their key
  2. Keyfly checks key and device
  3. Your app verifies the signature
  4. Features unlock
Linked to 1 of 1 devices Signed answer

Everything you need to license software, in one place

  • Accounts for your users
  • Keys per feature
  • Any duration, or never expires
  • Device lock
  • One-click device reset
  • Signed answers
  • Build uploads
  • Forced updates
  • Maintenance per module
  • Launcher status
  • Bans
  • Activity log
  • Several products
  • REST API
  • Read-only API keys
  • CSV export
How it works

From “paid” to “unlocked” in three steps

You decide what a key is worth. Keyfly makes sure only the right person, on the right device, gets it.

  1. Name your features

    Split your software into the parts you sell: “pro”, “export”, “module_x”. One feature is enough if it is all-or-nothing.

  2. Create keys

    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.

  3. Your software asks Keyfly

    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.

Features

Built for people who sell software for a living

The dashboard does the daily work. The API does the same from your own tools.

RAZ3B-ZMUP5-…-WM926proexportExpires in 12 monthsActive
JMEQR-G9FPF-…-VR9GSproExpires in 30 daysActive
XPHG3-ZU9P2-…-HENFVmodule_x1 year once redeemedUnused
One key, several features, its own clock

Sell 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.

Device 1
Linked 3 days ago
Linked
Another computer
Tried 2 minutes ago
Blocked
Locked to their device

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.

Add time
View devices
Reset devices
Revoke key
Revoke, extend, reset

A refund, a renewal or a new laptop: each is one click, and takes effect the next time the app checks in.

Mmarta.rActive key
DdevonActive key
Kkenji_tBanned
Real accounts for your users

Sign-up, login and bans, with passwords you never have to store yourself. Or skip accounts and use keys alone.

marta.r redeemed a keyKey redeemed
Someone tried a key that was not validKey rejected
devon was blocked on a new deviceDevice blocked
See every attempt

Logins, redeemed keys, wrong passwords and blocked devices, in one timeline you can filter.

Skyblock modLive
PvP modMaintenance
Updating for 1.21. Back in 2 hours.
Map toolsLive
Maintenance, one module at a time

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 sessionsLatestRequired
1.6.0New export formatsBeta
1.4.2Faster startup
Ship updates, and force the ones that matter

Upload 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.

For developers

One function in your app

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.

  • Seven calls: status, register, login, check, redeem, key-only, logout
  • The same answer shape every time
  • Plain error codes you can branch on
  • Works in any language with HTTPS and Ed25519
Open the documentation
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 })
Security

Know exactly what you are relying on

No black box. This is how each piece is protected, and the one thing no licensing service can promise.

Keys can't be guessed or forged

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.

Answers can't be faked

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.

Keys can't be shared

Each key is linked to the devices that first use it. Hardware IDs are stored only as a keyed hash, never as sent.

A leaked database isn't enough

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.

Guessing is slowed down

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.

Your data stays yours

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"
Automate it

Your store and your Discord bot can do it for you

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.

Discord bot example included
Full-access and read-only API keys
One key for all your products
The activity log, over the API
FAQ

Questions sellers ask first

Can someone crack my software if I use Keyfly?

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.

What exactly can a key unlock?

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 does a key's time start?

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.

A customer bought a new computer. Now what?

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.

Do my users need an account?

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.

Can I manage keys from Discord or my store?

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.

I'm building a launcher that starts mods or plugins. Does this fit?

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.

Can I force everyone to update?

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.

Which languages does it work with?

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.

What happens if Keyfly is unreachable?

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.

Your next sale can ship with a key.

Create a product, name a feature, make a key. Then paste one function into your software.