ChatGPT answers, unedited

For a solo developer selling desktop software licenses + paid updates, my first choice would be Lemon Squeezy.

It has an unusually good fit for exactly this model because the ecommerce layer and licensing layer are already connected.

My ranking

🥇 Lemon Squeezy

This is the one I'd pick if I were building a new indie software product today.

Lemon Squeezy can automatically generate a unique license key when someone purchases a product, with configurable license duration and activation limits. Lemon Squeezy Docs Lemon Squeezy Docs

More importantly for your use case, it has file versions specifically intended for software products. You can attach versions to your product/variant files and use the License API to determine whether a customer is entitled to a particular download. Lemon Squeezy Docs

You also get an API for:

• activating a license
• validating a license
• deactivating an installation
• tracking activation instances
• checking expiration
• disabling licenses
• managing license limits Lemon Squeezy Docs Lemon Squeezy Docs

That gives you a pretty clean architecture:

Customer
   │
   ▼
Lemon Squeezy checkout
   │
   ├── Payment
   ├── Tax / merchant-of-record
   ├── License key generated
   └── Download entitlement
            │
            ▼
       Your application
            │
            ├── Activate license
            ├── Validate license
            └── Check update entitlement

And your releases could look like:

MyApp
├── 1.0.0
├── 1.1.0
├── 1.2.0
└── 2.0.0

You can then make your own update server determine something like:

License purchased:
2026-01-15

Updates included:
1.0 → 1.9

Current version:
1.4

Latest eligible version:
1.9

That distinction is important: Lemon Squeezy handles the commerce/license primitives; your app can implement whatever "updates for one year" or "major-version upgrade" policy you want.

One caveat

If you need serious offline licensing, cryptographic licensing, floating licenses, hardware-bound activation, or sophisticated anti-piracy controls, I wouldn't make the ecommerce platform itself your entire licensing system.

In that situation I'd use:

Lemon Squeezy + dedicated licensing backend

rather than trying to force ecommerce software to become a complete license-management system.

🥈 Gumroad

Gumroad is appealing if you want the absolute minimum setup.

It has built-in license keys and an API for verifying them. It also supports product versions, and license keys can be associated with particular versions. Gumroad

The drawback is that the licensing model is relatively primitive. Gumroad explicitly leaves license enforcement to you; your application decides how verification/usage should work. Gumroad

I'd choose it for something like:

$49 utility → download ZIP → enter license key → basic online verification.

I'd choose Lemon Squeezy if you expect the product to become a serious commercial software business.

🥉 Paddle

Paddle is excellent if your bigger concern is global software commerce, subscriptions, tax, and compliance. It supports one-time digital software products and handles payments, tax, fraud, and merchant-of-record responsibilities. Paddle Developer Docs

But for your specific requirement—"generate a license key and manage versioned software downloads"—Lemon Squeezy is more directly aligned.

What I'd actually build

For a solo developer, I'd avoid building an ecommerce system yourself.

I'd use:

Lemon Squeezy
→ checkout/payment/tax
→ license generation
→ customer/order records
→ file distribution

Your small backend
→ license validation wrapper
→ update entitlement logic
→ "latest version available" API
→ optional telemetry

Your desktop app
→ sends license key
→ activates installation
→ periodically checks license
→ checks for eligible updates
→ downloads the appropriate version

For example:

GET /api/update?product=myapp&version=1.4.2&license=XXXX

Your server could return:

{
  "update_available": true,
  "version": "1.6.0",
  "download_url": "...",
  "release_notes_url": "...",
  "license_valid": true
}

That gives you much more control over "customers who bought version 1.x get all 1.x updates, but version 2.0 requires an upgrade" without having to replace your ecommerce platform.

Bottom line

For a solo developer: Lemon Squeezy is the best starting point.

Its combination of license generation + activation limits + License API + versioned files + ecommerce is unusually close to your requirements. Lemon Squeezy Docs Lemon Squeezy Docs Lemon Squeezy Docs

If you tell me whether you're selling Windows/macOS/Linux desktop software, plugins, or SaaS, and whether updates are free forever, 1 year, or tied to major versions, I can recommend the exact architecture and compare Lemon Squeezy vs Paddle vs a dedicated licensing service.

For a solo developer selling software licenses + paid updates, the “best” ecommerce system depends on whether you want to avoid building infrastructure or own the licensing stack. The strongest choices are usually not generic ecommerce carts; they are systems that understand entitlements, activation, downloads, upgrades, and renewals.

Here are the options I would consider:

My recommendation by scenario

1. Desktop app (Windows/macOS/Linux): use Paddle or Lemon Squeezy + Keygen

This is probably the cleanest modern indie stack.

Example architecture:

Customer
   ↓
Checkout (Paddle/Lemon Squeezy)
   ↓
Webhook
   ↓
License server (Keygen)
   ↓
Your app checks license
   ↓
Download/update server

Advantages:

• Handles VAT/sales tax headaches
• Handles subscriptions and renewals
• You keep control of licensing
• Easy to add: - device limits
• offline activation
• trial keys
• upgrade eligibility

SendOwl Freemius

2. WordPress plugin/theme: WooCommerce is usually the winner

If your software is a WordPress plugin, I would strongly lean toward WooCommerce because the ecosystem already solves:

• license generation
• activation APIs
• update delivery
• customer accounts
• renewals

WooCommerce licensing extensions can generate keys after purchase, manage activations, and provide update APIs. WooCommerce WooCommerce

A typical stack:

• WooCommerce checkout
• Software licensing extension
• Private downloads
• Your plugin calls your update API

3. Small desktop utility with a few hundred customers: consider building less

A lot of solo developers overbuild licensing. You often only need:

Database:

licenses
---------
id
customer_id
product
license_key
status
expires_at
max_devices

activations
------------
license_id
device_id
last_seen

releases
---------
version
download_url
required_license

Your app calls:

GET /license/validate
GET /updates/latest

That can be enough for years.

Systems I would avoid for this use case

Gumroad

Good for simple digital files, but licensing/version management is not its strength.

Shopify

Excellent ecommerce platform, but software licensing usually becomes a collection of apps and custom glue code.

Building everything yourself immediately

It sounds simple until you need:

• refunds disabling licenses
• upgrade pricing
• stolen keys
• offline activation
• subscription expiry
• customer migrations

