Skip to content

Migrate from Lemon Squeezy before March 31, 2027

Lemon Squeezy is shutting down. Stripe, which owns it, closed new store sign-ups on November 16, 2026, and Lemon Squeezy stops processing transactions, including subscription renewals, on March 31, 2027. Lemon Squeezy says the deadline won't be extended, that a migration can take up to eight weeks, and that you should start no later than mid-January 2027. Its tooling to move stores to Stripe Managed Payments arrives on December 2, 2026. Sources.

This guide moves a Lemon Squeezy store to Flint, for a business in the US. On Flint your business is the seller: the charge carries your name, and you can sell digital products, subscriptions, services, and physical goods from one catalog, with orders, shipping, inventory, invoices, and a customer account included. Cards are 3.79% + 35¢ per payment, plus 0.40% on subscription payments and 0.50% on payments that carry automatic tax (fees), where Lemon Squeezy charged 5% + 50¢ per transaction. Flint as a Lemon Squeezy alternative compares the two in full.

Choose Stripe Managed Payments instead if you need either of these:

  • Saved cards that move with the subscription. Lemon Squeezy's tooling moves most card subscriptions to Managed Payments without subscribers entering their card again. Flint has no route that imports cards, so every subscriber saves a card on Flint once.
  • A merchant of record that keeps filing your tax. Managed Payments, like Lemon Squeezy, is the seller and files the tax. Flint calculates and collects tax, and your business files it.

Managed Payments isn't available in every country Lemon Squeezy supports, and it covers eligible digital products only. A US business that sells goods or services, or wants its own name on the charge, moves to Flint.

What changes when you're the seller#

Lemon Squeezy is the merchant of record: its company sells to your buyers and resells to you. On Flint, your business is the seller, which changes three things.

Lemon SqueezyFlint
Sales tax and VATLemon Squeezy calculates, collects, files, and pays itAutomatic tax calculates and collects US sales tax, and tax on digital goods, software, and SaaS sold to Canada, the EU, the UK, Australia, and New Zealand, wherever you add a registration. You register and file, from Flint's tax reports. Or send rates from your own tax engine.
Name on the receipt and card statementLemon Squeezy, as the sellerYour business. Set the statement text with payments.statement_descriptor in settings.
Refunds and disputesLemon Squeezy receives chargebacks and processes refunds on its accountRefunds come from your balance, and disputes come to you to answer with evidence before evidence_due_at, in the dashboard or the API

Before you collect tax on Flint, register in each state or country where you owe it, then add each registration to Flint with POST /v1/tax-connection/registrations. A place where you aren't registered calculates zero tax. Connect automatic tax has the steps. Flint doesn't decide where you owe tax or file returns for you; confirm your obligations with a tax professional.

Tell your buyers about the change too. Their next charge shows your business name instead of Lemon Squeezy's, and a charge a buyer doesn't recognize is a common reason for a dispute.

Lemon Squeezy objects and their Flint equivalents#

Lemon SqueezyFlintNotes
StoreYour Flint account and its settingsBusiness name, branding, statement descriptor, and support details
Test mode and test API keysA sandbox and a test key, flint_test_...Same base URL as live. Stripe test cards such as 4242 4242 4242 4242 work in a sandbox.
Product and its variants, one-time priceProduct prod_ with product_type: "digital", and its variants var_The variant carries the price. An order line names a variant_id.
Subscription variant (interval, interval_count)Subscription plan plan_ with billing_interval and billing_interval_countdaily, weekly, monthly, or yearly. A variant's free trial becomes the plan's trial_period_days.
Pay-what-you-want variantPayment link line of type: "custom_variable"Buyer chooses the price
Checkout created with the Lemon Squeezy checkouts APICheckout session cs_One buyer, one order. Send the buyer to url exactly as returned.
Checkout link shared from the dashboardPayment link pl_Every buyer who opens it gets their own order
checkout_data.custom, returned in meta.custom_datametadata on the order, which every order read and order.* event carriesUp to 50 keys. Metadata and your IDs.
Checkout overlay (Lemon.js)Hosted checkout, or your own page with embedded paymentsFlint has no overlay script
CustomerCustomer cus_
Order and order itemsOrder ord_ and its line itemsFlint prices lines, discounts, and tax on the server
SubscriptionSubscription sub_Statuses map below
Subscription invoiceThe renewal's order, which carries subscription_id
Discount and discount codePromotion promo_ with codesamount_type percent is percent_off, fixed is amount_off. duration is application_method.recurrence.
Customer portalCustomer accountBuyers change the card on a subscription, pause, cancel, and see orders
Order refundRefund ref_, POST /v1/refundsRefund the whole order, an amount, or specific line items
Webhook (X-Signature HMAC)Webhook endpoint whep_A JWT you verify against Flint's public keys, or HMAC when you ask for it
License key and license key instanceLicense key lk_ and its activations lka_Flint issues, emails, and disables keys. See Deliver digital products.
FilesYour own serverFlint doesn't host downloads

