847K
Licenses Issued
623K
Active
23ms
API Latency p99
142/hr
Issuance Rate
Trusted by developers building the future
The Problem
Software licensing is static in a dynamic world
Developers lose revenue, customers, and insight every day — because no standard licensing infrastructure exists.
61%
of plugin developers use no cloud licensing tool
31%
of software vendors say piracy is a major revenue drain
3
structural failures, every platform, every day
01. Control
Rigid, reactive, and offline.
Current systems can't adapt, respond, or take action in real time. By the time you see the problem, the revenue is already gone.
02. Visibility
Usage is opaque and misunderstood.
Licensing systems track transactions, not behaviour — leaving you blind to real users and real usage.
03. Leakage
Revenue is leaking. You can't see it.
Traditional licensing offers little visibility into misuse, overuse, or grey-market activity.
Try it
Issue a licence. Validate it. Kill it.
The entire product, in three clicks, with no account. This is the same key format and the same response shape your customers will hit in production.
No licence yet
•••••-•••••-•••••-•••••
Waiting for a request…
That is the whole loop. In production it is three API calls.
Do it for realProduct
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.
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.
How 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 one at a time from the API when an 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.
Analytics
Know what's happening, before it's a problem
Real-time visibility across your license estate. Flag anomalies, track activations by device, and spot distribution channel trends as they emerge.
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.
Architecture
One dashboard. One API. One SDK.
Three surfaces, one system: a dashboard to run it, a REST API to automate it, 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 — API
Key Management
Mint · Assign · Revoke · Bulk issue
02 — Dashboard
Analytics
Activations · Channels · Anomalies
03 — Records
Audit Log
Tamper-proof · Immutable · Verifiable
Fraud monitoring that catches piracy in motion
Invisible protection that exposes piracy networks without heavy DRM. Days become milliseconds in your response time.
Anti-Piracy
Predictive & real-time protection
Fraud Detection
AI & behavioural signals
License Control
Dynamic — revoke, track, trace
Honeytokens
Built into the JUCE-native SDK
What is a Honeytoken?
A decoy license that only a pirate would touch.
Polaris plants invisible, inert license keys inside your release channels. Legitimate customers never see them. The moment a cracked build or leaked download tries to validate one, we know — instantly, silently, without disrupting real users.
Example — A Seeded Torrent
You seed one decoy key into a pre-release build sent to a reviewer.
Days later, that build appears on a torrent site.
Every pirated activation pings Polaris — IP, device, region, timestamp.
You see the leak source, distribution map, and scale — in real time.
Run it yourself
Pick an attack. Watch it get caught.
Three things that genuinely happen to plugin developers, played out against live detection. The timings are staged — the signals and the audit format are not.
One customer pastes their key into a public thread. Within an hour it is everywhere.
Nothing yet. Run the scenario.
Anomaly score
0
Idle
Reliability
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.
99.98%
Uptime, rolling 90 days
23ms
Validation p99
3
Regions, automatic failover
0
Scheduled maintenance windows
Offline grace
Validation is cached on the machine. Set a grace period — a day, a month, forever — and an activated install keeps opening with no connection at all. Your customer never learns our name.
Air-gapped activation
For studios with no network, a challenge/response code activates a machine by hand. Read it off the screen, paste it back, done. No exception path, no support ticket.
Degrades, never fails closed
If we are unreachable, new activations queue and complete when the connection returns. Nothing about an outage on our side turns into a locked-out customer on yours.
Connect your store
Keep selling where you already sell
Connect your checkout once and every paid order mints a licence key on the spot — delivered, activated and revocable. No change to your pricing, your storefront or the way customers pay you.
Stripe
Checkout, Payment Links or the API — a paid session mints a key.
Shopify
Sell the plugin as a digital product; the order webhook does the rest.
FastSpring
Merchant of record, so VAT and refunds stay their problem.
Selling somewhere that isn’t on this list?
Tell us where and we’ll build it — we ship integrations in the order people ask for them.
Migration
Bring your existing keys with you
Bulk-import what you already issued and run both systems in parallel. Existing customers keep working, untouched, while new issuance moves over at whatever pace suits your release schedule.
Import
Push your existing keys and their activation state through the API — device bindings, seat counts, expiry, the lot. Nothing is reissued, so nothing in your customers' hands changes.
Run both
Your current provider keeps validating old keys while Polaris takes new issuance. Both systems live at once, for as long as you want. There is no switch to flip and no evening you have to keep free.
Move when you are ready
Point the SDK at Polaris in your next release. Old keys validate against the imported record, new keys were already here, and the other subscription gets cancelled by you — not by a deadline we set.
No cut-over date. No reissued keys. No customer emails that start “action required”.
Send us a key export and we will tell you exactly what the import looks like before you commit to anything — start there, or read the migration guide.
Proof
Already running under other people’s revenue
Asking a vendor to sit between you and every sale you make is a real decision. Here is the volume going through, and what the teams on the other side of it say.
0
Licences issued
0
Active right now
0
Validations this week
0
Countries with activations
We had spent two years maintaining our own key server and were still guessing at how many seats were really out there. The import took an afternoon and we have not thought about licensing since.
Placeholder Name
Founder, Example Audio
40k licences migrated
Release day used to be the day our licensing fell over. Now it is the day we watch the activation map fill in. Nothing about the volume touches us any more.
Placeholder Name
Head of Engineering, Example Instruments
0 release-day incidents
The anomaly flags found a reseller running one key across a lab of machines within a week. That single catch paid for the year.
Placeholder Name
Technical Director, Example DSP
1 reseller, caught in 6 days
Pricing
Simple, usage-based pricing
No upfront costs. No contracts. Pay as you grow.
Starter
Everything you need to get started. Up to 100 active licences.
- ✓100 active licences (last 90 days)
- ✓REST API access
- ✓Analytics dashboard
- ✓JUCE / C++ SDK
- ✗Fraud detection
Growth
For serious studios shipping multiple products at scale.
- ✓1,000 active licences (last 90 days)
- ✓REST API + webhooks
- ✓Advanced analytics
- ✓Fraud detection (beta)
- ✓Priority support
Enterprise
Unlimited scale, SLA guarantees, dedicated account management.
- ✓Unlimited licenses
- ✓Custom integrations
- ✓99.99% SLA
- ✓Dedicated account manager
- ✓Secondary market access
What you actually pay for
An active licence 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 licence 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 340+ developers already using Polaris to issue and manage their license keys.