My ranking for a solo software developer

1. Paddle + Keygen — best overall for commercial desktop software
2. Lemon Squeezy + Keygen — best indie-friendly option
3. WooCommerce + licensing plugin — best if you want self-hosted ownership
4. FastSpring — best if you expect a larger software business
5. Custom Stripe + your own licensing API — best only if you enjoy maintaining infrastructure

If you tell me what kind of software you sell (desktop app, WordPress plugin, SaaS, CLI tool, mobile app) and whether licenses are perpetual + paid updates or subscription, I can narrow it to a specific stack.

1. Paddle + Keygen — best overall for commercial desktop software
2. Lemon Squeezy + Keygen — best indie-friendly option
3. WooCommerce + licensing plugin — best if you want self-hosted ownership
4. FastSpring — best if you expect a larger software business
5. Custom Stripe + your own licensing API — best only if you enjoy maintaining infrastructure

If you tell me what kind of software you sell (desktop app, WordPress plugin, SaaS, CLI tool, mobile app) and whether licenses are perpetual + paid updates or subscription, I can narrow it to a specific stack.

For a solo developer selling desktop software licenses + ongoing updates, I’d put Lemon Squeezy at the top of the list right now.

My ranking

Why I'd choose Lemon Squeezy

Lemon Squeezy has unusually good support for exactly this model.

1. License keys are built in.
You can configure license length and activation limits per product/variant. When someone purchases, Lemon Squeezy generates the key and delivers it to them. docs.lemonsqueezy.com

2. Your application can validate the key.
Their License API supports activation, validation, and deactivation, so your app can essentially do:

User enters license
       ↓
Your app → Lemon Squeezy
       ↓
Valid? / Expired? / Activation limit?
       ↓
Enable software

docs.lemonsqueezy.comdocs.lemonsqueezy.comdeveloper.paddle.comwww.paddle.com

You can also manage activation limits, expiration, and disabling through their API. docs.lemonsqueezy.com

3. It works nicely with your own update server.

I'd actually separate licensing from software distribution:

                    Lemon Squeezy
                         │
             purchase + license key
                         │
                         ▼
Customer ──────────── Your website
                         │
                  "My Downloads"
                         │
             ┌───────────┼───────────┐
             ▼           ▼           ▼
          v1.0.0      v1.1.0      v2.0.0
          Windows      Windows      Windows
          macOS        macOS        macOS
          Linux        Linux        Linux

Lemon Squeezy gives you the commerce/license layer, while you maintain your own release/version structure. Their API also exposes product/file-related data, making custom download experiences possible. docs.lemonsqueezy.com

The architecture I'd recommend

For a solo developer, I'd keep it extremely simple:

Lemon Squeezy

• Checkout
• Credit cards/PayPal/etc.
• Taxes/VAT handling
• Customer/order records
• License generation
• License activation/validation
• Webhooks

Your server

• /activate
• /validate
• /download
• /updates
• Customer download portal
• Release/version metadata

Object storage/CDN

• myapp-1.0.0-win.exe
• myapp-1.0.0-mac.dmg
• myapp-1.1.0-win.exe
• etc.

Your update endpoint could return something as simple as:

{
  "latest": "1.4.2",
  "minimum_supported": "1.2.0",
  "download": "https://...",
  "release_notes": "..."
}

The application sends its license key + current version, and your server decides whether it gets the update.

One important distinction

If by "versioned downloads" you mean:

"Customer buys once and should have access to every version released during their update entitlement"

I'd not make the ecommerce platform itself responsible for your version-management logic.

Instead, model your product as:

Perpetual license + X years of updates

For example:

• $79 — perpetual v1 license
• Includes 1 year of updates
• After 1 year, software continues working
• Customer can renew for another year of updates
• Existing customer retains access to all versions released while their update entitlement was active

That gives you much more control than treating every software version as a separate ecommerce product.

Lemon Squeezy vs. Paddle

I'd choose Lemon Squeezy if you're primarily a one-person software business.

I'd choose Paddle if you expect the business to become more sophisticated around subscriptions, billing infrastructure, or SaaS. Paddle has a very capable API/webhook system, but its current API is more focused on billing, products, transactions, subscriptions, etc. developer.paddle.com

Paddle's older/Classic documentation does explicitly describe delivering software license codes and downloads, but that material is specifically marked as applying to Paddle Classic, so I wouldn't choose it today solely for that feature. www.paddle.com

Bottom line: I'd start with Lemon Squeezy + your own lightweight update/download API. It gives you the least amount of infrastructure to build while still letting you own the actual software-update experience.

If you tell me what kind of software you're selling (Windows/macOS/Linux, plugin, CLI, SaaS, etc.) and whether updates are perpetual or subscription-based, I can recommend the exact architecture and compare Lemon Squeezy vs Paddle vs FastSpring for your particular licensing model.

For a solo developer selling desktop software/licenses with downloadable versions, I’d shortlist FastSpring and Lemon Squeezy, with FastSpring as the best fit if licensing and downloads are core requirements.

My ranking

1. FastSpring — my pick for serious desktop software

FastSpring is unusually well suited to software licensing.

It supports license-key fulfillment and product-download fulfillment as separate, built-in fulfillment mechanisms. License keys can be generated through its own generators, scripts, or remote license servers, while downloads can be securely distributed after purchase. developer.fastspring.com

It also supports files up to 5 GB through its current product-download fulfillment system. developer.fastspring.com

More importantly, if you eventually need serious licensing—machine activation, floating licenses, subscription licensing, trials, etc.—FastSpring integrates with licensing systems such as Cryptlex, LicenseSpring, LimeLM, KeyGen.sh, SoftwareKey, and Nalpeiron. developer.fastspring.com

A good architecture would be:

Your website
     │
     ▼
FastSpring checkout
     │
     ├── Payment
     ├── Customer/order record
     ├── License generation
     └── Secure download
              │
              ├── v1.0.0
              ├── v1.1.0
              └── v2.0.0

You could then have your app periodically check your own API:

license key
     ↓
your licensing API
     ↓
valid? expired? activation count?
     ↓
latest version available
     ↓
download URL

That gives you much more control than making the ecommerce platform itself responsible for your entire update system.

