Moonbase vs Keygen

Keygen is a well-built licensing and distribution API, and a favourite of developers who like to assemble their own stack. Moonbase is for plugin companies who would rather not: licensing, checkout, tax, accounts, downloads and email in one platform.

Keygen is an API-first licensing service. It models almost any licensing scheme, from node-locked and floating licenses with heartbeats to entitlements and metered usage, signs offline license files with Ed25519 or RSA, and distributes releases for Electron, Tauri, Go and more. You can use Keygen Cloud or host the Community Edition yourself.

What Keygen leaves to you is everything your customer touches. Payments usually go through Stripe, wired to Keygen with your own webhook code, and the store, tax, account pages and the activation screens in your plugin are yours to build. That is a real project before the first sale, and upkeep every time a renewal, refund or upgrade needs handling.

Moonbase ships those parts. The JUCE module brings the activation, trial, license and update screens; checkout embeds on your website with Moonbase as merchant of record; and each license lives on the same customer record as the order that created it, so refunds, renewals and upgrades update it without code from you.

Licensing is one part of selling software

Keygen handles the license. Somebody has to handle the rest.

Between a plugin and a paying customer sit eight jobs. On the left is who does each of them alongside Keygen. Every tag that is not Keygen is another vendor, another integration or more of your own code.

  • Activation and validationKeygen
  • TrialsKeygen
  • Store, cart and checkoutyour store
  • VAT and sales taxyour store
  • Licenses per order and refundyour webhooks
  • Accounts and devicesportal beta
  • Installers and updatesKeygen
  • Email by ownership and useanother tool
moonbase
All eight, on one customer record
  • Activation SDKs and a JUCE UI
  • Trials, offline activation, add-ons
  • Store, cart and checkout on your site
  • Merchant of record for VAT and tax
  • Licenses follow orders and refunds
  • Customer accounts with self-service
  • Installers, release notes, in-app updates
  • Campaigns and segments by DAW and usage
10,000
validations free every month
€0
monthly fee

Inside your plugin

An activation UI you don’t have to build

Keygen’s official SDK is for Go, with C++ examples on GitHub for validating licenses and verifying license files. The activation screens in your plugin are yours to design and build. Moonbase’s JUCE module ships them, with your name, logo and colour.

  • The welcome screen: a product name and logo, an "Activate Solstice" heading, an "Activate online" button, and a "No internet? Activate offline" link

    Activate

    Opens your website, where the customer signs in, buys or starts a trial. Offline activation is one click away.

  • The trial screen: a free-trial panel with days remaining, a progress bar, and an "Unlock full version" button

    Trial

    Days left, what the trial includes, and an unlock button that opens your website to buy.

  • The license details screen: licensed-to name, email, plan, activation type, expiry, seat count, and a "Deactivate this device" button

    License

    Who it is licensed to, seats in use, and a deactivate button to move to another computer.

  • The update available screen: an "Update available" pill, a "Solstice 1.0.0 is ready" heading, a "What's new" changelog card, a Download button, and a "Skip this update" link

    Update

    A new release with its notes, and the installer downloaded inside the plugin.

Your product name, logo and accent colour throughout, or a headless controller if you’d rather draw your own. A ready-made activation UI also ships for Electron, Tauri and Gorilla Engine, and SDKs for C++, Rust, .NET and Node.js cover everything else. Read the JUCE module docs.

Why sign-in matters

A login that unlocks better prices, not just the license

Licensing tools that offer a user login use it to unlock the license, and stop there. The prices live in whichever store you connect, behind a separate account of its own.

In Moonbase, the account a customer signs in with to activate is the one your store knows them by. Signing in also unlocks the prices meant for them, which gives customers a reason to sign in and gives you a way to reward the ones who have already bought.

  • Upgrade prices for what they own

    Owners of an older version, or of a license whose updates are ending, see their upgrade or renewal price, and checkout names the license it extends.

  • Loyalty pricing

    Discounts only for owners of certain products, or for customers who already own a few of yours.

  • Offers for their segment

    Prices and sales for a list or segment, like lapsed subscribers or customers running your plugin in Ableton.

