A licence key
the thing you send after they payA short code, something like ACME-4K2P-8ZQD. Your customer
types it into your program once. Until they do, the paid parts of your program do not
open.
Licence Keys for Your Software
Sell your software. Keep control of it.
Sell one Windows program as a free trial, a one-time purchase, a subscription or a basic version with paid extras, and stop one paid copy running on ten computers. A licence key tells your program exactly what it may do, and you can see where each copy runs, move it, or switch it off.
Same program — the key decides
Let them try it for a month on one computer. The expensive parts stay switched off — the program they downloaded simply never opens them.
They pay once and it never expires, on up to three of their computers. Batch export is included; the two heavier tools are sold separately.
They pay monthly, and the renewal happens by itself in the background. Five people can use it at a time — whoever opens it first.
They already own the basic version and now buy the extras. Everything switches on where it is — no new key to install, nothing to download again.
Working · 22 days left · keeps working for 3 days without internet
Working · never expires · 2 of their 3 computers used so far
Working · renews on its own · the slot frees up when they close it
Working · added on top of the licence they already had
Press the four buttons. The licence key is invented, but everything that changes underneath is what the product really does.
Software licensing has its own vocabulary, and none of it is obvious. Here is the whole of it in six sentences. Everything further down this page is built out of these ideas.
A short code, something like ACME-4K2P-8ZQD. Your customer
types it into your program once. Until they do, the paid parts of your program do not
open.
The moment their computer checks that key and gets permission to run. It takes a second and happens once — after that your program remembers, and quietly confirms in the background from time to time.
The licence works on that machine and no other. Copy the program to a second computer and it will not run there — which is exactly what stops one paid copy becoming ten.
Instead of naming computers, you sell a number. Buy five and any five people can be using the program at the same time; when one closes it, the next person gets their turn. Thirty engineers, five licences, nobody administering it.
Plenty of industrial and defence machines are kept off the network deliberately. They are licensed by carrying two small files across on a USB stick — one out, one back — and it works exactly as well.
A licence you cancel stops working, and stays stopped even if the customer reinstalls, restarts, or unplugs the network. Useful when an invoice goes unpaid or a laptop walks out of the building.
You build and ship one thing. Which of these four a customer gets is decided when you issue their key, not when you build — so adding a subscription option, or a cheaper trial, costs you nothing in development.
Runs for as long as you decide, usually on one computer, with the parts you would rather not give away left switched off.
The ordinary sale. It never expires, and you decide how many of their computers it covers.
Shortly before it runs out, the licence quietly extends itself. Your customer does nothing and notices nothing.
A second, smaller licence that adds features to the one your customer already bought.
Inside your program this is one line of work. It asks whether this customer's licence includes a named feature, and switches that part of the screen on or off accordingly. Your developers write no licence checking, no expiry dates, no key handling — those live in the licensing system, which is the point of buying one.
Rather than listing which computers may run your program, you sell a number of slots. Whoever opens it takes one; when they close it, the next person gets it. Nobody has to manage that, and your customer stops arguing about how many copies they need.
WS-014 took a slot at 09:14 and is holding it while the program is open. Try either button and watch the count.
The other way round: the licence is locked to a single computer, recognised by its own hardware. Install the program somewhere else and it will not run there — it says this is a different machine and waits for you to approve the move.
That is the right choice for a machine you sold, a controller on a factory floor, or anything that will never reach your server. Air-gapped activation is node-locked only — counting shared slots needs a server to count them, so a licence cannot be both shared and offline.
Your program does not have to know which kind it is. You choose per customer when you issue the licence, and nothing in your software changes.
The panel above is a drawing of how this really works, not a live connection to a licensing server.
Plenty of the machines worth licensing will never see the internet — a controller in a plant, an inspection workstation on an isolated network, anything inside a defence installation. A USB stick and two minutes, and that machine is licensed properly.
Your application writes a request file on the offline machine. It carries that machine's fingerprint and nothing a customer needs to understand.
Upload the request in the console, choose the customer and the licence terms, and download the signed response.
“A customer with an air-gapped machine sends you a .c2v
file. Upload it, choose the customer and license terms, and download the signed
.v2c.”
When the licence has to move to another machine, the offline machine produces a receipt. Upload that and the seat is free again — the transfer is auditable in both directions.
The response only works on the machine that asked for it.
The .v2c is an authenticated envelope sealed to that machine's
fingerprint, so a customer who copies it to a second machine does not get a second licence —
they get a failed authentication tag. This is the part a hand-rolled licence file almost never
gets right.
This is where a bought licensing system earns its money. Eight situations, each one already thought through, so your software behaves sensibly instead of guessing — including the awkward ones, like an engineer whose laptop has been off the network for two days.
No licence yet
ActivationRequiredEverything is fine
ActiveBeen offline a while
GraceIt ran out
ExpiredDifferent computer
HardwareMismatchYou cancelled it
RevokedSomeone moved the clock
TamperSuspectedThe licence file broke
CorruptFilled dot: your software runs. Hollow dot: it stops, and it can say exactly why. The small grey line on each card is the name your developers will see in the code. How often it checks in, and how long it keeps working offline, are yours to set.
Anyone can compare a string to a key. The interesting cases are the copied licence file, the clock set back a year, the rolled-back virtual machine, and the licence that has been revoked but keeps working because the software forgot.
A separate Windows background service holds it, and your program only ever asks it questions and gets yes or no back — never the licence, never the secret. Someone pulling your program apart to strip the licence check out of it finds nothing to strip, because the decision was never made in there.
HTTPS with SPKI SHA-256 certificate pinning that cannot be overridden at
runtime, so a proxy with a trusted root does not get to listen. Each product authenticates
with its own HMAC-SHA256 secret.
X25519 key agreement with ChaCha20-Poly1305 authenticated
encryption. The response is bound to the requesting machine's fingerprint — elsewhere it
fails the tag check rather than degrading quietly.
Every check writes to a rollback ledger. A system clock set back, or an update counter that
decreases because a virtual machine was restored from a snapshot, produces
TamperSuspected — the two oldest tricks in the trade.
Revoke a licence and it stays revoked through restarts, reinstalls and time offline, because the decision is recorded in the machine's own encrypted ledger rather than depending on the next successful server call.
Encrypted on disk with a SYSTEM-only ACL; vendor codes are writable by
administrators alone. A damaged store recovers automatically from up to three rotated
encrypted backups.
Every shipped file is listed in a SHA-256 manifest, so a swapped DLL is a
detectable event and not a mystery support ticket.
Licensing arrives as a small Windows background service plus two files that sit beside your program. Nothing about how you deliver your software changes — your installer gains one step, and there are four ways to add it.
Installs the service, sets the permissions and starts it. On upgrade it stops the old service, replaces the files and restarts.
Copy the service\ folder and run it once with
--install. For a developer box or a CI runner.
For teams whose product already ships as a WiX-authored MSI or bundle. The complete XML is in the manual.
For products whose shipping installer is an InstallShield project, with the click-path documented step by step.
Fourteen sections written for whoever does the work, including the one that matters on a bad afternoon: every error message your team could hit, listed word for word with what to do about it. Downloadable, and it prints.
Most product companies want their revenue protected. Very few want to operate a licensing back office to get it.
We run it
We add licensing to your software and operate activation, seats, renewals and revocation on your behalf. You get the console access you need and none of the responsibility for keeping a licensing service alive.
You run it
The licensing system itself, running under your control, with your own team issuing licences and managing seats. For companies that need licensing to be theirs — because of a procurement rule, a data-residency requirement, or simply preference.
What the product is, how it is installed today, and how you would like to sell it — trials, subscriptions, modules, concurrent seats, or machines that never see a network. We will tell you what the integration looks like in your codebase before anyone signs anything.