2. Lemon Squeezy — probably the easiest for a solo developer

Lemon Squeezy is very attractive if you want minimal infrastructure and a pleasant developer experience.

Its license system can automatically generate a key when a customer purchases a product, and you can configure license length and activation limits. docs.lemonsqueezy.com

It also has a dedicated License API supporting activation, validation, and deactivation, plus APIs for products, files, orders, customers, etc. docs.lemonsqueezy.com

I'd choose Lemon Squeezy if your model is approximately:

Pay $79 → receive license key → download software → periodically check whether a newer release exists.

It's particularly appealing if you don't want to build much ecommerce infrastructure yourself.

The important distinction: "versioned downloads"

I wouldn't make the ecommerce platform your actual software-update system.

Instead, I'd separate the two:

Ecommerce

• Checkout
• Tax/payment handling
• Customer/order records
• License issuance
• Entitlements

Your update server

• Version numbers
• Release channels
• OS/architecture
• Changelogs
• Download URLs
• Update eligibility
• Optional forced/minimum versions

For example:

{
  "product": "MyApp",
  "channel": "stable",
  "version": "4.2.1",
  "minimum_version": "3.8.0",
  "download": "https://updates.example.com/4.2.1/MyApp-win-x64.exe"
}

Your application can then ask:

GET /api/updates/MyApp?channel=stable&platform=windows-x64

and receive the appropriate release.

That approach also makes paid upgrades much easier. Your ecommerce system determines whether the customer's license is entitled to v4, while your update service handles the actual binary.

What about Paddle?

Paddle is excellent for SaaS/subscriptions, but I wouldn't pick it specifically for a traditional license-key + downloadable desktop application unless you already prefer its billing ecosystem. Its current developer platform is heavily oriented around API-driven billing, subscriptions, and SaaS/app infrastructure. developer.paddle.com

My recommendation

If I were building this as a solo developer today:

Choose Lemon Squeezy if:

• You want the simplest setup.
• You have one/few products.
• Your licensing requirements are fairly straightforward.
• You want to spend almost no time building ecommerce infrastructure.

Choose FastSpring if:

• Software licensing is a major part of your business.
• You sell perpetual licenses + upgrades.
• You need sophisticated activation/licensing later.
• You want robust digital fulfillment.
• You expect your product/business to grow.

For a serious commercial desktop application, I'd pick FastSpring + a small custom update API. FastSpring handles the money, tax/compliance, customer/order lifecycle, license delivery, and downloads; your API handles the software-release lifecycle.

FastSpring developer documentation
Lemon Squeezy developer documentation

If you tell me your platform (Windows/macOS/Linux), whether licenses are perpetual or subscription, and whether customers pay separately for major-version upgrades, I can narrow this down to the best architecture and compare the actual workflow/costs for FastSpring vs Lemon Squeezy.

For a solo developer selling perpetual software licenses + paid updates, I’d pick Lemon Squeezy first.

Lemon Squeezy is unusually well matched to this exact model because licensing and software-version delivery are built into the product rather than requiring you to assemble them yourself.

My ranking

Why Lemon Squeezy wins

1. License generation is native.
You can enable license keys per product/variant, specify the license duration and activation limit, and Lemon Squeezy generates a unique key for each purchase. Customers receive the key in their receipt and order history. docs.lemonsqueezy.com

2. It has an actual licensing API.
Your app can call the License API to activate, validate, and deactivate keys. It also tracks individual license-key instances, so you can implement things like "one license, two computers." docs.lemonsqueezy.com

3. Versioned software downloads are a first-class feature.
This is the big differentiator for your use case. Lemon Squeezy lets you attach versions to files, explicitly intended for software products where access to upgrades is controlled by license keys. docs.lemonsqueezy.com

The file API exposes the version as well as a signed, expiring download URL, which is useful if you want your application to check a license and then retrieve the appropriate installer. docs.lemonsqueezy.com

4. You don't have to become a tax/compliance expert.
Lemon Squeezy operates as a merchant of record, handling sales tax/VAT and related compliance. That's particularly attractive when you're a one-person software company selling internationally. developer.paddle.com

The architecture I'd use

For example, suppose you're selling MyApp Pro.

Customer
   │
   ▼
Lemon Squeezy Checkout
   │
   ├── Payment
   ├── License Key
   └── Customer record
           │
           ▼
      Your webhook
           │
           ▼
     Your database
           │
           ├── license
           ├── customer
           └── entitlement

Then your application does:

App starts
   │
   ▼
User enters license key
   │
   ▼
Your server → Lemon Squeezy License API
   │
   ├── valid → activate
   └── invalid → reject

For updates:

App v1.4
   │
   ▼
Your update endpoint
   │
   ▼
Validate license
   │
   ▼
Determine entitled version
   │
   ▼
Return download URL
   │
   ▼
Download v1.5 installer

That lets you sell a model such as:

$79 — perpetual license + 12 months of updates
After 12 months, the customer keeps the latest version they received but must renew to download newer versions.

Lemon Squeezy's license expiration and activation controls map quite naturally onto that model. docs.lemonsqueezy.com

One important caveat

I wouldn't choose Paddle Billing over Lemon Squeezy specifically for licensing.

Paddle is excellent for payments and merchant-of-record functionality, but its current Billing product expects you to build fulfillment yourself, including license-key generation and digital-product delivery. Paddle explicitly says its older Paddle Classic license-key/product-delivery functionality was deprecated in Billing. developer.paddle.com

So with Paddle you'd essentially be building:

• license database
• key generation
• activation service
• entitlement logic
• download authorization
• version management
• update delivery

That's reasonable if you want complete control, but it's a lot of infrastructure for a solo developer.

My recommendation

Use Lemon Squeezy if your priority is minimizing infrastructure.

I'd structure the product as:

Lemon Squeezy

• checkout
• payments
• tax/VAT
• customer records
• license generation
• activation limits
• license API
• installer/version storage

Your server

• webhook processing
• entitlement rules
• optional update API
• app-specific licensing logic

Your app

• license entry
• activation
• periodic validation
• update checking

If you tell me whether you're selling Windows/macOS/Linux software, plugins, or a SaaS, and whether your model is perpetual + 1 year updates or subscription, I can recommend the exact Lemon Squeezy product/variant/license/version structure I'd use. docs.lemonsqueezy.com