Lemon Squeezy IDs are numeric, and Flint rejects them in fields that take a Flint ID. Keep each Lemon Squeezy ID in the Flint object's external_reference_id, which customers, products, subscription plans, subscriptions, and orders accept and their list endpoints filter by. An import that stops halfway can then look up what it already created.

Before you start#

  • Export your data. Lemon Squeezy exports customers, orders, and subscriptions as CSV, and its API lists each object with your live API key. Export early and again before the shutdown.
  • Keys and URL. Create a test key in the dashboard and call https://api.withflintpay.com with Authorization: Bearer. No account yet? Sign up and you get a sandbox.
  • Request bodies. Flint takes plain JSON, not JSON:API documents: fields sit at the top level of the body, not under data.attributes, and responses put the object in data.
  • Money. Every amount is an integer in minor units with a currency, {"amount": 2900, "currency": "USD"}, where Lemon Squeezy sends a bare number of cents. Prices and payouts are in USD.
  • Idempotency. Send Idempotency-Key on every write that accepts one, derived from the Lemon Squeezy ID and the action, so a rerun import never creates twice. Routes that can move money or stock require one.

Recreate your catalog#

Create one Flint product per Lemon Squeezy product you sell once, with each variant's price on a Flint variant:

cURL
curl -X POST https://api.withflintpay.com/v1/products \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: import-ls-product-48291" \
  -d '{
    "variant_mode": "simple",
    "name": "Icon pack",
    "product_type": "digital",
    "default_variant": {
      "unit_price_money": {"amount": 2900, "currency": "USD"}
    },
    "external_reference_id": "ls-product-48291"
  }'

A digital product's variants take the digital_goods tax category unless you set another, which automatic tax uses in every place it covers. Use software or saas where that describes the product better; Tax categories lists them.

Recreate each subscription variant as a subscription plan:

cURL
curl -X POST https://api.withflintpay.com/v1/subscription-plans \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: import-ls-variant-73105" \
  -d '{
    "name": "Pro Monthly",
    "billing_interval": "monthly",
    "billing_interval_count": 1,
    "currency": "USD",
    "line_items": [{
      "type": "custom",
      "name": "Pro plan",
      "unit_price_money": {"amount": 1900, "currency": "USD"},
      "quantity": 1
    }],
    "external_reference_id": "ls-variant-73105"
  }'

Recreate discount codes as promotions. A Lemon Squeezy duration of once, repeating, or forever is the promotion's application_method.recurrence.type, and duration_in_months becomes period_count, counted in billing cycles. starts_at and expires_at become the promotion's schedule, and max_redemptions becomes a code's max_uses.

Move checkout#

Choose by how many buyers pay through one URL:

Your Lemon Squeezy codeUse in Flint
Creates a checkout per buyer with the checkouts API, often with checkout_dataAn order, then a checkout session for it
Shares one checkout link for a variantA payment link with a variant line
Sells a subscription variantA checkout session with type: "subscription_plan", or a payment link with subscription_plan_id

For a per-buyer checkout, create the order with the catalog variant and put what you sent in checkout_data.custom in the order's metadata:

cURL
curl -X POST https://api.withflintpay.com/v1/orders \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: order-user-4821-icon-pack" \
  -d '{
    "line_items": [
      {"type": "variant", "variant_id": "var_1kmn0aExample", "quantity": 1}
    ],
    "metadata": {"user_id": "user_4821"}
  }'

Then create a checkout session for the order, where redirects.success_url replaces product_options.redirect_url:

cURL
curl -X POST https://api.withflintpay.com/v1/checkout-sessions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: checkout-user-4821-icon-pack" \
  -d '{
    "type": "order",
    "order_id": "ord_1kmn0aExample",
    "redirects": {
      "success_url": "https://example.com/thanks",
      "cancel_url": "https://example.com/pricing"
    }
  }'

Redirect the buyer to the session's url exactly as returned. Fulfill from the order.paid webhook, not from the redirect. Sell with hosted checkout is the whole flow, from the product to access after a refund.

For a shared link, create a payment link with the variant:

cURL
curl -X POST https://api.withflintpay.com/v1/payment-links \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: payment-link-icon-pack-001" \
  -d '{
    "name": "Icon pack",
    "line_items": [{
      "type": "variant",
      "key": "icon-pack",
      "variant_id": "var_1kmn0aExample"
    }],
    "buyer_fields": {"require_email": true},
    "redirects": {"success_url": "https://example.com/thanks"}
  }'

The response carries the link's url. Replace your Lemon Squeezy buy links with it on your site.

Deliver digital products#

Where Lemon Squeezy generated license keys for a variant, add license_key_configuration to the Flint variant. Flint issues a key for each unit paid for, emails it to the buyer, and disables it after a refund or chargeback. Your app calls POST /v1/license-key-activations where it activated a Lemon Squeezy instance, and POST /v1/license-keys/validate where it validated a key, with your Flint product IDs and no credential. Sell software license keys covers the calls.

Flint doesn't import keys you already sold. List them with Lemon Squeezy's API before the shutdown, and have your app check them against your own server while new keys go to Flint.

Flint doesn't host downloads. Where Lemon Squeezy attached files to a variant, your server does that after order.paid: serve the file from your own storage with a signed link, or open the course for the user in the order's metadata. Before you grant, check the order's dispute_status, and take access back after a refund or chargeback by the rules in Revoke access after a refund or dispute.

Import customers#

Create one Flint customer per Lemon Squeezy customer you still sell to or bill, with the Lemon Squeezy ID in external_reference_id:

cURL
curl -X POST https://api.withflintpay.com/v1/customers \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: import-ls-customer-1934020" \
  -d '{
    "name": "Ada Lovelace",
    "email": "ada@example.com",
    "external_reference_id": "ls-customer-1934020",
    "on_email_conflict": "return_existing"
  }'

An email belongs to one customer in a Flint environment, compared without case. on_email_conflict: "return_existing" returns the customer that already has the email, unchanged, instead of 409 ALREADY_EXISTS. Store data.customer_id beside the Lemon Squeezy ID. Phone numbers must be E.164, such as +14155551234, or left out.

Guest orders that were unlinked before the import stay unlinked. When a returning buyer checks out as a guest and types an imported customer's email, that order also stays unlinked (customer_id: null) and doesn't appear in the customer's order history. To attach earlier guest purchases, have the buyer verify that email with a Flint code, then call link-guest-purchases.

For future purchases, set customer_id on the order before checkout for a signed-in buyer, or let a guest verify their email in checkout where that option is available. After cutover, share your Flint customer account link so buyers can see the purchases linked to them.

Move subscribers#

Cards saved with Lemon Squeezy don't move to Flint, and Flint has no route that imports cards. Each subscriber saves a card on Flint in the browser, before their next renewal. Their subscription moves without a charge: import it with the period they already paid Lemon Squeezy for, and Flint takes over at the next renewal. Subscribers who paid with PayPal save a card too, because Flint doesn't take PayPal.

For each active subscriber:

  1. Import the subscription with billing_start.type: "imported". The import doesn't need a card.
  2. Have the subscriber save a card. Send them to your store's customer account, where they choose a card for their subscription. While Flint sends subscription emails, the default, it also emails a card request 3 days before the billing date to each subscriber who hasn't added one.
  3. Cancel the Lemon Squeezy subscription once the Flint one exists, so only Flint renews it.

Subscription statuses#

Lemon Squeezy statusFlintWhat to do
activeactiveImport it.
on_trialtrialing, or scheduledDon't import. Once the subscriber saves a card, create the subscription with "billing_start": {"type": "scheduled", "starts_at": "..."} at trial_ends_at, on a plan without trial_period_days. Nothing is charged before then.
cancelled, in its grace periodactive with cancel_at_period_end: trueDon't import. Keep access in your app until ends_at.
past_due or unpaidpast_dueThe current period isn't paid, so it can't be imported. Once the subscriber saves a card, create the subscription with "billing_start": {"type": "immediate"}, which charges the period now, and cancel it on Lemon Squeezy.
pausedpausedCreate it when the subscriber comes back, with an immediate start and a saved card.
expiredcanceledNothing to move. Import the customer only.

