Moonbase vs LicenseSpring

LicenseSpring is a capable licensing service with an enterprise bent. Moonbase is built for plugin and audio software companies, and licensing is one part of it: the same platform runs your checkout, tax, customer accounts, downloads and email.

LicenseSpring covers a wide range of licensing models, from node-locked and floating licenses to usage metering, SSO and on-premises license servers, with SDKs for C++, .NET, Java, Python, Go, Swift and more. If you sell business software across many platforms, that breadth is the point.

Plugin companies tend to need something narrower and deeper. Their customers activate on a couple of computers, try before they buy, expect to move a seat themselves, and buy again when a new version ships. Moonbase’s JUCE module ships the activation, trial, license and update screens ready to theme, and each license sits on the same record as the order, subscription and newsletter opt-in behind it, so a refund revokes it and a renewal extends it with no integration in between.

LicenseSpring is licensing only, so the store, payments, tax and email come from other vendors, connected through its Stripe and FastSpring integrations or your own webhooks. With Moonbase they are one platform, with no monthly fee.

Licensing is one part of selling software

LicenseSpring 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 LicenseSpring. Every tag that is not LicenseSpring is another vendor, another integration or more of your own code.

  • Activation and validationLicenseSpring
  • TrialsLicenseSpring
  • Store, cart and checkoutyour store
  • VAT and sales taxyour store
  • Licenses per order and refundintegration
  • Accounts and devicesLicenseSpring
  • Installers and updatesyour code
  • 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

LicenseSpring’s C++ SDK includes a JUCE sample project, and its guide leaves the activation screen to you: an overlay or a page in your plugin’s own UI. Moonbase’s JUCE module ships those screens, 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 products, licenses and API calls, or a meter priced by use

LicenseSpring 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.

LicenseSpring plans
Free1 product, 100 active licenses, 1,000 API requests a month
$0/mo
Business Starter3 products, 1,000 active licenses, 10,000 API requests a month
$199/mo
Business Plus10 products, 10,000 active licenses, 1,000,000 API requests a month
$750/mo
EnterpriseUnlimited products and licenses
Custom

As published on licensespring.com/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
LicenseSpring

Licensing

Device activations
Yes(Built in)

Seats per license, set per product

Yes(Built in)

Node-locked, including TPM and Secure Enclave binding

Trials
Yes(Built in)

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

Yes(Built in)

Time-limited or feature-restricted

Offline activation
Yes(Built in)

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

Yes(Built in)

File exchange through its offline portal, plus air-gapped code exchange

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

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

Yes(Built in)

User-based licensing alongside license keys; the login unlocks the license only

Customers move seats themselves
Yes(Built in)

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

Yes(Built in)

Device resets in the user portal, when you allow them

Concurrent (floating) license pools
No(Not available)

Seats belong to computers rather than a shared pool

Yes(Built in)

Cloud floating, or a floating server on the customer’s premises

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

Consumption metering on Business Plus and up

Add-ons and feature entitlements
Yes(Built in)

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

Yes(Built in)

Feature flags, with feature-level metering

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)

Maintenance periods

In your plugin

JUCE
Module with UI(Built in)

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

Sample project(Partly, or you build it)

A JUCE sample in the C++ SDK; the activation UI is yours to build

Other SDKs
Yes(Built in)

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

Yes(Built in)

C/C++, .NET, Java, Python, Go, Node.js, Swift, Unity, Android

In-app update prompts
Yes(Built in)

Release notes and the installer, downloaded in the plugin

Build it(Partly, or you build it)

Versions and installation files are in the API; the prompt is yours

On-premises license server
No(Not available)
On request(Built in)

For customers who run licensing on their own network

Selling

Store, cart and checkout
Yes(Built in)

Embeds on your own website, whatever it is built with

No(Not available)

Connect Stripe, FastSpring or another store

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

Via integration(Partly, or you build it)

Native Stripe and FastSpring integrations, webhooks for the rest

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

Billing and licensing in one place

Licenses only(Partly, or you build it)

Subscription licenses; the billing runs in your payment provider

Installer downloads
Yes(Built in)

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

Links(Partly, or you build it)

Download links in the user portal

Customers and marketing

Customer accounts
Yes(Built in)

Products, licenses, devices and subscriptions, on your website

User portal(Built in)

White-labelled portal for license managers

Email marketing integrations
Yes(Built in)

Klaviyo, Mailchimp, MailerLite, Brevo and Mailjet

CRM(Partly, or you build it)

Salesforce and HubSpot integrations

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

LicenseSpring 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 LicenseSpring is the better fit

  • You sell to businesses that want floating licenses on their own network, usage metering, or SSO for their staff.
  • You ship on platforms Moonbase has no SDK for, such as Java, Python, Go or Unity.
  • Your store, tax and email are already set up the way you want, and the license is the only piece you want a specialist for.

Switching

Moving from LicenseSpring

  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 LicenseSpring 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.

Yes. Your integration records each sale from the other store through the Moonbase API, and Moonbase issues the licenses and gives the buyer an account. Refunds recorded the same way revoke them. Many companies move checkout to Moonbase later, since that is where the customer record comes together.

Moonbase seats float between computers: a customer deactivates one machine, from the plugin or their account, and activates another without contacting you. What Moonbase does not have is a concurrent pool that a team checks licenses in and out of. If you need that, LicenseSpring supports it.

LicenseSpring plans are priced by products, active licenses and API requests: free during development, $199 a month for Business Starter, $750 for Business Plus, and custom Enterprise plans. 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 Keygen 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 LicenseSpring for anything. No pressure, no generic sales pitch.