For a solo developer selling desktop software licenses + paid updates, I’d pick Lemon Squeezy first.

My ranking

Why Lemon Squeezy fits particularly well

Lemon Squeezy has native license-key generation, including configurable license duration and activation limits. A customer receives their key in the purchase receipt and can also access it through their order history. docs.lemonsqueezy.comdocs.lemonsqueezy.com

It also exposes a proper License API for:

• activating a key
• validating a key
• deactivating individual installations
• checking expiration
• tracking activation instances

That makes it quite practical to build something like:

Customer buys Pro
       ↓
Lemon Squeezy generates license
       ↓
Customer downloads v4.2.0
       ↓
App asks for license key
       ↓
Your app → Lemon Squeezy License API
       ↓
License valid?
       ↓
Enable Pro features

docs.lemonsqueezy.comdocs.lemonsqueezy.com

The other big advantage is that Lemon Squeezy has file/version management alongside its product system. Its current documentation specifically includes "Managing file versions," while its API exposes products, variants, files, orders, licenses, and webhooks. docs.lemonsqueezy.comdocs.lemonsqueezy.com

So you can structure your product roughly as:

MyApp
├── Windows
│   ├── 4.2.0
│   ├── 4.1.3
│   └── 4.0.0
├── macOS
│   ├── 4.2.0
│   └── 4.1.3
└── License
    ├── Pro — 1 activation
    └── Pro — 3 activations

Lemon Squeezy vs. Paddle

Paddle is the main alternative I'd seriously consider.

Paddle is particularly strong if your priority is global software sales, tax/VAT handling, subscriptions, and billing infrastructure. It explicitly supports software licenses and downloadable files, and its one-time purchase flow can trigger a webhook that your system uses to issue a license or unlock a download. developer.paddle.com

The distinction I'd make is:

Lemon Squeezy:

"I want an ecommerce platform that already understands my software license."

Paddle:

"I want a sophisticated global billing/merchant-of-record platform and I'm comfortable building more of the software-license fulfillment layer."

For a solo developer, I'd generally favor the first.

One important architectural recommendation

Don't make the ecommerce platform your entire licensing system.

I'd use:

Lemon Squeezy → payments/orders/licenses
Your backend → authoritative product/update access rules
Object storage/CDN → actual software binaries

For example:

                 ┌──────────────────┐
                 │  Lemon Squeezy   │
                 │                  │
Customer ───────►│ Checkout         │
                 │ Payment          │
                 │ License          │
                 │ Order            │
                 └────────┬─────────┘
                          │ webhook
                          ▼
                 ┌──────────────────┐
                 │ Your API         │
                 │                  │
                 │ License mapping  │
                 │ Entitlements     │
                 │ Update policy    │
                 └────────┬─────────┘
                          │
                 ┌────────▼─────────┐
                 │ Download/CDN     │
                 │                  │
                 │ 4.2.0            │
                 │ 4.1.3            │
                 │ 4.0.0            │
                 └──────────────────┘

That gives you much more flexibility later. For example, you can sell "1 year of updates" without making the license itself synonymous with a particular software version.

What I'd choose

If you're starting from scratch today:

1. Lemon Squeezy — best fit
Use its built-in licenses, activation limits, checkout, orders, webhooks and file versions. docs.lemonsqueezy.comdocs.lemonsqueezy.com

2. Paddle — excellent if international tax/billing complexity is your biggest concern
Especially attractive as the business grows. developer.paddle.com

3. Stripe + your own licensing/download system — only if you need unusual licensing
For example, floating licenses, offline activation, hardware-bound licenses, complex team licensing, or highly customized update entitlements.

If your software is a Windows/macOS desktop app, I can also compare the actual stack I'd use—Lemon Squeezy vs Paddle vs Keygen vs Cryptlex vs Stripe, including offline activation, piracy resistance, automatic updates, 1-year update subscriptions, and version-gated downloads.

For a solo developer selling desktop software licenses + ongoing updates, I’d pick Lemon Squeezy first.

My ranking

Why Lemon Squeezy fits particularly well

Lemon Squeezy has essentially the exact primitives you're asking for:

• Automatic license-key generation for each purchase.
• Configurable license duration and activation limits. docs.lemonsqueezy.comdocs.lemonsqueezy.com
• An API for your application to validate, activate, deactivate, and manage licenses. docs.lemonsqueezy.com
• File versions are a first-class feature. You can associate a version such as 2.4.1 with a downloadable file. docs.lemonsqueezy.comdocs.lemonsqueezy.com
• Customers can access their purchased downloads through Lemon Squeezy's customer/order interfaces. docs.lemonsqueezy.com
• You can have different variants for things like Personal / Pro / Commercial, with different prices and licensing rules. docs.lemonsqueezy.com

The particularly nice part is that you don't have to build an entire licensing backend just to get started.

A typical architecture would be:

Your website
    │
    ▼
Lemon Squeezy checkout
    │
    ├── payment
    ├── license key generated
    └── download entitlement
            │
            ▼
      Customer installs app
            │
            ▼
     Your licensing API
            │
       validate key
            │
            ▼
      App is activated

For updates:

Lemon Squeezy
    │
    ├── MyApp 1.0.0
    ├── MyApp 1.1.0
    ├── MyApp 1.2.0
    └── MyApp 2.0.0

Your app can check your server, determine that 1.2.0 is the newest version the customer's license permits, and retrieve the appropriate download. Lemon Squeezy's file API exposes the software version and generates signed download URLs. docs.lemonsqueezy.comdocs.lemonsqueezy.com

Where Paddle differs

Paddle is also excellent for a solo software business, particularly because it's a merchant of record and handles international tax/compliance. It explicitly supports one-time software products and downloads. docs.lemonsqueezy.comdocs.lemonsqueezy.comdocs.lemonsqueezy.comdocs.lemonsqueezy.comdeveloper.paddle.com

But there's an important distinction:

Paddle is primarily the commerce/billing layer; you'd build more of the actual software-license/update infrastructure yourself.

Paddle's documented fulfillment flow is essentially:

payment → transaction.completed webhook → you grant access/send a license/unlock the download. docs.lemonsqueezy.comdocs.lemonsqueezy.comdocs.lemonsqueezy.comdocs.lemonsqueezy.comdeveloper.paddle.com

