Migrate to Polar

Why migrate to Polar?

Polar offers several advantages over traditional payment platforms:

Developer-First

Built by developers, for developers. Clean REST API, type-safe SDKs, and comprehensive documentation.

Open Source

Fully open source with Apache 2.0 license. Transparent pricing, no vendor lock-in, and community-driven development.

All-in-One

Payments, subscriptions, benefits, usage billing, and customer portal in one platform.

Lower Fees

Simple 4% + 40¢ per transaction. No monthly fees, no setup costs, no surprises.

Migration overview

Migrating to Polar involves four main phases:

Data mapping

Understand how your existing data maps to Polar’s data model

Setup & configuration

Create your Polar account, connect Stripe, and configure products

Customer & subscription migration

Import existing customers and transition active subscriptions

Integration & cutover

Update your application code and switch to Polar

Timeline: Most migrations complete in 1-2 weeks depending on complexity. For large customer bases (10,000+ subscribers), plan for 2-4 weeks.

Platform-specific guides

Stripe Billing
Paddle
Lemon Squeezy
Other Platforms

Migrating from Stripe Billing

Polar uses Stripe for payment processing, making migration smoother. You can keep your existing Stripe account.

Data mapping

Stripe Billing	Polar Equivalent
Product	Product
Price	Product Price
Customer	Customer
Subscription	Subscription
Invoice	Order (for subscription)
Charge	Order (one-time)
Coupon	Discount

Migration steps

Export Stripe data

Use Stripe’s API to export your data:

import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

// Export products
const products = await stripe.products.list({ limit: 100 });

// Export customers
const customers = await stripe.customers.list({ limit: 100 });

// Export subscriptions
const subscriptions = await stripe.subscriptions.list({ limit: 100 });

For large datasets, use pagination and save exports to CSV for easier review.

Create products in Polar

Recreate your Stripe products in Polar:

import { Polar } from "@polar-sh/sdk";

const polar = new Polar({
  accessToken: process.env.POLAR_ACCESS_TOKEN,
});

for (const stripeProduct of products.data) {
  // Get prices for this product
  const prices = await stripe.prices.list({ 
    product: stripeProduct.id 
  });
  
  await polar.products.create({
    name: stripeProduct.name,
    description: stripeProduct.description,
    prices: prices.data.map(price => ({
      amountType: "fixed",
      priceAmount: price.unit_amount,
      priceCurrency: price.currency.toUpperCase(),
      recurringInterval: price.recurring?.interval,
    })),
  });
}

Connect same Stripe account

In Polar:

Go to Settings → Finance → Accounts
Click Connect Stripe
Use the same Stripe account you’re currently using

This allows Polar to access existing customer payment methods.

Using the same Stripe account is crucial for seamless subscription migration.

Import customers

Polar can automatically sync customers from your Stripe account:

// Customers with existing Stripe IDs are automatically linked
const checkout = await polar.checkouts.create({
  productPriceId: "prp_...",
  customerEmail: "[email protected]",
  // Polar will match by email or create new customer
});

For bulk imports, use the API:

for (const stripeCustomer of customers.data) {
  // Polar will link to existing Stripe customer
  await polar.customers.create({
    email: stripeCustomer.email,
    name: stripeCustomer.name,
    // Additional metadata
  });
}

Transition subscriptions

Option 1: Natural renewal (recommended)Wait for subscriptions to renew naturally:

Keep Stripe Billing running
New purchases go through Polar
Existing subscriptions renew through Polar at next billing date
Cancel Stripe Billing once all migrated

Option 2: Immediate migrationCancel and recreate subscriptions (may cause customer disruption):

for (const stripeSub of subscriptions.data) {
  // Cancel in Stripe (optionally at period end)
  await stripe.subscriptions.cancel(stripeSub.id);
  
  // Create in Polar with same billing date
  await polar.subscriptions.create({
    customerId: polarCustomer.id,
    productPriceId: polarPrice.id,
    // Prorate or start immediately
  });
  
  // Notify customer of the change
}

Immediate migration may confuse customers. We recommend natural renewal whenever possible.

Keep using Stripe webhooks

You can continue using Stripe webhooks during transition:

// Handle both Stripe and Polar webhooks
if (webhookSource === "stripe") {
  // Legacy Stripe subscription
  handleStripeEvent(event);
} else if (webhookSource === "polar") {
  // New Polar subscription
  handlePolarEvent(event);
}

