How to migrate subscriptions to a Shopify app

To migrate subscriptions to a Shopify app, export your contracts and payment methods, import them, reconcile every subscriber, then test before launch. This guide covers the migration steps first, then the checks that stop a switch going wrong.

Arc is being built and is in early access. These are planning guides, not a claim that Arc supports every workflow, source app or payment provider. Explore the reviewed capability pages, then request access to discuss your store.

How do you migrate existing subscriptions to a new Shopify app?

Migration is four jobs in order: export, import, payment method handling and reconciliation. Ask both your current provider and the new app what they can export and import. Most providers can give you a subscriber list with contract details: customer, line items, selling plan or frequency, next billing date, status and a payment method reference. Get that as a spreadsheet or CSV you can inspect before anything moves.

Do not cancel the old setup until the new one is verified. Run the migration in a staging store or a small pilot group first, so a mistake affects a handful of subscribers rather than all of them. Shopify's subscriptions documentation is the baseline for how subscriptions are structured in Shopify; use it to check that the fields you export map to what the new app expects.

  • Ask the current provider for a full export of active contracts and payment method references.
  • Ask the new app which fields it can import and in what format.
  • Map each field from the export to the import format and note any gaps.
  • Run the import into a staging store or pilot group first, never straight into the live store.

How do you handle payment methods during a subscription migration?

Payment methods are the hardest part. Card details usually cannot be exported in a usable form, so the new app either imports a token from the old provider or asks the customer to re-enter their card. Ask both vendors which route applies before you promise customers a smooth switch. If customers must re-enter details, plan the email sequence and a grace period so nobody is charged late or cancelled by mistake.

Shopify's subscription contracts documentation describes how a contract holds its payment method and billing attempts. Use it to check what the new app records for each migrated contract. Where a card cannot be moved, flag those subscribers separately and contact them first.

  • Confirm whether the new app can import payment tokens from the old provider.
  • Split the list into subscribers with a transferable payment method and those who must re-enter details.
  • Email the re-entry group with a clear deadline and what happens if they do not act.
  • Record the payment method status for every migrated contract before go-live.

How do you reconcile subscribers after the import?

Reconciliation means proving the new app holds the same subscribers, contracts and next billing dates as the source. Export the contracts from the new app after import and compare row by row against your original export. Count active contracts on both sides, then check a sample in detail: customer, line items, frequency, next billing date, status and payment method. Investigate every mismatch before launch.

Keep a reconciliation sheet with the source count, the imported count, the difference and an explanation for each gap. A common mistake is importing cancelled or paused contracts as active, which can trigger charges that should not happen. Another is losing the next billing date, which shifts a customer's delivery without warning.

  • Export contracts from the new app immediately after import.
  • Compare totals: active, paused and cancelled counts on both sides.
  • Check a detailed sample of at least twenty contracts field by field.
  • Log every mismatch with an owner and a fix date, then re-run the comparison after fixes.

What should you test before you switch on Shopify subscriptions?

Treat the launch as a set of surfaces that each need a check. Write each one down with the expected result, the actual result, the evidence you captured and the person responsible. That record makes the test repeatable and gives you something to review before go-live. Shopify's selling plans documentation describes how subscriptions are set up and what selling plans control; use it as your baseline for what should happen, then verify it in your own store.

If you are still choosing an app, the Shopify subscription app checklist covers selection criteria. This guide assumes the app is chosen and you are testing the setup.

  • Product page: the selling plan appears only where intended, with the right frequency options and discount text.
  • Cart and checkout: a subscription item can be added and paid for with a test payment method.
  • Order creation: the order records the selling plan and the correct amount.
  • Subscription contract: customer, line items, frequency, next billing date and status match what you expect.
  • Customer account: the subscription is visible and self-service actions work on mobile and desktop.
  • Emails: each notification arrives with the right sender, subject, links and unsubscribe behaviour.
  • Cancellation and skip: the contract status and next billing date update in both admin and app.
  • Payment retries: the retry schedule and failure emails are configured as intended.
  • Taxes, shipping, discounts and inventory: each behaves as expected for subscription orders.