That's perfectly reasonable if you already want your own licensing server.

What I'd do as a solo developer

If you're launching a conventional desktop app, I'd use:

Lemon Squeezy + your own tiny licensing/update API

rather than trying to make Lemon Squeezy do everything.

Let Lemon Squeezy handle:

• checkout
• payments
• receipts
• taxes
• license generation
• activation limits
• customer purchase records
• downloadable files

And have your own backend handle:

• POST /activate
• POST /deactivate
• POST /validate
• GET /updates
• entitlement rules
• minimum/maximum supported versions
• optional update channels (stable, beta)
• any machine/device fingerprinting you need

That gives you a very small amount of infrastructure while retaining control over the software itself.

One important design decision

I'd not make the license key itself determine which version the user gets.

Instead, model it as:

License
  ├── product = MyApp
  ├── tier = Pro
  ├── activations = 2
  ├── expires = 2027-08-17
  └── update entitlement = 12 months

Then your update API can return something like:

{
  "latestVersion": "3.4.2",
  "download": "...",
  "updateAllowed": true
}

That makes it much easier later to sell things like "1 year of updates", perpetual license + paid upgrades, or subscription without redesigning your licensing system.

Bottom line: If your priority is "I want to sell my app this month without building a miniature ecommerce company" → Lemon Squeezy is the strongest choice. Its built-in license keys + activation limits + versioned files are unusually well matched to your use case. docs.lemonsqueezy.comdocs.lemonsqueezy.com

Lemon Squeezy developer documentation
Paddle developer documentation

For a solo developer selling desktop software licenses + paid updates, I’d pick Lemon Squeezy first.

My ranking

Why Lemon Squeezy is particularly good

Lemon Squeezy has the unusual combination of native license-key generation and file versioning. You can attach multiple versions of files to a product/variant, and their documentation specifically describes using the License API to verify a key before allowing a customer to download an upgrade. docs.lemonsqueezy.comdocs.lemonsqueezy.comwww.lemonsqueezy.comdeveloper.paddle.com

For example, you could structure your product like:

MyApp Pro
├── License: perpetual
├── Version 5.2.0
│   ├── Windows installer
│   └── macOS installer
├── Version 5.1.0
├── Version 5.0.0
└── ...

Your application can call the License API to determine whether the license is valid, its activation limit, expiration, etc. License activations can also be individually deactivated. docs.lemonsqueezy.comdocs.lemonsqueezy.com

That's a very good fit for a model like:

$99 perpetual license + 1 year of updates

or:

$99 license + $39/year for continued updates

You can make the license expire after a year if you want the license itself to control update/support access. Lemon Squeezy supports license length and activation limits directly. docs.lemonsqueezy.comdocs.lemonsqueezy.comwww.lemonsqueezy.comdeveloper.paddle.com

It also handles the less-fun solo-business stuff: payment processing, taxes, digital delivery, checkout, etc. Its current pricing page lists license-key management and signed/throttled digital downloads as built-in capabilities. www.lemonsqueezy.com

Lemon Squeezy

Where Paddle fits

Paddle is my second choice, particularly if you expect the business to evolve toward SaaS/subscriptions or more complicated billing.

It is a Merchant of Record and handles tax/compliance globally. developer.paddle.com

The important caveat for your particular use case is that current Paddle Billing requires you to build the fulfillment logic yourself. After transaction.completed, your backend needs to generate/provision the license and download access. developer.paddle.com

So it's powerful, but you're taking on more engineering than with Lemon Squeezy.

Paddle

One important architectural distinction

I wouldn't make the ecommerce platform your source of truth for software licensing.

A good architecture is:

Checkout → webhook → license/entitlement → your API → app

For example:

Customer buys $99 license
        ↓
Lemon Squeezy
        ↓
Webhook
        ↓
Your backend
        ↓
License = ABCD-1234...
        ↓
App activates license
        ↓
App asks your API:
"Is this license entitled to v5.2?"
        ↓
Your API
        ↓
Signed download URL for v5.2

That gives you considerably more control than simply emailing an installer URL.

What I'd choose for a solo developer

Lemon Squeezy + your own tiny licensing/update API is the sweet spot.

Let Lemon Squeezy handle:

• Checkout
• Credit cards/payment methods
• Taxes/VAT
• Receipts
• License generation
• Activation limits
• Customer orders
• Download delivery

Let your backend handle:

• Which versions a customer is entitled to
• Current/latest version
• Update eligibility
• Machine/device activation policy, if you need something beyond Lemon Squeezy's activation model
• Release channels (stable, beta)
• Download authorization
• Automatic update checks

The nice thing is that Lemon Squeezy already gives you the primitives for this rather than forcing you to invent a licensing system from scratch. docs.lemonsqueezy.comdocs.lemonsqueezy.com

Bottom line: If you're a one-person shop and your product is a traditional downloadable app with license keys + paid upgrades, I'd start with Lemon Squeezy. If you're building toward a more complex SaaS/billing operation, I'd look harder at Paddle.

For a solo developer selling downloadable software with license keys and paid updates, I’d pick Lemon Squeezy first.

My ranking

🥇 Lemon Squeezy — my recommendation

For your particular use case, it has an unusually good combination of features.

It can automatically generate license keys when somebody purchases a product, with configurable license duration and activation limits. docs.lemonsqueezy.com

More importantly, it has file versions specifically intended for software products. You can attach multiple versions of a file to a product/variant, which is exactly the model you want for:

v1.0 → v1.1 → v1.2 → v2.0

You can then use its License API to verify that the customer is entitled to an update before serving the appropriate file. docs.lemonsqueezy.com

It also supports one-time purchases, subscriptions, and automatically issuing license keys after purchase. www.lemonsqueezy.com

So a fairly clean architecture would be:

Customer → Lemon Squeezy checkout → license generated → customer downloads v1.0 → your app validates license → update endpoint → v1.1 download

That's a lot of infrastructure you don't have to build yourself.

🥈 WooCommerce + Kestrel API Manager — best for maximum control

If you're comfortable running WordPress/WooCommerce, this is arguably the more powerful solution.

The current Kestrel API Manager handles:

• license generation
• activation/deactivation
• activation limits
• expiration
• license revocation
• license validation API
• secure downloads
• S3-hosted files
• software updates
• customer download area
• subscriptions
• license upgrades/downgrades woocommerce.com

It even provides an SDK for integrating license authentication and updates into your software. woocommerce.com

The downside is that you are now running an ecommerce stack. WordPress, WooCommerce, hosting, backups, security, plugin updates, payment configuration, etc.

For a solo developer, that's a meaningful amount of operational overhead.

I'd choose this if owning the entire customer/store infrastructure is important to you.

🥉 Gumroad — easiest, but I'd outgrow it sooner

Gumroad does have native software license keys and an API for verifying them. It also supports multi-seat licenses. gumroad.com

It's attractive if your priority is:

"I want to put my software up for sale today and not build an ecommerce system."

But its software update/version-management model isn't as compelling as Lemon Squeezy's dedicated file-version functionality.

One important distinction

I'd separate "selling updates" from "delivering updates."

For example, suppose you sell:

Software Pro — $99

and give the customer:

• 12 months of updates
• license valid forever
• after 12 months, they can continue using their current version
• renewal = $39/year for new versions

That's a slightly different licensing model from:

Software Pro — $99/year

where the license itself expires.

Lemon Squeezy can accommodate subscription-linked licenses, but your application still needs to enforce whatever update entitlement model you choose. Its API is the mechanism I'd use for that. docs.lemonsqueezy.com

What I'd build

If I were a solo developer starting today, I'd use:

Lemon Squeezy
→ payments, tax/VAT handling, customer accounts, license issuance

Your own API
→ license validation + update authorization

S3/R2
→ actual software binaries

Your application
→ sends license key to your API and checks for updates

That gives you a very clean separation:

                 Lemon Squeezy
                      │
             purchase + license
                      │
                      ▼
Customer ───────► Your License API
                      │
             valid / expired /
             activation limit
                      │
                      ▼
                Update metadata
                      │
                      ▼
                S3 / Cloudflare R2
                      │
                      ▼
                 Software v1.4

I would not make your ecommerce platform the update server itself. Let it handle commerce/licensing, while your API controls whether a particular installation is entitled to a particular version.

Bottom line

Pick Lemon Squeezy if you're a solo developer and want the least operational work.

Pick WooCommerce + Kestrel API Manager if you want maximum ownership/customization and don't mind maintaining WordPress.

If you're selling Windows/macOS desktop software, I can also compare Lemon Squeezy vs Paddle vs Keygen vs Cryptlex vs WooCommerce specifically for license activation + offline activation + machine limits + paid major-version upgrades. That comparison gets considerably more interesting.

For a solo developer selling desktop/server software licenses with paid updates, I’d pick Lemon Squeezy unless you have a strong reason to own the entire ecommerce stack.

My ranking

🥇 Lemon Squeezy

This is particularly well matched to your requirements.

It natively supports license-key generation, activation limits, expiration, re-issuing/deactivating keys, and an API for validating licenses. docs.lemonsqueezy.com

More importantly for your question, Lemon Squeezy has versioned files specifically intended for software distribution. You can attach versions to product files and use the License API to validate a customer's license before delivering an upgrade. docs.lemonsqueezy.com

So your architecture can be roughly:

Customer
   │
   ▼
Lemon Squeezy checkout
   │
   ├── Payment
   ├── License key generated
   └── Customer gets download
             │
             ▼
       Your application
             │
       validates license
             │
             ▼
       checks latest version
             │
             ▼
       downloads update

It also provides a customer portal where customers can access their licenses and purchased files. www.lemonsqueezy.com

The big advantage for a solo developer is that you're not building the ecommerce infrastructure yourself.

Lemon Squeezy

🥈 Easy Digital Downloads

If your priority is maximum control over the licensing/update system, I'd seriously consider EDD.

Its Software Licensing functionality is designed specifically around software developers: license generation, activation limits, expiration, renewals, and version-controlled update delivery. EDD describes these as core functionality rather than something bolted onto a generic ecommerce system. easydigitaldownloads.com

The tradeoff is that you're operating a WordPress/WooCommerce-like stack yourself. For a solo developer, that means more responsibility for hosting, security, updates, backups, plugins, payment infrastructure, etc.

Easy Digital Downloads

WooCommerce

WooCommerce can actually be extremely good for this if you're willing to assemble the pieces.

Its software add-ons can handle license keys, activation limits, software versions, and downloadable products, and there are extensions with APIs specifically for activation/deactivation and software updates. woocommerce.com

But I'd avoid it for a new solo project unless you specifically want a WordPress-based store. It's considerably more infrastructure than you need if the actual product is your software.

What I'd build

For a typical solo developer, I'd use:

Lemon Squeezy + your own small licensing/update API

with:

• Lemon Squeezy → checkout/payment
• Lemon Squeezy → license creation
• Lemon Squeezy → customer/download management
• Your API → license validation from the application
• Your API → determine whether an update is available
• Lemon Squeezy → host/version the actual update files
• Your application → download/install the update

One important distinction: don't make the license key itself your security mechanism. Have the application communicate with your server and validate the license. That lets you later add activation limits, revocation, grace periods, update entitlements, etc., without changing the customer's license format.

If your business model is specifically "buy version 1, get updates for one year, then buy an update license", rather than subscriptions, I'd structure the licensing slightly differently. Lemon Squeezy supports license lengths for non-subscription products, which fits that model well. docs.lemonsqueezy.com

Bottom line: for a solo developer, Lemon Squeezy is probably the sweet spot. EDD wins if you're willing to run WordPress in exchange for deeper ownership/control of the software licensing infrastructure.

For a solo developer selling desktop software with perpetual licenses + paid updates, I’d pick Lemon Squeezy first.

My ranking

🥇 Lemon Squeezy

Lemon Squeezy is unusually well matched to your requirements.

It has native license-key generation, including license duration and activation limits. Its License API lets your application activate, validate, and deactivate keys. docs.lemonsqueezy.com

More importantly for your use case, Lemon Squeezy's file system explicitly supports software file versions. A file has a version field, and their documentation describes using the License API to validate a customer's license before serving the appropriate software upgrade. docs.lemonsqueezy.comdocs.lemonsqueezy.com

That gives you a fairly clean architecture:

Customer buys "Pro"
        ↓
Lemon Squeezy generates license key
        ↓
Customer receives key + download
        ↓
Your app sends key to your backend/LS
        ↓
License validated
        ↓
App determines entitled version
        ↓
Downloads appropriate update

You can also use their API to build your own "Check for Updates" mechanism rather than exposing permanent public download URLs. Their download URLs are signed and expire, which is useful for protecting your binaries. docs.lemonsqueezy.com

🥈 FastSpring

FastSpring is probably the better choice if your licensing requirements are more complicated.

It has first-class license-key fulfillment and product-download fulfillment, and supports custom license-generation scripts as well as integrations with dedicated licensing systems such as Cryptlex, Cryptolens, LicenseSpring, and others. developer.fastspring.com

I'd choose FastSpring if you anticipate things like:

• floating/network licenses
• complicated activation rules
• multiple licensing schemes
• enterprise customers
• integration with a dedicated licensing service
• more elaborate fulfillment workflows

For a typical indie/solo software product, though, that flexibility may be more infrastructure than you need.

Paddle

Paddle is excellent if your primary concern is selling globally as a merchant of record, particularly with subscriptions. Paddle explicitly supports one-time software products and digital downloads and handles payments, tax, fraud, and global compliance. developer.paddle.com

But if your central requirement is specifically:

license → entitlement → versioned binary → update

I'd put Lemon Squeezy ahead of it.

What I'd build

For a solo developer, I'd avoid building a full licensing server initially.

Use:

Lemon Squeezy

• checkout
• payments/tax
• customer/order records
• license generation
• activation limits
• download storage/delivery
• version metadata
• webhooks

Your application

• stores the customer's license key
• calls the License API
• checks entitlement
• periodically checks for updates
• downloads the appropriate version

Your own small backend only if you need application-specific logic, such as:

license
   ↓
your API
   ├── entitlement
   ├── current version
   ├── update channel
   └── signed download URL

The important design decision is to distinguish license entitlement from software version. For example, a perpetual license might entitle someone to versions 1.x, while purchasing an "Updates for 12 months" entitlement gives access to whatever versions were released during that period.

Bottom line: for a solo developer starting today, Lemon Squeezy is the closest match to "I want to sell software licenses and updates without building an ecommerce/licensing infrastructure myself." Its combination of native license keys + activation + versioned files is particularly compelling for this exact workflow. docs.lemonsqueezy.com

If you tell me whether your software is Windows/macOS/Linux, web, or a plugin, and whether updates are free forever, paid major versions, or a maintenance-period model, I can recommend the exact architecture and data model I'd use.

For a solo developer selling desktop software licenses + ongoing updates, my top pick is Lemon Squeezy.

It is unusually well matched to your exact requirements because it combines checkout, tax/VAT handling, license generation, activation limits, and versioned file delivery rather than making you assemble those pieces yourself.

My ranking

\*Merchant of Record.

Why I'd choose Lemon Squeezy

1. License generation is native.

You can enable license keys on a product/variant, set the license duration and activation limit, and Lemon Squeezy generates a unique key for each purchase. Your application can then validate the key through its License API. docs.lemonsqueezy.com

That gives you a straightforward model such as:

$79 → 1-year license → 2 activations → includes updates for 1 year

or:

$149 → perpetual license → 3 activations → updates for 2 years

2. Versioned software downloads are specifically supported.

This is the killer feature for your use case. Lemon Squeezy lets you create file versions for a product/variant. Their documentation explicitly describes using this for software upgrades where you validate the customer's license and then serve the appropriate software version. docs.lemonsqueezy.comdocs.lemonsqueezy.com

So you could have:

MyApp
├── Windows
│   ├── v1.0.0
│   ├── v1.1.0
│   └── v1.2.0
├── macOS
│   ├── v1.0.0
│   ├── v1.1.0
│   └── v1.2.0
└── Linux
    ├── v1.0.0
    └── v1.1.0

You don't need to build your own download server just to handle this.

3. You can make your own update mechanism.

For example, your application could call your backend:

GET /update?license=XXXX&platform=windows&version=1.1.0

Your backend validates the Lemon Squeezy license and determines whether that customer is entitled to the newer version. Lemon Squeezy's API covers products, files, orders, subscriptions and license keys. docs.lemonsqueezy.com

That gives you considerably more control than simply emailing a download link.

4. It handles the annoying commerce stuff.

For a one-person software business, having the platform handle payments, taxes and the customer billing portal is a big advantage. Customers can access their purchases, license keys and downloadable files through Lemon Squeezy's customer-facing systems. docs.lemonsqueezy.com

Where Gumroad fits

Gumroad is probably my #2 choice if you want the absolute simplest setup.

Gumroad also has native software license keys, including multi-seat licenses, and provides an API for your application to verify them. gumroad.com

It also has product versions, so it can work well for something like:

MyApp
  ├─ Version 1
  ├─ Version 2
  └─ Version 3

The limitation is that license enforcement is more your responsibility: Gumroad's API lets your application verify the key, but your application decides how that verification translates into access. gumroad.com

I'd choose Gumroad if your priority is:

"I want to upload my software and start selling it with almost no engineering."

I'd choose Lemon Squeezy if your priority is:

"I want a proper software licensing/update system that I can integrate into my application."

Paddle

Paddle is excellent, particularly if you're building a subscription SaaS rather than primarily selling downloadable software.

Paddle supports one-time software-license/digital-download purchases, but its current Billing architecture expects you to implement more of the fulfillment logic yourself—for example, listening for transaction.completed and generating the appropriate download URL. developer.paddle.com

For your stated use case, that makes it less attractive than Lemon Squeezy.

The architecture I'd use

If I were building a solo-dev product today, I'd make Lemon Squeezy the commerce/distribution layer, but keep the actual licensing logic in a tiny backend that you control.

                    ┌─────────────────┐
                    │  Your Website   │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │ Lemon Squeezy   │
                    │    Checkout     │
                    └────────┬────────┘
                             │
                  purchase + license
                             │
                             ▼
                    ┌─────────────────┐
                    │ Your Backend    │
                    │                 │
                    │ • entitlement   │
                    │ • update checks │
                    │ • activation    │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │ Desktop App     │
                    │                 │
                    │ license key     │
                    │ activation      │
                    │ update check    │
                    └─────────────────┘