Import each subscriber#

Lemon Squeezy reports the end of the current period in renews_at. Send its start, one plan interval earlier, as period_started_at, and the number of periods already paid, including the current one, as completed_cycles. Run the body through POST /v1/subscription-previews with "mode": "create" first; it returns is_valid and every error, and creates nothing. Import subscribers from another tool shows the preview. Then create:

cURL
curl -X POST https://api.withflintpay.com/v1/subscriptions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: import-ls-subscription-582044" \
  -d '{
    "terms": {
      "type": "subscription_plan",
      "subscription_plan_id": "plan_1kmn0aExample"
    },
    "customer_id": "cus_1kmn0aExample",
    "billing_start": {
      "type": "imported",
      "period_started_at": "2026-12-04T00:00:00Z",
      "completed_cycles": 9
    },
    "external_reference_id": "ls-subscription-582044"
  }'
Response
{
  "data": {
    "subscription_id": "sub_1kmn0aExample",
    "status": "active",
    "customer_id": "cus_1kmn0aExample",
    "subscription_plan_id": "plan_1kmn0aExample",
    "payment_method_id": null,
    "payment_method_due_at": "2027-01-04T00:00:00Z",
    "current_period_start_at": "2026-12-04T00:00:00Z",
    "current_period_end_at": "2027-01-04T00:00:00Z",
    "next_billing_at": "2027-01-04T00:00:00Z",
    "completed_cycles": 9,
    "external_reference_id": "ls-subscription-582044"
  }
}

Check that next_billing_at matches the subscriber's renews_at. If it doesn't, correct it with PATCH /v1/subscriptions/{subscription_id} and a billing_schedule, as Control the billing schedule describes.

  • Import before the period ends. A period that has already ended returns 400 INVALID_REQUEST on billing_start.period_started_at. Don't fall back to an immediate start for a subscriber who already paid: it charges the period again.
  • Bind the card before payment_method_due_at. A card the subscriber chooses for the subscription in the customer account is bound to it. A card you save with POST /v1/payment-methods binds when you send its ID with PATCH /v1/subscriptions/{subscription_id}. If the billing date arrives without a card, nothing is charged and the subscription goes past_due. Import without a card has the details.
  • Keep remaining discounts. For a subscriber partway through a repeating discount, attach the promotion in promotions with consumed_cycles set to the discounted periods already used. See Attach promotions when you create or import.
  • Retry safely. Use one Idempotency-Key per subscriber and reuse it on retries. A second import with the same external_reference_id returns 409 ALREADY_EXISTS with the existing subscription in details[0].current_resource.
  • Send your own announcement. Each imported subscriber gets Flint's "You're subscribed" email. To explain the move in your own words, set customer_email_delivery.subscription_lifecycle to merchant_sends before you import, and send from subscription.created. Flint then sends no card requests either, so ask for the card in your own email. Customer email delivery has the setting.

The dashboard's CSV import runs the same preview and create for plan subscriptions, so you can import from Lemon Squeezy's subscription export without code.

Switch webhooks#

Register an endpoint and list the events you handle:

cURL
curl -X POST https://api.withflintpay.com/v1/webhook-endpoints \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: webhook-endpoint-lemon-squeezy-migration-001" \
  -d '{
    "url": "https://example.com/webhooks/flint",
    "enabled_events": [
      "order.paid",
      "refund.succeeded",
      "refund.partially_succeeded",
      "refund.failed",
      "dispute.created",
      "subscription.created",
      "subscription.activated",
      "subscription.payment_succeeded",
      "subscription.past_due",
      "subscription.paused",
      "subscription.resumed",
      "subscription.cancellation_scheduled",
      "subscription.reactivated",
      "subscription.canceled",
      "customer.updated"
    ],
    "description": "Lemon Squeezy migration"
  }'

