What makes plugins different
A desktop app starts, shows a window and runs. A plugin is loaded by someone else’s program, possibly dozens of times in one project, in a format that depends on the DAW. The license check has to fit around that.
Never on the audio thread. The audio callback has a strict time budget. A network call, a file read or a lock on it can cause dropouts. Do all License API work on a background thread, publish the result in an atomic flag, and have the audio code read the flag.
Not at scan time. Some DAWs load each plugin during a scan to read its name and parameters. A check at that moment can be slow, can fail with no UI, and can annoy users when the scan happens at every launch. Verify nothing over the network in the constructor. Read the stored token, verify its signature locally, and start a background validation only when an editor opens or processing starts.
Many instances, one license. Opening a project with 30 instances of your plugin must not make 30 License API calls. Share the state in one process-wide object, and rate limit yourself. The License API allows 60 requests a minute per key; 30 simultaneous checks would use half.
Several formats, several DAWs, one machine. A buyer may use the VST3 in one DAW, the AU in another and AAX in a third. Each is a different binary and may run as a different user. If every one stores its license in its own place, one purchase uses several seats. Pick one machine-wide folder, created by your installer with permissions that let every user read and update it: /Library/Application Support/YourCompany/ on macOS, %ProgramData%\YourCompany\ on Windows. If you must store per user, accept that each user account is a device.
Signing. Apple’s Developer ID guidance says to sign “any apps, plug-ins, or installer packages” you distribute and to notarize them. An unsigned plugin bundle may be blocked on a Mac before your license code runs. See the macOS page for the rules.
Studios are often offline
A recording studio can be on a locked-down or absent network, and a laptop on a stage has no Wi-Fi. A signed token lets the plugin verify its license with no call, and the token carries refresh_by, 14 days after the last successful validation. After that window you choose what happens, and the choice is a product decision:
Policy after refresh_by with no network |
What the user sees | Risk |
|---|---|---|
| Keep working, show a quiet banner in the editor | A reminder to connect once | A user who never connects is never checked |
| Keep working for a grace period of, say, 30 more days | The banner, then a restriction | Lenient but bounded |
| Block processing | Silence or a demo mode | A live show or a session can fail at the worst moment |
Whatever you pick, do not change the audio mid-session. A license state that flips while someone is recording is the worst result. Apply restrictions the next time the plugin loads, not while it runs.
Recommended setup
| Setting | Suggested value | Why |
|---|---|---|
| License type | Perpetual, with paid upgrades for major versions | Projects must reopen years later, so a perpetual key is the safe default |
| Device limit | 2 or 3 | A studio computer, a laptop and a reinstall |
| Trial | 14 to 30 days, or a demo mode with limited output | Producers want to try a plugin in a real project |
| Updates | The installer checks the releases endpoint | One download per platform, labelled macos and windows |
A “deactivate” button inside the plugin lets a producer free a seat before wiping a machine. If they forget, the device page lets them remove it without writing to you.
Selling a suite
Clavem issues one key per product. A suite is a product of its own, and a checkout with several mapped products issues a license for each one. For an “everything” bundle, choose:
- Separate keys. The buyer of the bundle gets one key per plugin, and each plugin checks its own product’s
pid. Simple, and a customer finds seven keys in the email. - One suite product. Each plugin accepts a token from its own product or from the suite. Each product has its own signing key, so the plugin carries both public keys and checks the token’s
pidagainst the matching one.
Whichever you choose, check pid as well as the signature, so a key for a cheap plugin does not work in an expensive one.
Large downloads
Sample libraries and plugin installers are big. Each release file can be up to 5 GiB, and plans include storage: 1 GB free, 10 GB on Indie, 50 GB on Studio. As an example, a 3 GB installer for each of macOS and Windows is 6 GB for one version, and a second version needs 6 GB more until you delete the old one. That is a reason to start on Studio, or to delete old releases. Downloads themselves are not metered. See releases and downloads.
Doing this with Clavem
Create a product per plugin, connect Stripe and map each price. After payment, the buyer gets a key, an order page and the installer. The plugin calls activate the first time the user enters the key, validate from a background thread, and deactivate from a menu. The JUCE guide shows the pattern in a JUCE plugin, and the C++ guide covers other frameworks.
Guides to follow
- License key validation in JUCE
- Offline license verification in JUCE
- Device activation in C++
- Software updates in JUCE
Questions
Where should a plugin store its license?
In one machine-wide location that the installer creates, so VST3, AU, AAX and standalone versions, and every DAW and user account on the computer, share one activation and one device slot. A per-user store counts each account as a device.
Can a plugin check its license while audio is playing?
It should never do the check on the audio thread, and should not hold up the DAW. Run the network call on a background thread, keep the result in an atomic state, and let the audio code read only that state.