I would not make the desktop app directly depend on Lemon Squeezy for every launch. Put a thin API of your own in front of it. That gives you the ability to change ecommerce providers later without shipping a new version of your application.

One important distinction

If by "license key generation" you mean serious software licensing—offline activation, cryptographically signed licenses, device fingerprinting, floating licenses, revocation, grace periods, etc.—then I would use a dedicated licensing service instead of relying entirely on an ecommerce platform.

But if your requirements are roughly:

• sell a license
• generate a unique key
• limit activations
• validate the key
• sell renewals/updates
• upload new versions
• let licensed customers download updates
• handle payments/tax
• minimize infrastructure

Lemon Squeezy is probably the sweet spot for a solo developer. docs.lemonsqueezy.comdocs.lemonsqueezy.com

If you tell me what kind of software you're selling (Windows/macOS/Linux, one-time vs subscription, perpetual license vs annual updates), I can also lay out the exact licensing + update architecture I'd recommend, including how I'd structure the database and API.

For a solo developer selling software licenses + updates, I would usually avoid a generic ecommerce platform unless you already need its ecosystem. The best choice depends on whether you want maximum control or minimum maintenance.

My shortlist:

My default recommendation: Easy Digital Downloads + Software Licensing

For a one-person software company, this is often the sweet spot:

• Customers buy a license
• A unique key is generated automatically
• Your app checks the key against an API
• You can limit activations
• You can deliver updates only to paying customers
• You can manage renewals/upgrades

It was designed around selling digital products rather than adapting a physical-product cart. eddsellservices.com

A typical architecture:

Website
 └── Easy Digital Downloads
      ├── Checkout
      ├── Customer accounts
      ├── License database
      ├── Update API
      └── Download permissions

Your software
 ├── Sends license key
 ├── Checks activation
 ├── Checks latest version
 └── Downloads update

When I would choose WooCommerce instead

Choose WooCommerce if you need:

• complex pricing
• bundles
• physical products later
• lots of payment/shipping integrations
• a heavily customized storefront

For software licensing, WooCommerce needs an extension. Options such as Kestrel's API Manager or Software Add-on add automatic key generation, activation handling, upgrades, and secure downloads. eddsellservices.comwoocommerce.com

When I would not build my own licensing system

A common solo-dev trap is:

"I'll just generate UUIDs and store them in my database."

The hard parts are not generating keys. They are:

• activation limits
• stolen keys
• refunds
• subscription expiry
• offline activation
• version entitlement ("customer owns v3 but not v4")
• customer account recovery

A dedicated licensing service like Keygen can handle the licensing layer if you prefer to build your own checkout. freemius.com

My picks by product type

Desktop app (Windows/macOS/Linux):

1. Paddle or another merchant-of-record + Keygen/LicenseSpring-style licensing
2. EDD + custom updater

WordPress plugin/theme:

1. Easy Digital Downloads
2. Freemius
3. WooCommerce + licensing plugin

Developer tool / CLI / SDK:

1. Stripe + Keygen-style API
2. EDD if you want a simple store

Small indie app with <10k customers:
I would probably start with:

• WordPress
• Easy Digital Downloads
• Software Licensing
• S3 or Cloudflare R2 for binaries
• a small update API

It keeps your monthly costs low and avoids building commerce infrastructure.

One question changes the recommendation quite a bit: are you selling a desktop application, a WordPress/plugin product, or a SaaS/API subscription?

For a solo developer selling desktop software licenses + paid updates, I’d pick Lemon Squeezy first.

The reason is that your requirements line up unusually well with its native features:

Lemon Squeezy can generate a license automatically when a customer purchases a product, with configurable license length and activation limits. Your application can then activate, validate, or deactivate the license through its API. docs.lemonsqueezy.com

More importantly for your particular model, its file system supports versions. You can attach versioned files to a product/variant—for example 1.0.0, 1.1.0, 2.0.0—and use the license API to determine whether the customer is entitled to the download. docs.lemonsqueezy.com

How I'd structure it

For example:

Product: MyApp Pro
License: perpetual
Update entitlement: 12 months

Customer buys → Lemon Squeezy:

1. Creates order
2. Generates license key
3. Emails license to customer
4. Your app activates the key
5. Your server validates the license
6. Customer checks for updates
7. Your server determines which versions they're entitled to
8. Customer downloads the appropriate installer

You can therefore keep your actual application fairly simple while letting Lemon Squeezy handle checkout, payment, tax, license records, and file delivery.

The important caveat

I wouldn't make Lemon Squeezy the entire update/licensing architecture if your software has sophisticated entitlement rules.

For example, if you need:

"Customer bought v3 in 2024, receives all 3.x updates forever, but cannot download 4.x unless they purchase an upgrade."

I'd put a small entitlement service/database of your own between the application and Lemon Squeezy.

Think of it as:

Lemon Squeezy → commerce + basic license

Your API → entitlement + update logic

Object storage/CDN → actual installers

That gives you much more flexibility than trying to encode every rule into the ecommerce platform.

Alternatives

Paddle is my second choice. It's particularly attractive if you're building toward a larger SaaS/software business and need sophisticated billing. It supports one-time software licenses and digital downloads, but license management isn't as directly integrated as Lemon Squeezy's. developer.paddle.com

FastSpring is worth considering for more established software companies. It has extensive digital-product infrastructure, but its licensing workflow relies on third-party license-management integrations rather than providing the same simple native license-key system. developer.fastspring.com

My ranking for your use case:

1. 🥇 Lemon Squeezy — best overall for a solo developer
2. 🥈 Paddle — better if you're building a substantial SaaS/business operation
3. 🥉 FastSpring — stronger when you need more enterprise-oriented software commerce
4. Stripe + your own licensing system — maximum control, but considerably more work

So if your goal is "I want to sell a Windows/macOS/Linux app, issue license keys, sell upgrades, and deliver versioned installers without spending months building ecommerce infrastructure", I'd start with Lemon Squeezy.

Lemon Squeezy licensing documentation

Lemon Squeezy file-version documentation

If you tell me whether your software is desktop, plugin, CLI, or SaaS, and whether updates are perpetual or subscription-based, I can also recommend the ideal licensing/entitlement architecture around it.