How the pricing works

A plan priced by active licensed users, or a meter priced by use

Keygen prices licensing alone, so a store, card processing and tax come on top. Moonbase bills two things separately: a fee on each sale, which covers the store, card processing and tax, and license validations, which are not part of that fee.

Keygen plans
DevUp to 100 active licensed users
Free
Std 1Up to 1,000 active licensed users
$99/mo
Std 2Up to 10,000 active licensed users
$299/mo
Std 3Up to 25,000 active licensed users
$599/mo
Std 4 and up100,000 active licensed users and more, then Enterprise plans
From $999/mo

As published on keygen.sh/pricing in November 2026. Payment processing, tax and your store are separate.

Moonbase
License validations
€5 per 10,000
Billed on top of the transaction fee, not included in it. The first 10,000 each month are free. Activations, launches and trials all count, with no plan limits on products or licenses.
Selling through Moonbase
5% + €1 per order
Covers card processing, merchant-of-record tax, checkout, file delivery and customer accounts. License validations are billed separately, as above. Some payment methods and currencies add a surcharge.

No monthly fee and no tiers. Every fee is on our pricing page, with a calculator for your validation volume.

Feature comparison

Moonbase
Keygen

Licensing

Device activations
Yes(Built in)

Seats per license, set per product

Yes(Built in)

Machines per license, set by policy

Trials
Yes(Built in)

Timed or endless, optionally behind a sign-up or newsletter opt-in

Yes(Built in)

Short-duration policies you configure

Offline activation
Yes(Built in)

Machine file uploaded in the customer’s account, signed license file back

Yes(Built in)

Signed, optionally encrypted license files

Sign in instead of typing a key
Yes(Built in)

Activation opens your website, and the same sign-in unlocks their own prices

Build it(Partly, or you build it)

User-locked licenses through Keygen’s users API; you build the sign-in, and it unlocks the license only

Customers move seats themselves
Yes(Built in)

Deactivate in the plugin or from their account, activate on the new computer

Build it(Partly, or you build it)

Machines can be deactivated through the API; the UI is yours

Concurrent (floating) license pools
No(Not available)

Seats belong to computers rather than a shared pool

Yes(Built in)

Floating licenses with heartbeats, and Relay for local networks

Usage-based (metered) licensing
No(Not available)
Yes(Built in)

Usage counters you increment and decrement

Add-ons and feature entitlements
Yes(Built in)

Add-ons with their own seats, custom properties in the license token

Yes(Built in)

Entitlements on policies and licenses

Update plans for perpetual licenses
Yes (beta)(Built in)

Updates for a period or up to a major version, with upgrade pricing for owners

Yes(Built in)

Expired licenses can keep access to versions released before expiry

In your plugin

JUCE
Module with UI(Built in)

Drop-in JUCE 8 module with themeable activation, trial, license and update screens

Build it(Partly, or you build it)

No JUCE module; call the API from C++ using its examples

SDKs
Yes(Built in)

C++, Rust, .NET, Node.js, Electron, Tauri, Gorilla Engine

Go(Partly, or you build it)

Official Go SDK; community libraries for Rust and Tauri, and an electron-builder integration

In-app update prompts
Yes(Built in)

Release notes and the installer, downloaded in the plugin

Some stacks(Partly, or you build it)

Auto-updates for Electron, Tauri, Go and macOS apps; plugins need their own prompt

Self-hosting
No(Not available)

Hosted only

Yes(Built in)

Community Edition is free to self-host; Enterprise Edition is licensed

Selling

Store, cart and checkout
Yes(Built in)

Embeds on your own website, whatever it is built with

No(Not available)

Bring Stripe or another payment provider

Merchant of record for VAT and sales tax
Yes(Built in)

Collected and remitted worldwide

No(Not available)

Your store or payment provider’s job

Licenses follow orders and refunds
Yes(Built in)

Same record as the order; refunds revoke, renewals extend

