Signed
Licenses verify offline
JUCE / C++
Native SDK
-
Just-in-time minting
1 click
Revoke everywhere
The Problem
Audio software has a licensing problem
Piracy is endemic, activation friction pushes honest buyers away, and every plugin company ends up rebuilding the same key server from scratch.
55%
of music-software users admit they've run unlicensed plugins
80%
say affordability is why people pirate — trials and tiers convert them
82%
prefer a simple serial number over dongles and challenge codes
Source: IMSTA, “Let's Talk Piracy” survey (2022)
01. Piracy
Cracked builds ship faster than updates.
Popular plugins are cracked and shared within days of release, and a majority of users have run one. A bare serial check is not a defence — it's an invitation.
02. Friction
Heavy protection punishes the people who paid.
Dongles, machine locks and re-authentication mid-session are the complaints buyers cite most. When activation fails in a studio, the cracked copy starts looking like the reliable one.
03. DIY
You're a DSP developer, not a license-server admin.
So every plugin company hand-rolls keys — a PHP script, a spreadsheet, serials pasted into store emails — and it breaks on the busiest day of the year: release day.
The Solution
Issue a licence. Validate it. Kill it.
The whole loop, playing out below — no account needed. In the real product you mint keys from the dashboard, your plugin validates them through the SDK, and one click kills a leaked key on every machine.
No licence yet
•••••-•••••-•••••-•••••
Waiting for a request…
That is the whole loop — mint, validate, revoke. The dashboard and SDK do it for real.
Try it FreeHow it works
Four steps, and you are selling licensed software
Step one
It starts with the SDK
Generate an API key in Settings, drop the JUCE module into your CMake build, and construct the Core with your key and product slug. From then on your plugin can ask one question — is this licensed? — and everything else is handled for you.
Read the SDK docsOne key per environment. Rotate it whenever you like — the plugin picks up the new one on its next check-in.
# point JUCE at the modulejuce_add_module("${POLARIS_SDK_DIR}")target_link_libraries(MyPlugin PRIVATEpolaris_licensing_sdk)
auto core = std::make_shared<polaris_licensing_sdk::Core> (endpoint,api_key, // from Settings → API Keys"nebula-synth", // your product slugdevice_id);if (! core->hasValidLicense())showActivationDialog(); // opens your hosted form
Step two
Then you mint your keys
Pick a product, choose how many keys you need, and mint. Keys follow whatever pattern you set per product, so they stay recognisably yours. Mint a batch for a distributor, or just-in-time when a store order lands.
Step three
Your customer lands on a form you built
The page where a key gets redeemed. Choose what you collect, style it to match your product, and publish — no front-end work and no redeploy when you want to change a colour. Build it below, then switch to themes to skin it.
Licence key, device ID and product ID are always there. The last two are filled in by the SDK and never shown to the customer — everything else is yours, and whatever you collect lands on the licence record.
The default. Dark, quiet, gets out of the way.
Where the key gets entered — every form ships with all three.
Step four
And then you manage licences
Every activation lands on a licence record: which machines it is bound to, how many seats are left, when each last checked in. Free a seat, revoke a key after a chargeback, or let the customer de-register a device themselves.
Platform
Everything after the sale, in one dashboard
Mint keys, watch activations land, revoke a leaked licence, and publish the page your customers redeem on. No spreadsheet, no bespoke admin panel to maintain.
Analytics
Know what's happening, before it's a problem
The Overview answers the questions that matter: how many licenses are live, which devices are checking in, where every key stands, and whether you'll run out before release day.
Architecture
One dashboard. One API. One SDK.
Three surfaces, one system: a dashboard to mint and manage keys, a REST API for activation and check-ins, and an SDK that validates inside your plugin. Plus a hosted page your customers activate on.
Your Software
Plugin SDK
Polaris
Mint & Validate
Your Customer
Activates Instantly
01 — Dashboard
Key Management
Mint · Batch · Just-in-time · Revoke
02 — Overview
Analytics
Licenses · Devices · Check-ins · Runway
03 — Records
Transaction Log
Every mint, activation and revoke, recorded
Developer Experience
Live in a day.
Not a quarter.
One REST call to validate a license. Drop our C++/JUCE SDK into your plugin and you're done.
Product
Stripe, for software licensing
Issue keys, bind them to devices, publish the activation page, and see what is happening — from one dashboard and one API.
Key Management
Mint keys one at a time, in distributor batches, or just-in-time from store orders. Revoke a leaked key from the dashboard in one click.
Overview Dashboard
Live counts of licenses, devices and check-ins, key-status breakdowns, and per-product key runway — will you run out before release day?
Device & Seat Control
Bind a licence to a set number of machines. Customers see what is activated and can free a seat themselves, if you allow it.
Products & Catalogue
Model what you sell, then attach key patterns, seat limits, and forms per product. Transactions reconcile against it.
Secondary Market
Verified license transfers between users. Developers set resale policy and retain full control throughout the transfer.
Coming SoonData Intelligence
Advanced analytics on demand, distribution, and usage — so vendors understand customer behaviour across every channel.
Coming SoonReliability
Your plugin opens whether or not we are having a good day
Licensing sits between your customer and the thing they paid for. That is a hard place to put a dependency, so we treat an outage on our side as our problem — never theirs.
0
Network calls needed at launch
Signed
License files verify offline
Monthly
Check-in refreshes the license
2 years
License term per activation
Offline validation
The SDK verifies a signed license file stored on the machine — opening the plugin needs no network at all. A monthly check-in refreshes the file in the background when a connection is there.
Air-gapped activation
For studios with no network, the licensing dialog exports a file. Activate it on the Polaris website from any connected machine, import it back, done. No dongles, no support ticket.
Degrades, never fails closed
Revocations and seat changes apply at check-in, not at every launch. If Polaris is unreachable, an activated install keeps opening from its locally signed license — an outage on our side never locks out a paying customer.
Pricing
One plan. Every feature. Pay for usage.
No feature gates, no contracts. Your price is set by active licenses alone — and each one gets cheaper as you grow.
Try for free
Full-featured — every feature, the SDK and the key testing tool, with up to 100 active licenses. No card required.
The one limit: keys can't be issued through a live form until you upgrade.
Polaris
Tier 1$588 billed annually
Need more than 250,000? Talk to us
Everything included, at every tier
- Unlimited products and versions
- Mint keys on demand — or just-in-time from store orders
- Activation, deactivation and per-device limits
- Signed licenses that validate offline, with device check-ins
- One-click revocation, dead on every machine
- Custom activation and unlock forms
- Store integration — connect where you already sell
- Overview dashboard — licenses, devices, check-ins, key runway
- REST API plus JUCE / C++ SDK
- Bulk import to migrate existing keys
What you actually pay for
An active license is one that has validated at least once in the last 90 days. You are billed on the peak count within the month, so a release-day spike does not follow you into the next one.
Billed
- A key that validated in the last 90 days
- Each license once — not once per machine it is bound to
- A converted trial, from the day it converts
Not billed
- Revoked, refunded, or expired keys
- Trials, until they convert
- Keys minted but never activated
- Seats, teammates, API calls, or validations
Questions? Get in touch
Questions
The things people ask before they sign up
Answered here rather than in a sales call.
Still deciding? Book a demo or read the documentation. The chat in the corner answers the short ones instantly.
Ready to protect
your software?
Join the audio developers using Polaris to issue and manage their license keys.