Lemon Squeezy signs each delivery with an HMAC of the raw body in X-Signature and names the event in the payload's meta.event_name. Flint signs a new endpoint with a JWT you verify against Flint's public keys, with the webhook_endpoint_id as the audience, so there is no secret to store. To keep a shared-secret verifier, add "signing_methods": ["hmac"] and verify Standard Webhooks signatures. Route on event_type, read the resource from data.object, and deduplicate on webhook_event_id.

Lemon Squeezy's subscription_updated fires on every change. Flint sends a specific event for each change and subscription.updated only for changes no other event describes, so most handlers that read the status from subscription_updated become one handler per event:

  • order.paid
    The order is paid in full. Deliver the product, after you check dispute_status.
    order_created
  • refund.succeeded
    Every part of the refund succeeded. Recompute what the order still grants.
    order_refunded
  • refund.partially_succeeded
    Part of the refund succeeded.
    order_refunded
  • customer.updated
    A customer changed.
    customer_updated
  • subscription.created
    A subscription was created on any surface, including an import.
    subscription_created
  • subscription.activated
    The first period is paid or imported. Grant access. Sent once per subscription.
    subscription_created
  • subscription.payment_succeeded
    A renewal was paid, including one that recovers a failed renewal.
    subscription_payment_success
  • subscription.past_due
    A charge failed and Flint is retrying. Ask for a new card.
    subscription_payment_failed
  • subscription.cancellation_scheduled
    The subscription ends at scheduled_cancel_at. Keep access until then.
    subscription_cancelled
  • subscription.reactivated
    A scheduled cancellation was undone.
    subscription_resumed
  • subscription.paused
    Billing is suspended.
    subscription_paused
  • subscription.resumed
    Billing resumed. Grant paid access when the status is active.
    subscription_unpaused
  • subscription.canceled
    The subscription ended. Remove access.
    subscription_expired
  • license_key.created
    A key was issued for a paid unit.
    license_key_created
  • license_key.updated
    A key was reinstated, replaced, or its terms changed. license_key.disabled and license_key.expired report when it stops working.
    license_key_updated
  • dispute.created
    A buyer disputed a payment. Answer before evidence_due_at.
    No Lemon Squeezy event

affiliate_activated has no Flint event. The event catalog lists every event Flint sends.

Past orders and refunds#

Flint doesn't import order history: no route creates a paid order for a sale Lemon Squeezy already took. Keep your Lemon Squeezy exports, and refund Lemon Squeezy orders in Lemon Squeezy while it still processes transactions, which ends on March 31, 2027. For sales on Flint, POST /v1/refunds with order_id and refund_type of full, amount, or targets replaces Lemon Squeezy's order refund. A 201 means Flint recorded the refund; follow refund.succeeded and refund.failed for the outcome. Refunds covers line-item refunds and failures.

Cutover checklist#

Lemon Squeezy stops processing on March 31, 2027, so every step finishes before then.

  1. By December 4, 2026. Export customers, orders, subscriptions, and license keys. Create a Flint account and run the whole migration in a sandbox: catalog, plans, promotions, a webhook handler, and a test import.
  2. By December 18, 2026. Register for sales tax where you owe it, connect automatic tax, set your statement descriptor, and finish onboarding so the account can take live payments.
  3. By January 8, 2027. Send new purchases and new subscribers to Flint checkout sessions and payment links, and remove Lemon Squeezy checkout links from your site.
  4. From January 11, 2027. Import subscribers in batches ordered by renews_at, each before their Lemon Squeezy renewal. Tell each one about the move, send them to the customer account to add a card, and cancel their Lemon Squeezy subscription once the Flint one exists.
  5. By March 1, 2027. Every active subscriber is imported, including annual ones whose next renewal comes after the shutdown, and you've followed up with each subscriber whose payment_method_id is still null.
  6. By March 26, 2027. Refund any Lemon Squeezy orders you still need to, take a final export, and remove the Lemon Squeezy webhook once nothing new is created there.

Ready to move? Create a Flint account and run the import in your sandbox.

Sources#

Read November 17, 2026.

Next steps#

Sell with hosted checkoutA digital product from catalog to order.paid, delivery, refunds, and disputes.Subscription billingPlans, imports, renewals, failed payments, and plan changes.Sales taxAutomatic tax, registrations, and the reports you file from.Migrating from StripeThe same moves from a Stripe integration.

Was this helpful?