Build it(Partly, or you build it)

Your webhook code; Keygen publishes a Stripe example

Subscriptions and rent-to-own
Yes(Built in)

Billing and licensing in one place

Licenses only(Partly, or you build it)

Timed licenses renewed from your billing system

Installer downloads
Yes(Built in)

Hosted releases, open to everyone, signed-in customers or owners only

Yes(Built in)

Releases and channels, with downloads gated by license

Customers and marketing

Customer accounts
Yes(Built in)

Products, licenses, devices and subscriptions, on your website

Beta(Partly, or you build it)

Open-source Keygen Portal, hosted in beta, or build your own

Email marketing integrations
Yes(Built in)

Klaviyo, Mailchimp, MailerLite, Brevo and Mailjet

Via Zapier(Partly, or you build it)
Segments by DAW, OS and activity
Yes (beta)(Built in)

From what your plugin reports, for campaigns and discounts

No(Not available)
Upgrade and loyalty pricing
Yes(Built in)

Prices only owners see, upgrade paths, cross-sells

No(Not available)

Your store’s job

  • Built in
  • Partly, or you build it
  • Not available

Keygen details come from its own website and documentation, checked in November 2026. If something has changed, tell us and we’ll correct it.

An honest take

When Keygen is the better fit

  • You want licensing on your own servers. Keygen’s Community Edition is free to self-host.
  • You sell to teams that share a pool of floating licenses, or you bill by metered usage.
  • You ship a CLI, a server or packages for npm, PyPI or Docker, and want Keygen’s distribution for them.
  • You enjoy building your own checkout and customer experience, and want a licensing API that stays out of the way.

Switching

Moving from Keygen

  1. Import customers and licenses

    Upload CSVs or use the API. Each license keeps its key code, seats and expiry, and your old IDs stay attached for reference.

  2. Bring your sales history

    Imported orders give every customer a lifetime value from day one, so owner pricing, upgrade discounts and segments work straight away.

  3. Ship an update with a Moonbase SDK

    Customers activate by signing in with the email they bought with, setting a password the first time. The license they own is already in their account.

  4. Move checkout when you’re ready

    Licensing works with sales from another store through the API, so the store can follow in its own time.

Frequently asked questions

Yes. Import your customers and licenses by CSV or through the API. Each license keeps its key code, seats and expiry, with its Keygen ID stored alongside for reference, and past orders can come too so every customer has a purchase history. Customers then activate the update built with a Moonbase SDK by signing in with the email they bought with.

Yes. moonbase_licensing is a drop-in JUCE 8 module with a themeable UI for activation, trials, offline activation, license details and update prompts, or a headless controller if you’d rather build your own screens. It is open source under the MIT license and has no third-party dependencies.

No. Moonbase is a hosted platform, run by us, with licensing, checkout and customer accounts kept on one record. If running licensing on your own servers is a requirement, Keygen’s Community Edition is the better fit.

Yes. The plugin saves a machine file, the customer uploads it in their account, and downloads a signed license file that the plugin verifies locally against your account’s public key. The JUCE module includes the whole flow, drag and drop included, and you can turn offline activation on or off per product.

Keygen prices by active licensed users, meaning anyone with licensing activity in the last 90 days: free for up to 100, then $99 a month for 1,000, $299 for 10,000 and $599 for 25,000, with larger plans above. Payment processing and tax come from your store on top. Moonbase has no monthly fee, and bills selling and licensing separately. Selling through Moonbase costs 5% + €1 per order, which covers card processing and merchant-of-record tax. License validations are not part of that fee: the first 10,000 each month are free, and each further 10,000 cost €5.

Comparing other licensing tools? Compare Moonbase with LicenseSpring and Keyzy.

Choosing where to sell? Compare Moonbase with Paddle, FastSpring, Gumroad and Shopify.

Upgrade your business

Let's talk about your setup

We’ll give you an honest assessment of whether Moonbase fits, including whether to keep Keygen for anything. No pressure, no generic sales pitch.