Migrating from Lemon Squeezy
Lemon Squeezy is shutting down : it closed sign-ups on November 16, 2026, and stops processing payments on March 31, 2027, subscription renewals included. Its recommended replacement, Stripe Managed Payments, takes the payments, but doesn’t deliver license keys: Lemon Squeezy’s migration docs tell you to connect a licensing app or build your own.
This guide moves the license keys of Acme Photo, a desktop app sold on Lemon Squeezy, to LicenseManager, with their current keys: your customers keep the keys they have, and the next version of your app validates them with LicenseManager. You’ll:
- Choose how you’ll take payments after Lemon Squeezy.
- Prepare the product and its policies.
- Export your license keys from Lemon Squeezy.
- Import them.
- Connect your new payment provider, so new sales create licenses.
- Ship a version of your app that validates keys with LicenseManager, before March 31.
We do the import for you, for free. Email sales@licensemanager.dev with your store’s size and where you’re moving your payments: we export your keys, import them, link your subscriptions, and check the result with you.
The timeline
| Date | What happens |
|---|---|
| November 16, 2026 | Lemon Squeezy closes new sign-ups. |
| December 2, 2026 | Its migration tooling to Stripe Managed Payments opens: it copies your products to Stripe, migrates your customers, and moves eligible card subscriptions. |
| Mid-January 2027 | The latest date Lemon Squeezy recommends to start: a migration takes 4 to 8 weeks. |
| March 31, 2027 | Lemon Squeezy stops processing payments, renewals included, with no extension. Its docs warn that customers may lose access to their license keys after this date. |
What happens to the License API (/v1/licenses/activate, validate, deactivate) after March 31 isn’t documented. Plan as if it stops: every copy of your app calling api.lemonsqueezy.com would then fail to validate its key. Ship the version that validates with LicenseManager well before, so most of your customers have updated by then.
Choose how you’ll take payments
LicenseManager doesn’t take payments: it creates licenses when your payment provider tells it a customer paid. It works with:
- Stripe Managed Payments, Lemon Squeezy’s recommended path, a merchant of record like Lemon Squeezy: Stripe’s Link handles sales tax and VAT. Available to businesses in the US, Canada, most of Europe, the UK, Australia, Hong Kong, Japan and Singapore. Lemon Squeezy’s tooling moves your customers and subscriptions to it.
- Paddle, another merchant of record, if your business is based in a country Managed Payments doesn’t support.
- Stripe without Managed Payments, if you handle sales tax yourself.
The Stripe integration works the same with or without Managed Payments: Managed Payments sales are Stripe Checkout Sessions and Payment Links on your own Stripe account.
Prepare the product
Create the product
Create the product in LicenseManager, and a test product of it to try the import first.
Create one policy per variant
Lemon Squeezy sells variants of a product, like Personal and Team. Create one policy per variant, named like the variant: the import matches each key’s variant name to a policy’s name.
Set each policy’s max machines to the variant’s activation limit, and its duration like the variant’s license length. Imported keys keep their own expiration and activation limit: the policy gives the defaults of new sales.
Record your past releases, if updates are limited
If your licenses include updates for a limited time, create a release for each version you shipped, with its real release date, before importing.
Export your license keys
Lemon Squeezy’s dashboard exports orders, not license keys. The script below reads your license keys with the Lemon Squeezy API and writes them as a CSV file ready to import.
Create an API key in Lemon Squeezy, under Settings → API, then run the script with Node.js 20 or later. It has no dependencies:
// Usage: LEMON_SQUEEZY_API_KEY=… node export-lemon-squeezy.mjs > licenses.csv
const API = "https://api.lemonsqueezy.com/v1";
const headers = {
Accept: "application/vnd.api+json",
Authorization: `Bearer ${process.env.LEMON_SQUEEZY_API_KEY}`,
};
// Reads every page of a list, 100 at a time, slowly enough for the rate limit.
async function list(path) {
const items = [];
for (let page = 1; ; page++) {
const res = await fetch(`${API}/${path}?page[number]=${page}&page[size]=100`, { headers });
if (!res.ok) throw new Error(`${path}: ${res.status} ${await res.text()}`);
const body = await res.json();
items.push(...body.data);
if (page >= body.meta.page.lastPage) return items;
await new Promise((resolve) => setTimeout(resolve, 250));
}
}
const cell = (value) => {
const text = value == null ? "" : String(value);
return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
};
// The variant of each key, to match it to a policy, comes from its order item.
const variants = new Map(
(await list("order-items")).map((item) => [item.id, item.attributes.variant_name]),
);
const keys = await list("license-keys");
console.log([
"key", "email", "name", "policy", "expires_at", "max_machines", "status",
"lemon_squeezy_license_key_id", "lemon_squeezy_order_id", "lemon_squeezy_customer_id",
"lemon_squeezy_product_id", "lemon_squeezy_created_at",
].join(","));
for (const { id, attributes: key } of keys) {
console.log([
key.key,
key.user_email,
key.user_name,
variants.get(String(key.order_item_id)),
key.expires_at,
key.activation_limit ?? "unlimited",
key.disabled ? "disabled" : key.status,
id,
key.order_id,
key.customer_id,
key.product_id,
key.created_at,
].map(cell).join(","));
}
console.error(`Exported ${keys.length} license keys`);LEMON_SQUEEZY_API_KEY=eyJ0eXAiOiJKV1Qi… node export-lemon-squeezy.mjs > licenses.csvThe file has one row per key:
key,email,name: the key, kept as is, and its customer.policy: the variant’s name, matched to the policy of the same name. Keys of a variant without a policy fail to import: create the policy, or edit the column.expires_at: empty for keys that never expire.max_machines: the activation limit, orunlimited.status: disabled keys are left out. Expired keys are imported expired, so their customers can renew.- The
lemon_squeezy_…columns go into each license’s meta, to find a key’s order or customer again.
If you sell several products on the same store, split the file by lemon_squeezy_product_id, and import each part in its LicenseManager product.
Link the subscriptions
Skip this step if you only sold one-time licenses.
Lemon Squeezy’s tooling moves your card subscriptions to Stripe: each one gets a new Stripe subscription id, sub_…, and keeps renewing in Stripe. Each subscription’s key must be linked to it on import. Otherwise, its next renewal in Stripe creates a new license with a new key, emailed to the customer, and the imported key expires.
Wait for the subscriptions to move
Lemon Squeezy gives customers at least 14 days’ notice before moving their subscription. Import after the move, once the subscriptions exist in Stripe.
Map the new prices
Lemon Squeezy’s tooling creates a Stripe product per variant. Connect Stripe, then map each recurring price to the variant’s policy.
Add the subscription ids
Add a subscription_id column to the CSV file, with the Stripe subscription of each subscription key. Lemon Squeezy’s migration report maps your Lemon Squeezy customers to their Stripe customers: the subscription is the one of that Stripe customer, in the Stripe dashboard’s Subscriptions, filtered by customer.
The import then links each license to its subscription: renewals extend the imported license, and it expires when the subscription ends. Subscriptions moved to Paddle work the same, with a paddle_subscription_id column.
PayPal subscriptions can’t move: Managed Payments doesn’t take PayPal. Their customers subscribe again, which creates a new license with a new key. Expire the old one at the end of its paid period by importing it with its expires_at.
Import
Import the file from the product’s Licenses page: click Import and choose the file. The dialog shows how each column was read and the rows with errors, before sending anything. See importing licenses for the format and the API.
Import in the test product first, then in the live product. Importing the same file again skips the keys already imported: run it again after new sales, until your new payment provider takes over.
Sell with your new provider
From the day you switch your checkout to Stripe or Paddle, sales create licenses in LicenseManager, with keys emailed to your customers:
- Stripe Managed Payments or Stripe: connect Stripe and map your prices, one-time and recurring. Your Lemon Squeezy checkout links don’t redirect: replace them with a Payment Link or Stripe Checkout.
- Paddle: connect Paddle and map your prices.
Your customers manage their licenses, see their machines and free a place from the customer portal, which replaces Lemon Squeezy’s for license keys. With Managed Payments, they manage their payments and subscriptions in Link.
Update your app
Your app calls Lemon Squeezy’s License API. The new version validates keys with LicenseManager instead, with an SDK or one request:
| Lemon Squeezy | LicenseManager |
|---|---|
POST /v1/licenses/activate with license_key and instance_name | Validate the key with the machine’s fingerprint and name: the first validation on a machine activates it. In Electron, setLicenseKey. |
POST /v1/licenses/validate with license_key and instance_id | The same validation, on each launch. The SDKs do it for you, and verify the signed token offline in between. |
POST /v1/licenses/deactivate with instance_id | Deactivate the machine: your customers do it from the customer portal, and a new computer can take the place of an old one on its own. |
activation_limit, activation_usage | The license’s max machines, and its active machines. |
status: expired or disabled | license_expired, see handling errors. |
The instance_id your app stored | Nothing to store: the machine is identified by its fingerprint. |
Validate the stored key once
When the new version starts with a Lemon Squeezy key stored by the previous one, it passes it to LicenseManager silently, once, and stores the license token. The customer doesn’t enter their key again.
import { LicenseManager } from "@licenseman/electron";
const license = new LicenseManager({ productId: "x7Kp2QaZ", publicKey: PUBLIC_KEY });
const state = await license.ready();
// The key the Lemon Squeezy version stored, wherever your app kept it.
const previousKey = await readLemonSqueezyKey();
if (state === "MISSING_KEY" && previousKey) {
try {
await license.setLicenseKey(previousKey);
await deleteLemonSqueezyKey();
} catch {
// Not imported, or expired: the activation screen asks for a key.
}
}Ship it before March 31
Customers who don’t update keep the Lemon Squeezy version, which stops working if Lemon Squeezy’s License API does. Ship the new version early, with auto-updates on (Electron, Tauri), and keep importing new Lemon Squeezy sales until your checkout has moved.
Edge cases
Keys are case sensitive. The export keeps Lemon Squeezy’s keys exactly as your customers received them. Your app must send them the same way: don’t change their case before validating them.
Activations aren’t imported. Each license starts with no machine, and each computer takes a place at its first validation with the new version. A key activated on 2 computers with a limit of 2 keeps working on both.
The same customer on two stores, or with two emails, makes two customers. Merge the emails in the file when you can.
Keys sold after the import aren’t in LicenseManager until you import them: import the file again, which skips the keys already there, until your checkout has switched.
Refunds and disputes are handled by your payment provider. A refund you make in Stripe doesn’t change the license: cancel it or expire it yourself, see refunds made in Stripe.