Migrating from Paddle

Paddle and Polar both act as merchant of record, making the transition conceptually similar.

Data mapping

Paddle	Polar Equivalent
Product	Product
Price	Product Price
Customer	Customer
Subscription	Subscription
Transaction	Order
Discount	Discount

Migration steps

Export Paddle data

Use Paddle’s API to export:

import { Paddle } from "@paddle/paddle-node-sdk";

const paddle = new Paddle(process.env.PADDLE_API_KEY);

// Export products
const products = await paddle.products.list();

// Export subscriptions
const subscriptions = await paddle.subscriptions.list();

Set up Polar & Stripe

Since Polar uses Stripe for processing:

Create Polar account
Connect a new or existing Stripe account
Complete Stripe onboarding

You’ll need to migrate payment methods since Paddle stores them separately.

Recreate products

Map your Paddle products to Polar:

const polar = new Polar({
  accessToken: process.env.POLAR_ACCESS_TOKEN,
});

for (const paddleProduct of products) {
  await polar.products.create({
    name: paddleProduct.name,
    description: paddleProduct.description,
    prices: paddleProduct.prices.map(price => ({
      amountType: "fixed",
      priceAmount: price.unitPrice.amount,
      priceCurrency: price.unitPrice.currency,
      recurringInterval: price.billingCycle?.interval,
    })),
  });
}

Customer migration

Import customers and let them update payment methods:

for (const paddleCustomer of customers) {
  const customer = await polar.customers.create({
    email: paddleCustomer.email,
    name: paddleCustomer.name,
  });
  
  // Send email asking to update payment method
  await sendPaymentMethodUpdateEmail(customer.email, {
    updateUrl: `https://polar.sh/customer-portal?email=${customer.email}`,
  });
}

Customers can add new payment methods via the customer portal.

Subscription transition

Since payment methods must migrate, use a phased approach:

Announce the migration 30 days in advance
Keep Paddle active until all customers migrate
Send migration emails with customer portal links
Create Polar subscriptions when customers update payment methods
Cancel Paddle subscriptions after successful migration

Example email flow:

// Week 1: Announcement
await sendEmail({
  subject: "Important: Updating our billing system",
  body: "We're migrating to improved billing infrastructure...",
});

// Week 2-3: Individual reminders
for (const customer of unmigrated) {
  await sendMigrationReminder(customer);
}

// Week 4: Final push
await sendFinalReminder(unmigrated);

Key differences

Feature	Paddle	Polar
Payment processor	Built-in	Stripe
Tax handling	Automatic	Automatic (via Stripe)
Payouts	Weekly	Daily (Stripe)
Fee structure	5% + 50¢	4% + 40¢ + Stripe fees
Customer portal	Built-in	Built-in

Migrating from Lemon Squeezy

Both platforms focus on digital products and developer experience.

Data mapping

Lemon Squeezy	Polar Equivalent
Product	Product
Variant	Product Price
Customer	Customer
Subscription	Subscription
Order	Order
Discount Code	Discount

Migration steps

Export from Lemon Squeezy

Use the Lemon Squeezy API:

const LEMON_API = "https://api.lemonsqueezy.com/v1";

// Export products
const products = await fetch(`${LEMON_API}/products`, {
  headers: { Authorization: `Bearer ${LEMON_API_KEY}` },
}).then(r => r.json());

// Export subscriptions
const subscriptions = await fetch(`${LEMON_API}/subscriptions`, {
  headers: { Authorization: `Bearer ${LEMON_API_KEY}` },
}).then(r => r.json());

Set up Polar

Create Polar account
Connect Stripe (Polar uses Stripe for processing)
Complete merchant onboarding

Polar’s open source nature means you can self-host if needed.

Create products

Import your products:

const polar = new Polar({
  accessToken: process.env.POLAR_ACCESS_TOKEN,
});

for (const product of products.data) {
  await polar.products.create({
    name: product.attributes.name,
    description: product.attributes.description,
    prices: product.attributes.variants.map(variant => ({
      amountType: "fixed",
      priceAmount: variant.price,
      priceCurrency: "USD",
      recurringInterval: variant.interval,
    })),
  });
}

Customer & payment migration