How do you choose a safe way to test a Shopify subscription order?

You have three broad options: a test order through your store's checkout, Shopify Payments test mode where available, or a vendor-provided sandbox or staging route. Each proves different things. A test order can confirm checkout, taxes, shipping and order creation, but it may not create a real subscription contract or simulate recurring billing. Shopify's test order guidance explains how to place a test order without charging a real card. Shopify Payments test mode, where available, lets you use test card details to check payment behaviour.

The decision rule: use a test order for checkout and order creation, test mode for payment behaviour, and a vendor sandbox only if it actually simulates contracts and retries. Record what each method can and cannot prove. Do not use live customer payment details for testing. If your vendor offers a sandbox, ask exactly which parts of the subscription lifecycle it simulates and which you must check manually after launch.

  • Read Shopify's test order guidance and Shopify Payments test mode documentation for your store.
  • Match each surface in your checklist to the method that can actually prove it.
  • Place a test order using a test payment method, never a real customer card.
  • Record the order number, the payment result and whether a subscription contract was created.

How do you check a subscription contract after a test order?

After a successful test order, find the subscription contract in your Shopify admin and in your subscription app. Check that the customer, line items, selling plan, next billing date and payment method match what you expect, and that the contract status is active. Shopify's subscription contracts documentation lists the fields and statuses a contract can have; use it to build your inspection checklist. Then test a change: skip a delivery or pause the contract and confirm the status and next billing date update in both places.

Finally, sign in as a test customer and confirm the subscription is visible on mobile and desktop. Test the self-service actions your setup exposes: updating a payment method, skipping, pausing or cancelling. Shopify's customer accounts documentation explains how account access works. Record any action that is not available so support can set expectations before launch.

  • Compare the contract in admin and in the app field by field.
  • Perform a skip or pause and confirm the status and next billing date change in both places.
  • Sign in as a test customer and try each self-service action on mobile and desktop.
  • Note any action that is missing and brief support on what to tell customers.

How do you test recurring payments and payment retries?

Use a test gateway or Shopify Payments test mode to check the first payment and any simulated billing attempt. Confirm what can be simulated for retries, failed payments and dunning emails, and document what must be checked manually after launch. Shopify's subscription contracts documentation describes how billing attempts relate to contracts; your payment gateway's test mode documentation will say which failure scenarios you can simulate.

Check the retry schedule and customer communication against your recovery plan. If you cannot simulate a failed payment, plan a manual check after the first live billing cycle. The guide to reducing involuntary churn covers recovery practice in more detail; here you only need to confirm that the retry settings and emails are configured as intended.

Set go/no-go criteria before you start testing. For example: every migrated contract is reconciled, all critical flows pass, known limitations are written down, support scripts are ready, and an owner is named for the first billing cycle. Decide how you will monitor that cycle and what you will pause or roll back if something fails. Keep the test checklist, reconciliation sheet and evidence with the launch plan. If you are migrating existing subscriptions, the migration checklist covers sequencing and reconciliation in more detail. Arc is a Shopify subscription app in early access; you can read more and request access on the early access page.

  • Confirm whether your payment gateway offers a test mode for recurring payments.
  • Simulate a successful first payment and, if possible, a failed payment.
  • Check the retry schedule and the emails sent to the customer.
  • Document any scenario you cannot simulate and add it to your post-launch checks.

Arc is in early access while the product is being built. Read the reviewed capability pages, Explore Arc plans, or request early access to discuss your requirements.

Sources

These sources explain Shopify workflows. Verify how each candidate app implements them; they are not endorsements or proof of Arc feature availability.

Talk to the team building Arc.

Arc is in early access. Tell us about your store and the workflows you need, and we will be in touch about access.