LicenseManagerLicense keys for your Tauri app, checked in Rust.
Register one plugin, connect Stripe, and ship. Each purchase creates a license key and emails it to your customer, and your Rust core decides what the app unlocks, where the webview can't reach. No backend to build, and no cut of your sales.
Free up to 100 active users. No credit card required.
use tauri_plugin_licensemanager::{Builder, LicenseState, LicensemanagerExt};
pub fn run() {
tauri::Builder::default()
.plugin(Builder::new("x7Kp2QaZ", PUBLIC_KEY).build())
.invoke_handler(tauri::generate_handler![export_pdf])
.run(tauri::generate_context!())
.expect("error while running tauri application");
}
// Locked in Rust, where the webview can't bypass it
#[tauri::command]
fn export_pdf(app: tauri::AppHandle) -> Result<(), String> {
if app.license().state() != LicenseState::Active {
return Err("A license is required".into());
}
Ok(())
}Your customer pastes the key, your app unlocks
Setup
From zero to your first sale in 5 minutes
Two minutes in the dashboard, three in your code. Then share your Stripe link and start selling.
- 11 min
Set up your licensing model
Sign up, add your app, and choose what you sell: a perpetual license, a yearly one, on 3 machines, with a trial…
- 21 min
Connect Stripe
Map your Stripe price to that offer, one-time or recurring. Each payment then creates a license and emails the key to your customer, and each renewal keeps it valid.
Unlock your app when the license is active
Install the SDK, and register the plugin in Rust, like above. Your webview shows your app when the state is ACTIVE, and otherwise your activation screen, which passes the key your customer enters to setLicenseKey.
That's the whole integration. Validation, storage, offline use and renewals are done for you.
$ cargo add tauri-plugin-licensemanager
$ npm install @licenseman/tauriimport { setLicenseKey, watchLicense } from "@licenseman/tauri";
// "ACTIVE", "MISSING_KEY", "EXPIRED"…
await watchLicense(({ state }) => render(state));
form.addEventListener("submit", async (event) => {
event.preventDefault();
try {
await setLicenseKey(input.value);
} catch {
showError("This license key wasn't recognized.");
}
});No backend to write. Not even a small one.
Stripe talks to LicenseManager, and your app talks to LicenseManager, with a public key and no secret to ship. No webhooks, database of keys or emails of yours to host and keep running at 3 a.m.
Your serverNot needed
Where it's checked
A real Rust plugin, not a fetch call from the webview
Tauri's pitch is a Rust core under a web UI, and that's a gift for licensing: the core is compiled, and the webview can't reach into it. Many licensing tools only give you a REST API to call from JavaScript, which hands the decision back to the part anyone can edit with the inspector.
tauri-plugin-licensemanager validates, verifies and stores the license in Rust. Your commands check app.license().state() before doing paid work, and the webview only gets what your capability allows.
- Validates the key with LicenseManager
- Verifies the Ed25519 signed token offline
- Stores the key in the system keychain
- Refuses paid commands without a license
- Watches the state with watchLicense
- Shows the activation form
- Calls only the permissions you grant
- Decides nothing
What it stops, and what it doesn't
- A key shared beyond its machine limit
- A forged key or license token
- A clock set back to stretch a license
- A version the license doesn't include
- A refunded or canceled license
Tauri SDK
The hard parts are already written
Licensing a desktop app well takes more than one request. The plugin does it the way you would, after a few months of support tickets.
Keys in the keychain
The key and the token are stored in the macOS Keychain, the Windows Credential Manager or the Linux Secret Service, compiled in, with no native module. They survive reinstalls.
Works offline
Your app verifies a signed token locally on every launch, and keeps running without a connection until it expires.
Renews in the background
The key is validated again before the token expires, with retries and a backoff. Startup is never delayed.
Detects clock tampering
A clock set back to keep using an expired license is noticed, even offline.
Locks to the machine
A stable fingerprint per computer, so a key shared beyond its machine limit is refused.
Locks only when it should
A network error or an outage never locks your customer out. Only an answer about their license does.
After the sale
Lost keys, new laptops and refunds, without a support ticket
Selling is the easy part. Then customers lose their key, replace their computer, and ask for their money back. They handle all of it themselves.
A customer portal for every product
Customers sign in with their email to copy their key, free a machine for their new computer, cancel during your money back guarantee and get refunded, or update their card. Open it from your app's Help menu with getPortalUrl().
See who uses which version, and what sells
Active machines by platform and version, adoption of each release, revenue by offer, MRR and churn. Built from the validations your app already makes, with no tracking code.
Free trials, without a separate code path
A trial is a license with a trial policy: 14 days on 1 machine, for instance. Your app checks it like any other key, and it stops at the end of the trial, even offline. Upgrading moves the customer to a paid license.
“1 year of updates”, enforced
Add each version you release, with its date. A license with a year of updates then accepts every version released during that year, and keeps them forever. Each validation checks the running version, and the SDK tells you the latest one the license allows, so Tauri's updater plugin only offers what the customer paid for.
Every model, no code:
- Perpetual
- Perpetual with limited time updates
- Time limited
- Subscription
- Free trial
- Limited number of machines
- Editions
- Money-back guarantee
Guides
Everything else about licensing a Tauri app
From the first command you gate to the move away from Electron, without your customers activating again.
Add license keys, step by step
The plugin, the capability, the activation screen and a gated command, end to end.
ReadGate your commands in Rust
Reach the license with app.license(), refuse paid commands, and react to changes.
ReadChoose what the webview may call
The plugin's permissions, and the capability that grants them to your windows.
ReadMoving from Electron
Switch from our Electron SDK, and your customers stay activated on the same machine.
ReadHow a machine is identified
The fingerprint, why it survives reinstalls, and how to override it.
ReadOffline, and for how long
The signed token, its lifetime, and what the app does when it runs out.
ReadTauri vs Electron, in numbers
Downloads, stars, contributors and community activity, updated every two weeks.
ReadElectron or Tauri for a paid app
Bundle size, memory, webviews, Rust vs Node.js, auto updates and licensing.
ReadCase study
Coming from a homemade license server? RabbitGUI was too
RabbitGUI, a desktop client for RabbitMQ, replaced the license server it had written and hosted itself. Its keys were imported, existing customers were activated silently on launch, and the team now adds subscriptions with a new policy instead of a backend rewrite.
- In-house license server retired
- Existing keys migrated silently, on launch
- Lifetime licenses with free updates, kept
- Offline use and 30-day refunds, kept
- Subscriptions added as new policies
Compare
Licensing Tauri apps: how the tools compare
Whether each tool has an SDK that runs in your Tauri app, takes a cut of your sales, or handles sales tax as a merchant of record. From their public pricing pages and docs.
| Tool | Tauri SDK | Fee on sales | Merchant of record | Price |
|---|---|---|---|---|
| LicenseManager.dev | tauri-plugin-licensemanager | None | No | Free, then €29 / mo |
| Anystack | Tauri integration | From 4%, on sales through its hosted checkout | No | Free, then $39 / mo |
| Moonbase | SDK (Rust) | From 5% + €1 | Yes | Free |
| Keygen | REST API only | None | No | Free, then $99 / mo |
| LicenseSpring | REST API only | None | No | Free, then $199 / mo |
| Polar | REST API only | From 3.4% + $0.30 | Yes | Free, then $20 / mo |
| Lemon Squeezy | REST API only | From 5% + $0.50 | Yes | Free |
Every tool, ranked for Tauri: top license management tools for Tauri, and the free ones. Or see every comparison.
Pricing
Free for your first 100 active users. Then €29 a month.
Every feature, no time limit, no credit card. Only licenses used in the last 90 days count, and €29 / month covers 1,000 of them. Customers pay you on your own Stripe account, and we never take a cut.
Say you sell 300 licenses at €49 this month:
- Your sales
- €14,700
- A 5% cut
- €735
- LicenseManager
- €29
FAQ
Questions before you start
No. Stripe notifies LicenseManager of each payment, and the SDK validates keys with an endpoint that needs no API key, straight from your app. There's no secret to ship, and no server of yours in between.
Tauri 2, with Rust 1.90 or later, on macOS, Windows and Linux. The licensing runs in Rust, and your webview reaches it with @licenseman/tauri, through permissions you control. See frontend and permissions.
Your webview's JavaScript can be read and changed with the browser inspector, so a check there is one edit away from being skipped. The Rust core is compiled into your binary. The plugin validates and verifies the license there, and your commands refuse to run without it, whatever the webview says. See Rust API.
Not yet: the plugin supports desktop apps only, and fails the app's setup on mobile. If you need it, tell us.
No. The Tauri SDK reads what our Electron SDK stored, and computes the same fingerprint: your customers stay activated, on the same machine of their license. See migrating from Electron.
The app keeps working on the signed token it stored, verified locally with your public key, until it expires. You choose how long that is: an hour, a week, or months. A network error or an outage never locks your customer out. See working offline.
No license system stops someone determined to modify your app. What LicenseManager stops is the common case: a key shared beyond its machine limit, a forged key or token, a clock set back, a version the license doesn't include. That's what protects most of your revenue.
Yes. A trial is a license following a trial policy, like 14 days on 1 machine. Your app validates it like any other key, it moves to EXPIRED when the trial ends, even offline, and upgrading turns it into a paid license. See trial licenses.
They open the customer portal, sign in with their email, deactivate the old machine, and enter their key on the new one. The same portal shows lost keys and handles refunds during your money back guarantee, so none of it reaches your inbox. See customer portal.
Yes. You add each version you release, with its date, and a policy with a year of updates accepts every version released during that year, forever. LicenseManager doesn't host your builds: the SDK sends the running version with each validation, moves to VERSION_NOT_ALLOWED when the license doesn't include it, and tells you the latest version it allows, for Tauri's updater plugin to offer. See releases.
You sell through your own Stripe account, so you can turn on Stripe Tax to calculate and collect sales tax and VAT at checkout. Merchants of record, like Paddle or Lemon Squeezy, aren't supported yet: they are coming. Until then, any payment provider can create licenses through the API.
Yes. Map a monthly or yearly Stripe price, and each subscription gets a license that renews with every payment, includes every update, and expires when the customer stops paying. The SDK picks up renewals on its own, and moves the app to EXPIRED when the subscription ends. See subscriptions.
No. Import your existing keys through the API, from another license manager or your own server, and your customers keep the key they have. RabbitGUI did it with an activation on launch that nobody noticed. See migrating.
A license validated in the last 90 days. Customers who stop opening your app stop counting, so you only pay for the ones using it. Past 100, plans start at €29 / month, and we never take a percentage of your sales. See pricing.
Your payments, customers and invoices live in your own Stripe account, not ours. Your licenses, customers and machines can all be read through the API, to move them elsewhere. And installed copies of your app keep running on their stored token until it expires.
Something else? Write to us, a developer answers.
Your Tauri app could be selling by tonight
Create a free account, add your product, and activate your first key from your app. Connect Stripe when you're ready to sell.