Customers need to add new payment methods:

// Import customers
for (const lsCustomer of customers.data) {
  await polar.customers.create({
    email: lsCustomer.attributes.email,
    name: lsCustomer.attributes.name,
  });
}

// Send migration instructions
await sendMigrationEmail({
  instructions: "Update your payment method",
  portalUrl: "https://polar.sh/customer-portal",
});

Subscription migration

Use a customer-driven approach:

Keep Lemon Squeezy active during transition
Customers update payment methods in Polar
Create Polar subscription when payment method added
Cancel Lemon Squeezy subscription
Grant any existing benefits in Polar

// When customer updates payment method
async function migrateCustomerSubscription(customerId: string) {
  // Get Lemon Squeezy subscription
  const lsSub = await getLSSubscription(customerId);
  
  // Create Polar subscription
  const polarSub = await polar.subscriptions.create({
    customerId: customerId,
    productPriceId: mappedPriceId,
    // Start at next billing date to avoid double charging
  });
  
  // Cancel LS subscription
  await cancelLSSubscription(lsSub.id);
  
  return polarSub;
}

Migrating from other platforms

General migration guide for any payment platform:

Step 1: Understand your data

Export and document:

Active products and prices
Customer list with emails
Active subscriptions with billing dates
Order/transaction history
Any custom metadata

Step 2: Map to Polar’s model

Your Platform	Polar Equivalent	Notes
Product/Item	Product	What you sell
Price/SKU	Product Price	Pricing model
User/Customer	Customer	Who buys
Subscription	Subscription	Recurring billing
Purchase	Order	Completed transaction
Coupon/Promo	Discount	Price reductions

Step 3: Setup Polar

Account creation

Sign up at polar.sh
Create your organization
Connect Stripe account

Product setup

const polar = new Polar({
  accessToken: process.env.POLAR_ACCESS_TOKEN,
});

// Create each product
await polar.products.create({
  name: "Your Product",
  description: "Product description",
  prices: [{
    amountType: "fixed",
    priceAmount: 2900,
    priceCurrency: "USD",
    recurringInterval: "month",
  }],
});

Webhook configuration

Set up webhooks to receive events:

Go to Settings → Webhooks
Add endpoint URL
Select events to receive
Test with sandbox checkouts

View webhook guide →

Step 4: Customer migration

Choose your migration strategy:A) Gradual (Recommended)

Keep old system active
New purchases use Polar
Existing subscriptions renew on Polar
Natural transition over billing cycles

B) Bulk migration

Set migration date
Notify all customers in advance
Import all data on migration date
Require payment method updates
Higher risk but faster completion

Step 5: Code integration

Update your application:

// Old system
const checkout = await oldProvider.createCheckout(...);

// New Polar integration
const checkout = await polar.checkouts.create({
  productPriceId: "prp_...",
  successUrl: "https://yoursite.com/success",
  customerEmail: user.email,
});

// Redirect to checkout.url

Update webhook handlers:

// POST /webhooks/polar
export async function POST(req: Request) {
  const event = await req.json();
  
  switch (event.type) {
    case "checkout.completed":
      await handleCheckoutCompleted(event.data);
      break;
    case "subscription.updated":
      await handleSubscriptionUpdated(event.data);
      break;
  }
  
  return new Response("OK");
}

Migration checklist

Use this checklist to track your migration progress:

Common challenges

Payment method migration

Challenge: Customers need to re-enter payment detailsSolutions:

Use same Stripe account (if migrating from Stripe)
Send clear instructions with customer portal links
Offer incentives (discount) for early migration
Provide grace period for payment method updates
Support team ready for questions

// Example: Offer migration discount
await polar.discounts.create({
  code: "MIGRATE2024",
  type: "percentage",
  amount: 20, // 20% off
  duration: "once",
  redemptionLimit: 1, // One per customer
});

Subscription timing

Challenge: Avoiding double charges during migrationSolutions:

Start Polar subscriptions at next billing date
Prorate partial periods
Cancel old subscription after new one activates
Monitor for duplicate charges

// Align with existing billing date
await polar.subscriptions.create({
  customerId: customer.id,
  productPriceId: price.id,
  startedAt: oldSubscription.currentPeriodEnd,
});

Historical data

Challenge: Preserving transaction history and analyticsSolutions:

Export complete history before migration
Store in your database or data warehouse
Keep old platform in read-only mode
Document retention period for old system

Polar provides transaction data via API:

// Future transactions available via API
const orders = await polar.orders.list({
  customerId: customer.id,
});

Benefit continuity

Challenge: Ensuring uninterrupted access to purchased benefitsSolutions:

Grant benefits to migrated customers immediately
Map old entitlements to new benefits
Verify benefit access before canceling old subscriptions
Provide fallback access during transition

// Manually grant benefits during migration
await polar.benefits.grants.create({
  customerId: customer.id,
  benefitId: benefit.id,
});

Customer communication

Challenge: Keeping customers informed and reducing confusionSolutions:

Announce migration 30 days in advance
Send weekly reminders
Create FAQ page
Offer live support during migration
Send confirmation after successful migration

Email sequence example:

Day 0: Initial announcement
Day 7: First reminder with action steps
Day 14: Second reminder with deadline
Day 21: Final reminder with support offer
Day 30: Migration complete confirmation

Post-migration tasks

After completing the migration:

Verify everything works

Test complete purchase flows
Verify webhook delivery
Check benefit grants
Confirm subscription renewals
Review customer portal access

Monitor closely

Watch for failed payments
Track customer support inquiries
Monitor webhook errors
Check benefit grant status
Review transaction success rates

Update documentation

Update developer docs
Revise customer help articles
Update marketing materials
Refresh API documentation links
Archive old platform references

Gather feedback

Survey customer experience
Review support tickets
Analyze checkout completion rates
Document lessons learned
Identify optimization opportunities

Need migration help?

We’re here to help make your migration smooth:

Join Discord

Get real-time help from our community

GitHub Discussions

Ask questions and share experiences

Email Support

Contact our team for personalized assistance

Book a Call

Schedule time with our migration specialists

Large-scale migrations: For organizations with 10,000+ active subscriptions, we offer dedicated migration support. Contact us to discuss your specific needs.

Success stories

Case Study: SaaS company migrates from Stripe Billing

Company: Mid-sized SaaS with 5,000 subscribersChallenge: Complex product catalog, multiple subscription tiers, and usage-based billingApproach:

Used same Stripe account for seamless transition
Migrated at natural renewal dates over 2 months
Implemented webhooks for both platforms during transition
Leveraged Polar’s usage-based billing features

Results:

Zero customer complaints
Reduced billing code by 60%
Saved $2,000/month in platform fees
Improved checkout conversion by 12%

Timeline: 6 weeks from start to 100% migration

Additional resources

API Reference

Complete API documentation

Webhook Events

All available webhook events

SDK Documentation

TypeScript, Python, PHP, and Go SDKs

Getting Started

Core Features

Usage-Based Billing

Payments & Billing

Customer Management

Finance

Merchant of Record

​Why migrate to Polar?

Developer-First

Open Source

All-in-One

Lower Fees

​Migration overview

​Platform-specific guides

​Migrating from Stripe Billing

​Data mapping

​Migration steps

​Keep using Stripe webhooks

​Migrating from Paddle

​Data mapping

​Migration steps

​Key differences

​Migrating from Lemon Squeezy

​Data mapping

​Migration steps

​Migrating from other platforms

​Step 1: Understand your data

​Step 2: Map to Polar’s model

​Step 3: Setup Polar

​Step 4: Customer migration

​Step 5: Code integration

​Migration checklist

​Common challenges

​Post-migration tasks

Verify everything works

Monitor closely

Update documentation

Gather feedback

​Need migration help?

Join Discord

GitHub Discussions

Email Support

Book a Call

​Success stories

​Additional resources

API Reference

Webhook Events

SDK Documentation

Build docs developers (and LLMs) love

Why migrate to Polar?

Migration overview

Platform-specific guides

Migrating from Stripe Billing

Data mapping

Migration steps

Keep using Stripe webhooks

Migrating from Paddle

Data mapping

Migration steps

Key differences

Migrating from Lemon Squeezy

Data mapping

Migration steps

Migrating from other platforms

Step 1: Understand your data

Step 2: Map to Polar’s model

Step 3: Setup Polar

Step 4: Customer migration

Step 5: Code integration

Migration checklist

Common challenges

Post-migration tasks

Need migration help?

Success stories

Additional resources