ChatGPT answers, unedited

For a custom storefront with recurring subscription plans and API-first architecture, I’d narrow the field to a few strong options depending on whether you’re building SaaS, digital subscriptions, or physical recurring commerce.

My shortlist

SimpleSubscription Crystallize## My recommendation by scenario

1. You are building a SaaS-like subscription product

Pick: Stripe Billing + custom frontend

Architecture:

Next.js / React storefront
        |
Your API layer
        |
Stripe Billing
        |
Webhooks → database → entitlements/access control

Good for:

• monthly/annual plans
• usage-based pricing
• seat-based billing
• trials
• coupons
• customer portals
• metered billing

Stripe’s APIs are designed around subscriptions, invoices, payment methods, and lifecycle events, making it a common foundation for custom subscription products. SimpleSubscription

2. You are building a subscription ecommerce brand

Examples:

• coffee subscriptions
• supplements
• recurring boxes
• replenishment products

Pick: Swell, Recharge Headless, or Crystallize

You need more than billing:

• product catalog
• variants
• inventory
• bundles
• shipping cadence
• customer self-service
• subscription changes

A pure billing system often becomes painful here because you end up rebuilding commerce primitives. Crystallize

3. You need enterprise subscription operations

Pick: Chargebee

Better when you need:

• complex plans
• invoicing workflows
• finance integrations
• revenue recognition
• B2B contracts
• sales-assisted subscriptions

A stack I would build today

For a modern custom storefront:

SaaS / digital subscription stack

• Frontend: Next.js
• Commerce UI: custom React components
• Payments: Stripe Checkout or Elements
• Subscription engine: Stripe Billing
• Database: PostgreSQL
• Auth: Auth.js / Clerk / custom OAuth
• Events: Stripe webhooks → queue → backend services
• CMS: Sanity or Contentful

Physical subscription stack

• Frontend: Next.js
• Commerce backend: Swell or Crystallize
• Subscription engine: native subscriptions or Recharge Headless
• Payments: Stripe
• Fulfillment: custom integrations
• CMS/PIM: integrated headless commerce CMS

What I would avoid

• Building recurring billing from scratch unless subscriptions are your core product.
• Using a traditional monolithic ecommerce platform if your storefront UX is a major differentiator.
• Using only a payment API for physical subscriptions; you’ll eventually need catalog, fulfillment, and customer lifecycle tooling.

If you tell me what kind of subscription you’re selling (SaaS, memberships, digital content, or physical products) and your expected scale (e.g., 1k vs 100k subscribers), I can narrow this to a specific architecture.

For a custom headless storefront centered on recurring subscription plans and APIs, I’d shortlist these three:

My recommendation: Shopify + Hydrogen

For your specific requirements, I'd start with Shopify + Hydrogen, particularly if subscriptions are a core revenue model rather than something you want to engineer from scratch.

Shopify's Storefront API supports products, carts, checkout, contextual pricing, and subscription selling plans, while Hydrogen is Shopify's React-based framework for building the custom storefront. Shopify Shopify

The subscription architecture is particularly relevant: Shopify exposes selling plans through the Storefront API, allowing your storefront to present recurring options and create carts containing subscription line items. Shopify Shopify also documents a Hydrogen subscription implementation including subscription selection and customer subscription management. Shopify

A typical architecture would be:

                    Custom storefront
                 Next.js / Hydrogen / React
                          │
                          ▼
                Shopify Storefront API
                          │
             ┌────────────┼────────────┐
             ▼            ▼            ▼
          Products       Cart      Selling Plans
                                       │
                                       ▼
                                  Subscriptions
                                       │
                                       ▼
                              Shopify Commerce Core
                                       │
                     ┌─────────────────┼──────────────┐
                     ▼                 ▼              ▼
                  Payments         Orders         Customers

You can also use Shopify's APIs without Hydrogen if you prefer Next.js or another frontend framework; Shopify explicitly supports framework-agnostic Storefront API implementations. Shopify

When I'd choose Medusa instead

Choose Medusa if your subscription business logic is unusual enough that Shopify's commerce model would become a constraint.

Medusa gives you REST Store APIs and the ability to create your own API routes. Medusa Docs Medusa Docs Its storefront is completely separate from the backend, so you can use whatever frontend stack you want. Medusa Docs

The tradeoff is important: subscriptions aren't native in Medusa. Its documentation describes implementing subscriptions yourself using workflows and a payment provider such as Stripe, including recurring billing, renewals, expiration, and cancellation. Medusa Docs

So I'd use Medusa if your requirements look more like:

• Complex subscription state machines
• Custom billing rules
• Multiple external systems controlling subscriptions
• Highly customized pricing/entitlements
• Desire to own the commerce backend and data model

Saleor is the other strong option

Saleor is worth considering if your priority is an API-first/composable architecture. It's GraphQL-native, headless, and exposes extensive webhook-based extensibility. Saleor Commerce Saleor Commerce

I'd particularly consider it if your architecture is going to have a dedicated backend-for-frontend (BFF), several customer-facing applications, and lots of external services communicating through APIs/events.

Bottom line

For a new project, my decision tree would be:

• Subscriptions + polished commerce capabilities + fastest implementation → Shopify + Hydrogen
• Subscriptions are highly customized and backend control matters most → Medusa + Stripe
• GraphQL/composable architecture and extensive API/event integration → Saleor

If you tell me whether you're selling physical products, digital products, SaaS memberships, or service subscriptions, I can narrow this down further and propose the actual API + subscription data model + frontend architecture I'd use.

A typical architecture would be:

                    Custom storefront
                 Next.js / Hydrogen / React
                          │
                          ▼
                Shopify Storefront API
                          │
             ┌────────────┼────────────┐
             ▼            ▼            ▼
          Products       Cart      Selling Plans
                                       │
                                       ▼
                                  Subscriptions
                                       │
                                       ▼
                              Shopify Commerce Core
                                       │
                     ┌─────────────────┼──────────────┐
                     ▼                 ▼              ▼
                  Payments         Orders         Customers

You can also use Shopify's APIs without Hydrogen if you prefer Next.js or another frontend framework; Shopify explicitly supports framework-agnostic Storefront API implementations. Shopify

When I'd choose Medusa instead

Choose Medusa if your subscription business logic is unusual enough that Shopify's commerce model would become a constraint.

Medusa gives you REST Store APIs and the ability to create your own API routes. docs.medusajs.com docs.medusajs.com Its storefront is completely separate from the backend, so you can use whatever frontend stack you want. docs.medusajs.com

The tradeoff is important: subscriptions aren't native in Medusa. Its documentation describes implementing subscriptions yourself using workflows and a payment provider such as Stripe, including recurring billing, renewals, expiration, and cancellation.

So I'd use Medusa if your requirements look more like:

For a custom storefront centered on recurring subscription plans and APIs, I’d put Shopify + Hydrogen/Storefront API at the top of the shortlist, with Saleor and Medusa as alternatives if you want more backend control.

My recommendation: Shopify headless

Shopify is particularly compelling if recurring subscriptions are a core business feature rather than something you want to build from scratch.

Its Storefront API is GraphQL-based and explicitly supports products, carts, checkout, and selling plans for subscriptions. You can use it with Hydrogen, Next.js, or essentially any frontend framework. Shopify Shopify

For subscriptions, Shopify has a useful underlying model:

• SellingPlanGroup — groups subscription options such as weekly/monthly plans.
• SellingPlan — defines billing, delivery, pricing, and recurring behavior.
• SellingPlanAllocation — connects a variant to a particular subscription plan and exposes the resulting pricing. Shopify Shopify Shopify
• The Storefront API can retrieve subscription products and create carts containing subscription line items. Shopify
• Hydrogen has an official subscription implementation pattern, including displaying plans, adding subscription products to carts, and building subscription-management UI. Shopify

A typical architecture would be:

                 ┌──────────────────────┐
                 │  Custom Storefront   │
                 │ Next.js / Hydrogen   │
                 └──────────┬───────────┘
                            │
                       GraphQL API
                            │
                 ┌──────────▼───────────┐
                 │       Shopify        │
                 │ Products / Cart      │
                 │ Customers / Orders    │
                 │ Selling Plans         │
                 └──────────┬───────────┘
                            │
                 ┌──────────▼───────────┐
                 │ Subscription App     │
                 │ Billing / Lifecycle  │
                 └──────────────────────┘

The important distinction is that Shopify's selling-plan infrastructure handles the commerce representation of subscriptions, while a subscription app/integration generally handles the subscription lifecycle. Shopify's own Hydrogen documentation explicitly requires installing a subscriptions app for this implementation. Shopify

When I'd choose Saleor instead

Saleor makes more sense if API ownership and architectural control are more important than minimizing operational work. Saleor is GraphQL-native and designed around headless/composable commerce, with storefront and admin APIs intended to be decoupled from the frontend. Saleor Commerce Saleor Commerce

I'd investigate Saleor particularly if you need:

• Your own subscription/billing domain model
• Heavy customization of checkout/order logic
• Multiple commerce channels
• An open-source foundation
• A GraphQL-first architecture
• Your own services sitting between the storefront and commerce engine

The tradeoff is that you should expect to design more of the subscription system yourself.

When I'd choose Medusa

Medusa is worth considering if your engineering team is strongly TypeScript/Node.js-oriented and wants to own the commerce backend. Its modular architecture is well suited to building custom commerce workflows, but recurring billing becomes more of an engineering concern than with Shopify's established subscription ecosystem. OSSAlt

What I'd build

For a typical subscription business, I'd use:

Frontend: Next.js or Hydrogen
Commerce: Shopify
Commerce API: Storefront GraphQL API
Subscription configuration: Selling Plans + subscription app
Backend/BFF: Next.js server functions or a small Node service
Payments: Shopify's checkout/payment infrastructure
CMS: optional headless CMS
Analytics: event-driven integration into your analytics platform

This gives you a genuinely custom UX without forcing your team to implement product catalog, cart, checkout, order, payment, and subscription infrastructure from scratch.

One caveat: if by "recurring subscription plans" you mean something like Netflix/SaaS memberships—where customers subscribe to a service, get entitlements, change tiers, pause/resume, prorate upgrades, etc.—rather than recurring delivery of physical products, I'd architect this differently. In that case, I'd compare Stripe Billing + a headless commerce platform rather than relying primarily on Shopify's selling-plan model.

My recommendation: Shopify + Hydrogen/Storefront API

For a custom storefront where recurring subscriptions and APIs are the priorities, I’d choose Shopify headless, using the Storefront API and either Hydrogen or your own frontend framework.

Why it fits particularly well:

• Subscription-native: Shopify's Storefront API exposes selling plans, including recurring delivery options, billing policies, pricing adjustments, and subscription line items. Shopify Shopify
• Truly headless: You can use React/Next.js, Hydrogen, Vue, or essentially any frontend stack while Shopify handles products, inventory, carts, checkout, orders, etc. Shopify Shopify
• Strong APIs: The Storefront API is GraphQL and Shopify also provides a Customer Account API and broader Admin APIs, giving you a good foundation for custom subscription/customer experiences. Shopify
• Good operational backend: You get Shopify's mature admin, fulfillment, payments ecosystem, inventory, promotions, analytics, and app ecosystem without having to build those systems yourself.
• Subscription management is extensible: Shopify's Hydrogen subscription implementation supports displaying plans and building customer subscription-management experiences, while subscription functionality is supplied through a subscriptions app. Shopify

A typical architecture would be:

                    CUSTOM STOREFRONT
                 Next.js / Hydrogen / React
                           │
                           ▼
                 Shopify Storefront API
                           │
             ┌─────────────┼─────────────┐
             ▼             ▼             ▼
          Products        Cart        Customers
             │             │             │
             └─────────────┼─────────────┘
                           ▼
                    Shopify Checkout
                           │
                           ▼
                   Orders / Payments
                           │
                           ▼
                  Subscription System
                           │
                           ▼
                 Webhooks / Your APIs
                           │
             ┌─────────────┼─────────────┐
             ▼             ▼             ▼
            CRM          Analytics       ERP

The important caveat

If subscriptions are the core business model, rather than simply "products that happen to have subscribe-and-save," I'd also evaluate Commerce Layer.

Commerce Layer is much more API-first/composable. Its API specifically includes subscriptions, multi-currency, distributed inventory, localized payments, promotions and orders. Commerce Layer Documentation

So I'd rank them:

Medusa is particularly interesting if you want to own more of the commerce backend: its storefront is completely separate from the commerce server and communicates through Store API/custom API routes. Medusa Docs

What I'd pick

Choose Shopify Headless if: you want to launch relatively quickly, need robust commerce operations, and subscriptions are an important feature.

Choose Commerce Layer if: the product is fundamentally an API-driven subscription platform and you expect multiple customer experiences—web, mobile, partner portals, marketplaces, etc.—to consume the same commerce backend.

Choose Medusa if: you have a strong engineering team and want significantly more control over the underlying commerce model and infrastructure.

If you tell me what you're selling (physical goods, SaaS, memberships, digital products, etc.) and whether billing is monthly/annual or usage-based, I can narrow this down to the best 1–2 architectures and explain exactly how I'd implement the subscription API.

For your use case, I’d recommend commercetools if the priority is a robust, API-first headless platform where recurring subscriptions are a first-class commerce capability.

My shortlist

1. commercetools — best overall

This is the one I'd pick for a subscription-heavy business.

commercetools now has native Recurring Orders, rather than requiring you to build the recurring-order engine yourself. Its API supports recurrence policies such as daily, weekly, monthly, and custom intervals, as well as start/end dates. Recurring orders can be paused, skipped, modified, or canceled. commercetools Documentation commercetools Documentation commercetools Documentation

It also lets you mix recurring and one-time products in the same checkout, which is particularly useful if your storefront will offer things like:

• Monthly subscription
• Annual subscription
• One-time purchase
• Subscription + add-ons
• Different pricing by billing interval

Its API model is also well suited to a completely custom frontend. commercetools Documentation

Architecture I'd use:

Next.js / React storefront → your BFF/API layer → commercetools APIs → payment provider

This gives you control over the customer experience without making the storefront responsible for commerce logic.

2. Medusa — best if you want maximum control

Medusa is arguably more attractive if you're a developer-heavy team and want the commerce backend to behave like an extensible application rather than a managed enterprise platform.

Its Store API is REST-based and specifically designed for external storefronts and apps. You can also create your own API routes. Medusa Docs Medusa Docs

The important caveat: subscriptions aren't native in the same sense as commercetools' Recurring Orders. Medusa provides a subscription recipe/framework that you implement yourself, with Stripe used as the example payment provider. The recipe covers recurring billing, expiration, customer subscription management, and cancellation. Medusa Docs

So I'd choose Medusa if you want:

• Full TypeScript/Node control
• Self-hosting
• Custom business logic
• Custom subscription domain model
• Your own API layer
• Minimal vendor lock-in

3. Saleor — best GraphQL option

Saleor is worth considering if your team strongly prefers GraphQL. It provides a headless architecture with GraphQL APIs, custom apps, payment integrations, channels, promotions, and extensive extensibility. Saleor Documentation

I'd put it behind the first two specifically for your use case because recurring subscription management isn't as turnkey as commercetools' current Recurring Orders implementation.

My recommendation

Choose commercetools if your subscription system is strategically important and you want the commerce platform itself to own recurring-order scheduling and lifecycle management.

Choose Medusa if you're comfortable building more of the subscription machinery yourself and value developer control/self-hosting over having those capabilities built in.

A particularly strong stack would be:

Next.js → API/BFF → commercetools → Stripe/payment provider

with your own application layer handling things such as:

• Plan selection
• Customer portal
• Upgrade/downgrade
• Proration rules
• Trial periods
• Coupons
• Account entitlements
• Subscription analytics
• Webhooks/events
• CRM/ERP synchronization

One important distinction: commerce subscriptions and payment subscriptions aren't necessarily the same thing. I'd keep the commerce/order lifecycle in commercetools while using the payment provider for payment-method storage, charging, and payment-specific lifecycle events.

docs.commercetools.com
docs.medusajs.com
docs.saleor.io

If you tell me your product type (physical, SaaS/digital, or both), billing model, expected scale, and whether you want to self-host, I can narrow this down to a specific architecture and recommend the payment/subscription stack too.

Next.js → API/BFF → commercetools → Stripe/payment provider

with your own application layer handling things such as:

• Plan selection
• Customer portal
• Upgrade/downgrade
• Proration rules
• Trial periods
• Coupons
• Account entitlements
• Subscription analytics
• Webhooks/events
• CRM/ERP synchronization

One important distinction: commerce subscriptions and payment subscriptions aren't necessarily the same thing. I'd keep the commerce/order lifecycle in commercetools while using the payment provider for payment-method storage, charging, and payment-specific lifecycle events.

Recommendation: commercetools

For a custom storefront where recurring subscriptions and APIs are first-class requirements, I’d shortlist commercetools first.

The key reason is that commercetools now has native Recurring Orders, rather than requiring you to build the recurring-order scheduler entirely in middleware. Its API lets you define recurrence policies and automatically create future orders on a schedule. commercetools Documentation commercetools Documentation

It also has a Checkout Transactions API specifically capable of triggering payments for subscription-based orders, which makes it a stronger fit than a platform where subscriptions are primarily handled by a third-party app. commercetools Documentation

How I'd compare the main options

Why not automatically choose Shopify?

Shopify is probably the easiest overall choice. Its Storefront API is explicitly designed for headless storefronts, and its subscription model exposes selling plans through the API. Shopify Shopify

The catch is that Shopify's subscription functionality is based around selling plans and its broader commerce ecosystem. If your product is fundamentally a subscription platform with unusual billing, entitlement, provisioning, renewal, or lifecycle logic, I'd favor commercetools' more composable architecture.

When I'd choose the others

Saleor is particularly compelling if your team wants GraphQL everywhere and maximum control over the architecture. Saleor describes itself as GraphQL-native and API-first, with 140+ webhooks and technology-agnostic extensions. Saleor Commerce Saleor Commerce

Medusa is attractive if you want an open-source Node.js/TypeScript-oriented commerce backend. Its storefront is completely separate from the backend, and its Store API is REST-based, making it straightforward to build a Next.js or other custom frontend. Medusa Docs Medusa Docs

My architecture recommendation

For a subscription-heavy product, I'd structure it roughly as:

Custom Storefront
   │
   ├── Product/catalog API
   ├── Customer/account API
   ├── Cart/checkout API
   └── Subscription UI
          │
          ▼
     commercetools
          │
          ├── Recurring Orders
          ├── Checkout / payments
          ├── Catalog & pricing
          ├── Orders
          └── Customer data
                │
                ▼
        Your subscription domain
          ├── Entitlements
          ├── Provisioning
          ├── Plan changes
          ├── Pause/cancel
          └── Webhooks/events

I would not make the commerce platform responsible for your entire subscription domain. Let commercetools handle commerce primitives—products, prices, carts, orders and recurring payments—while your own service owns business-specific concepts such as entitlements, plan state, usage, provisioning and subscription lifecycle rules.

Bottom line:

• Choose commercetools if subscriptions + API composability are the core architectural requirements.
• Choose Shopify if getting to market quickly and leveraging its ecosystem matter more.
• Choose Saleor if you want maximum GraphQL/open-source control.
• Choose Medusa if you want a highly customizable Node.js commerce foundation.

docs.commercetools.com · shopify.dev · saleor.io · medusajs.com

How I'd compare the main options

Why not automatically choose Shopify?

Shopify is probably the easiest overall choice. Its Storefront API is explicitly designed for headless storefronts, and its subscription model exposes selling plans through the API. Shopify Shopify

The catch is that Shopify's subscription functionality is based around selling plans and its broader commerce ecosystem. If your product is fundamentally a subscription platform with unusual billing, entitlement, provisioning, renewal, or lifecycle logic, I'd favor commercetools' more composable architecture.

When I'd choose the others

Saleor is particularly compelling if your team wants GraphQL everywhere and maximum control over the architecture. Saleor describes itself as GraphQL-native and API-first, with 140+ webhooks and technology-agnostic extensions. Saleor Commerce Saleor Commerce

Medusa is attractive if you want an open-source Node.js/TypeScript-oriented commerce backend. Its storefront is completely separate from the backend, and its Store API is REST-based, making it straightforward to build a Next.js or other custom frontend. Medusa Docs Medusa Docs

My architecture recommendation

For a subscription-heavy product, I'd structure it roughly as:

Custom Storefront
   │
   ├── Product/catalog API
   ├── Customer/account API
   ├── Cart/checkout API
   └── Subscription UI
          │
          ▼
     commercetools
          │
          ├── Recurring Orders
          ├── Checkout / payments
          ├── Catalog & pricing
          ├── Orders
          └── Customer data
                │
                ▼
        Your subscription domain
          ├── Entitlements
          ├── Provisioning
          ├── Plan changes
          ├── Pause/cancel
          └── Webhooks/events

I would not make the commerce platform responsible for your entire subscription domain. Let commercetools handle commerce primitives—products, prices, carts, orders and recurring payments—while your own service owns business-specific concepts such as entitlements, plan state, usage, provisioning and subscription lifecycle rules.

Bottom line:

For a custom storefront centered on recurring subscription plans and APIs, I’d shortlist Swell, Medusa, and commercetools—with Swell as my first choice if subscriptions are a core product feature rather than an add-on.

My recommendation: Swell

Swell is particularly interesting for your requirements because it combines headless APIs with native subscriptions, rather than making recurring billing something you have to bolt onto the commerce engine. It supports both REST and GraphQL, which is useful if your storefront and other services have different API preferences. Swell

A sensible architecture would be:

                Custom Storefront
                 Next.js / React
                       │
             REST / GraphQL APIs
                       │
                    Swell
          ┌────────────┼────────────┐
          │            │            │
       Catalog     Subscriptions   Customers
          │            │            │
          └────────────┼────────────┘
                       │
                 Payment provider
                       │
              Webhooks / Your API
                       │
          CRM / analytics / fulfillment

That gives you freedom to make the storefront experience completely custom while keeping products, customers, orders, and recurring plans in the commerce backend.

When I'd choose Medusa instead

Choose Medusa if owning the commerce backend is more important than having subscriptions built in.

Medusa is TypeScript/Node.js, modular, open source, and designed specifically for custom commerce applications. Its REST API and JavaScript SDK make it a natural fit for a Next.js/React stack. OSSAlt Vendure

The catch for your use case is significant: subscriptions aren't a core native capability, so you'd be adding subscription/billing infrastructure or a plugin. Swell

I'd pick Medusa if you anticipate unusual business logic such as:

• complex subscription lifecycle rules
• custom bundles
• marketplace functionality
• unusual checkout logic
• extensive backend customization
• wanting to self-host the entire commerce layer

When I'd choose commercetools

commercetools makes more sense if this is an enterprise composable-commerce project with multiple systems, regions, catalogs, pricing models, or business units.

It's extremely API-first and flexible, but you're buying that flexibility at the cost of considerably more architecture and implementation work. Subscription functionality is generally something you'd compose rather than simply switch on. Vendure Naturaily

What I would not choose first

Saleor is excellent if your team strongly prefers GraphQL and Python, but subscriptions are not its native strength. Its GraphQL-first architecture is excellent for custom storefronts, though. Saleor Commerce Swell

Shopify is compelling if minimizing engineering/operations is the priority, but for a product whose differentiator is custom recurring plans + API-driven commerce, I would evaluate Swell or Medusa first rather than designing around Shopify's subscription-app ecosystem.

Bottom line

I'd rank them for your particular requirement:

1. Swell — best if subscriptions are central and you want APIs without building the subscription engine yourself.
2. Medusa — best if engineering control/custom business logic outweighs native subscription functionality.
3. commercetools — best for large-scale enterprise composable architecture.
4. Saleor — best if GraphQL + open source + sophisticated commerce modeling is the priority.
5. Shopify — best if speed, ecosystem, and operational simplicity win.

If you tell me your expected number of subscribers, B2C vs. B2B, payment processor (e.g. Stripe), and whether you want to self-host, I can narrow this down to a specific architecture and API stack.

Saleor is excellent if your team strongly prefers GraphQL and Python, but subscriptions are not its native strength. Its GraphQL-first architecture is excellent for custom storefronts, though.

Shopify is compelling if minimizing engineering/operations is the priority, but for a product whose differentiator is custom recurring plans + API-driven commerce, I would evaluate Swell or Medusa first rather than designing around Shopify's subscription-app ecosystem.

Bottom line

I'd rank them for your particular requirement:

Choose Medusa if owning the commerce backend is more important than having subscriptions built in.

Medusa is TypeScript/Node.js, modular, open source, and designed specifically for custom commerce applications. Its REST API and JavaScript SDK make it a natural fit for a Next.js/React stack.

For your requirements, I’d recommend Medusa + Stripe Billing.

Best fit: Medusa + Stripe Billing

Medusa is particularly well suited if your priority is a fully custom storefront with APIs and subscription-specific business logic.

• Headless by design: Your storefront is a separate application, so you can use Next.js, React, mobile apps, or essentially any frontend stack. Medusa Docs Medusa Docs
• API-first: Medusa exposes REST Store APIs and lets you create your own API routes for custom commerce operations. Medusa Docs Medusa Docs
• Highly customizable: Its modular architecture lets you create custom data models, modules, workflows, and integrations rather than fighting a rigid SaaS commerce model. Medusa Docs
• Subscriptions are achievable: Medusa has an official subscription implementation recipe covering recurring orders, automatic renewal/expiration, customer cancellation, and Stripe payment handling. Importantly, subscriptions aren't currently a turnkey native commerce primitive—you implement the subscription logic using its framework. Medusa Docs
• Stripe Billing handles the hard billing pieces: recurring payments, trials, proration, failed-payment recovery, subscription management, and multiple pricing models. Stripe Stripe

A sensible architecture would be:

Custom Next.js / React storefront
             │
             ▼
        Medusa REST API
             │
      ┌──────┴──────┐
      ▼             ▼
 Commerce        Subscription
 modules         custom module
      │             │
      └──────┬──────┘
             ▼
       Stripe Billing
             │
             ▼
     Recurring payments

Other strong options

commercetools is worth considering if you're building a larger enterprise platform. It has native Recurring Orders, including recurrence policies and schedules, and is strongly API-oriented. commercetools Documentation The tradeoff is greater enterprise complexity and typically a heavier implementation.

Saleor is another excellent headless/API-first option, particularly if you prefer GraphQL. Its storefront and admin are headless, and it supports extensive API-based extensions and webhooks. Saleor Documentation Saleor Commerce For a subscription-heavy product, though, I'd investigate the subscription/billing layer carefully rather than assuming it provides the same turnkey recurring-billing functionality as Stripe.

My ranking

My pick: Medusa + Stripe Billing if you're building a product where the subscription experience itself is a major part of the application. You get a commerce backend rather than just a storefront platform, while keeping the subscription lifecycle and recurring billing in a system purpose-built for it.

If you tell me whether this is B2C, B2B, SaaS, physical products, or digital products, I can narrow this down further and propose the API/data model for plans, subscriptions, upgrades, downgrades, trials, cancellations, and renewals.

Recommendation: Medusa + Stripe Billing

For your requirements—custom storefront, recurring subscription plans, and a strong API layer—I’d recommend Medusa + Stripe Billing.

medusajs.com

Why this combination:

• Truly headless: Medusa separates the commerce backend from the storefront, so you can build the UI in Next.js, React, mobile, or essentially any frontend stack. Medusa Documentation Medusa Documentation
• API-first: Medusa exposes REST Store APIs and lets you create your own API routes, workflows, data models, and modules. Medusa Documentation Medusa Documentation
• Subscriptions are customizable: Medusa has an official subscription implementation recipe covering recurring purchases, renewals, expiration, cancellation, and subscription management. Medusa Documentation
• Stripe handles the hard billing problems: recurring charges, saved payment methods, renewals, failed payments, etc. Medusa's documentation explicitly shows a Stripe-based subscription architecture. Medusa Documentation
• You retain control of the customer experience: your storefront can expose plan selection, upgrades/downgrades, cancellation, account management, and custom checkout flows without being constrained by a hosted commerce UI.

Suggested architecture

                Custom Storefront
                 Next.js / React
                       │
                       ▼
              ┌─────────────────┐
              │  Medusa API     │
              │                 │
              │ Products        │
              │ Customers       │
              │ Orders          │
              │ Pricing         │
              │ Subscription   │
              │ workflows       │
              └───────┬─────────┘
                      │
          ┌───────────┴───────────┐
          ▼                       ▼
   Stripe Billing            Your services
   recurring payments        entitlement /
   invoices                  membership logic
   payment methods           analytics / CRM

I would make Stripe the system of record for payment/billing state, while Medusa owns the commerce/customer/order side. Medusa's own documentation presents both a custom subscription approach and a Stripe-based approach; the latter is preferable if you're primarily interested in getting reliable recurring billing without implementing the billing engine yourself. Medusa Documentation

What I'd model

For example:

Subscription Plan
├── plan_id
├── name
├── description
├── billing_interval: month | year
├── price
├── trial_period
├── features
└── stripe_price_id

Customer
└── Subscriptions
    ├── status
    ├── current_period_end
    ├── plan
    ├── stripe_subscription_id
    └── entitlements

Your storefront could then expose APIs such as:

GET  /api/plans
POST /api/subscriptions
GET  /api/subscriptions/:id
POST /api/subscriptions/:id/change-plan
POST /api/subscriptions/:id/cancel
POST /api/subscriptions/:id/reactivate

with Stripe webhooks feeding subscription-state changes back into your application.

Alternative: Saleor

I'd put Saleor second on the shortlist.

saleor.io

Saleor is particularly attractive if your team strongly prefers GraphQL. It is API-first, headless, open source, and provides extensive webhook/app extensibility. Saleor Documentation Saleor Commerce

The tradeoff is that for a subscription-heavy business, I'd favor Medusa's framework/customization model if the subscription domain itself is going to be a major part of your product rather than simply recurring payment on otherwise-standard products.

My pick

Bottom line: I'd start with Medusa + Next.js + Stripe Billing, especially if your subscription plans have business rules beyond simply "charge $X every month." It gives you a relatively clean separation between commerce, billing, and your custom customer experience, while leaving the APIs and frontend under your control. Medusa Documentation Medusa Documentation

For your requirements, I’d shortlist Medusa and Saleor, with Medusa as my default recommendation.

My recommendation: Medusa

Medusa is particularly well suited if the product is subscription-first rather than a conventional ecommerce store.

Why:

• API-first/headless: your storefront is a completely separate application. Medusa exposes Store APIs and lets you build the frontend with your preferred stack, including Next.js. Medusa Documentation Medusa Documentation
• Subscription support: Medusa explicitly provides a recipe for implementing subscription-based commerce. Medusa Documentation
• Extensible commerce logic: you can add custom data models, modules, workflows, API routes, and event subscriptions—useful for things like plan changes, renewals, entitlements, usage limits, and subscription lifecycle events. Medusa Documentation
• REST + SDK: the Store API is REST-based and has an OpenAPI specification, which is convenient if your architecture has multiple clients or backend services. Medusa Documentation
• Custom storefront: you aren't locked into Medusa's frontend. Medusa Documentation

A typical architecture I'd use:

                 ┌─────────────────────┐
                 │   Custom Storefront │
                 │ Next.js / React     │
                 └──────────┬──────────┘
                            │
                     REST / SDK APIs
                            │
                 ┌──────────▼──────────┐
                 │       Medusa        │
                 │                     │
                 │ Catalog             │
                 │ Customers           │
                 │ Orders              │
                 │ Pricing             │
                 │ Custom subscription │
                 │ workflows           │
                 └──────────┬──────────┘
                            │
              ┌─────────────┼─────────────┐
              ▼             ▼             ▼
          Payments       Database       Webhooks
          provider       / custom       / events

For recurring billing specifically, I'd keep the payment/subscription billing engine separate from the core commerce catalog/order system where practical. That lets you model:

Plan → Subscription → Billing schedule → Payment → Entitlements

rather than trying to force recurring billing into a traditional ecommerce order model.

Strong alternative: Saleor

Saleor is probably the better choice if your priority is GraphQL, API purity, and a highly composable architecture.

Saleor is API-only/headless, GraphQL-native, open source, and has extensive webhook/API extension capabilities. GitHub Saleor Commerce It also provides a Next.js storefront starter and supports custom integrations through its API and apps. Saleor Commerce

I'd choose Saleor over Medusa when:

• GraphQL is a hard requirement.
• You expect many different clients consuming the commerce API.
• You want a very composable/headless architecture.
• Your engineering team is comfortable building more of the subscription-specific domain themselves.

What about commercetools?

commercetools is the enterprise option I'd investigate if budget and scale are major considerations.

It has both HTTP and GraphQL APIs and extensive commerce APIs. commercetools Documentation Its "Subscriptions" API, however, primarily refers to event notifications to queues, rather than being a complete recurring-billing subscription-management system. commercetools Documentation So you'd likely still pair it with a dedicated billing/subscription system.

My ranking

Bottom line: I'd start with Medusa + Next.js + a dedicated recurring-billing provider. That gives you a highly customizable storefront while keeping commerce, billing, and subscription lifecycle concerns cleanly separated.

If you tell me whether your subscriptions are digital/SaaS, physical products, memberships, or usage-based, I can also recommend the best Medusa/Saleor + Stripe/Paddle/Chargebee architecture for it.

My recommendation: Shopify + Headless Storefront API

For a custom storefront where recurring subscription plans and APIs are central, I’d choose Shopify, using its Storefront API with a custom frontend (Next.js, React, Vue, etc.). It gives you a strong balance between API flexibility, subscription capabilities, and not having to build the entire commerce backend yourself.

shopify.dev

Why it fits your use case

• True headless architecture: Shopify's Storefront API is GraphQL and framework-agnostic, so your storefront can be completely custom. Shopify Shopify
• Subscriptions are first-class commerce concepts: selling plans support recurring billing/delivery, pricing adjustments, and options such as weekly/monthly plans. Shopify Shopify
• Subscription products work through the Storefront API: you can query selling plans and attach a selected plan to a cart line. Shopify
• Good API ecosystem: products, collections, carts, customers, orders, metafields, etc. are exposed through Shopify APIs, while Shopify handles much of the underlying commerce infrastructure. Shopify
• Custom subscription UX: you can build your own plan selector, pricing UI, account portal, upgrade/downgrade flows, and subscription-management experience rather than using Shopify's standard storefront. Shopify even documents a Hydrogen subscription-management pattern. Shopify

A typical architecture would be:

                    ┌──────────────────────┐
                    │ Custom Storefront    │
                    │ Next.js / React      │
                    └──────────┬───────────┘
                               │
                         GraphQL API
                               │
                    ┌──────────▼───────────┐
                    │ Shopify              │
                    │ Storefront API       │
                    │                      │
                    │ Products             │
                    │ Selling Plans        │
                    │ Cart / Checkout      │
                    │ Customers             │
                    └──────────┬───────────┘
                               │
                     Admin / Commerce APIs
                               │
                    ┌──────────▼───────────┐
                    │ Back-office          │
                    │ subscriptions        │
                    │ fulfillment           │
                    │ inventory             │
                    │ payments              │
                    └──────────────────────┘

One important caveat

Shopify's selling plans provide the commerce primitives, but if subscriptions are the core of the business, you may want a dedicated subscription solution on top of Shopify rather than implementing all subscription lifecycle logic yourself. Shopify's own documentation notes that implementing subscription apps involves protected APIs/scopes and specific requirements. Shopify Shopify

So I'd evaluate the stack as:

Custom frontend → Shopify Storefront API → Shopify + subscription platform

rather than assuming Shopify alone should own every aspect of subscription management.

Alternatives worth considering

For a subscription-first product, I'd start with Shopify, unless your requirements include unusually complex recurring billing—for example, usage-based billing, multiple independent subscription components, sophisticated proration, metered charges, or SaaS-style entitlements. In those cases, I'd consider separating commerce/catalog from subscription billing.

If you tell me whether you're selling physical products, digital products, or a SaaS/service subscription, I can narrow this down to a specific stack (e.g. Shopify + Recharge vs. Shopify + Stripe vs. commercetools + Stripe) and recommend the API architecture.

For your requirements—custom storefront + recurring subscription plans + API-first architecture—I’d shortlist Medusa, Saleor, and commercetools, with Medusa as my default recommendation.

🥇 My pick: Medusa

Medusa is particularly attractive if you're building the application rather than looking for an out-of-the-box SaaS storefront.

It is TypeScript/Node.js based, headless, modular, and exposes commerce functionality through APIs. Most importantly for your use case, Medusa has an official subscription implementation recipe covering monthly/yearly plans, automatic renewals, expiration tracking, cancellation, and customer subscription management. The implementation uses Stripe as the payment example, while allowing you to build your own payment/subscription provider. Medusa Docs Medusa Docs

That gives you an architecture roughly like:

                Custom Storefront
              Next.js / React / etc.
                       │
                       ▼
                 Medusa API
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
     Products        Orders        Customers
                       │
                       ▼
                Subscription Layer
                       │
                       ▼
                    Stripe
                       │
                       ▼
             Recurring Billing

The key advantage is that your subscription business logic remains yours rather than forcing the storefront into a vendor's subscription UX.

🥈 Saleor

Saleor is worth considering if GraphQL is a major architectural requirement.

Saleor is API-only and GraphQL-native, with extensive webhook/app capabilities and native multichannel commerce. Its official documentation emphasizes building the storefront independently of the commerce backend. Saleor Commerce GitHub

The caveat is subscriptions: Saleor doesn't give you a full native recurring-billing engine, so you'd still be composing subscription functionality around the commerce API and a payment/billing provider. Swell

I'd choose Saleor over Medusa if you have requirements like:

• Multiple storefronts/channels
• Complex B2B pricing
• GraphQL as a core platform standard
• Multiple warehouses/regions
• A Python/Django backend team

🥉 commercetools

commercetools is the one I'd investigate if this is an enterprise-scale composable commerce project.

It's extremely API-centric and designed for composing specialized services together. Its event/subscription mechanisms can also feed asynchronous processes such as payment-related workflows and CRM synchronization. commercetools Documentation

But for a new subscription-focused product, I wouldn't start here unless you actually need enterprise-scale commerce complexity. You're likely buying considerably more platform than you need.

What I'd build

If your product is something like "customers choose a plan → pay → automatically renew → manage/cancel/upgrade → receive recurring fulfillment", I'd use:

• Storefront: Next.js
• Commerce: Medusa
• Billing: Stripe Billing
• Database: PostgreSQL
• Authentication: your preferred auth provider
• Webhooks: Stripe → your subscription service/Medusa
• Email: Resend/Postmark/etc.
• CMS: optional headless CMS
• Search: optional Algolia/Typesense/etc.

One important architectural decision: don't make Medusa responsible for the actual recurring payment schedule if Stripe is your billing system. Let Stripe own billing state and payment retries, while Medusa owns commerce/order/product state. Medusa's own subscription recipe follows essentially this approach. Medusa Docs

That separation gives you a clean model:

Stripe
  = "Is this customer's subscription paid/active?"

Medusa
  = "What did the customer subscribe to and what
     commerce/order/fulfillment state does that create?"

Your application
  = "What does this subscription mean for our product?"

Bottom line: I'd pick Medusa + Stripe + Next.js unless you have a strong reason to prefer GraphQL/Saleor or enterprise composable commerce. Medusa gives you the most control without requiring you to build an entire commerce engine yourself. Medusa Docs powergatesoftware.com

If you tell me your subscription model (digital, physical, SaaS, subscription box, memberships, etc.) and expected scale, I can narrow this down to a specific architecture and API design.

Saleor is worth considering if GraphQL is a major architectural requirement.

Saleor is API-only and GraphQL-native, with extensive webhook/app capabilities and native multichannel commerce. Its official documentation emphasizes building the storefront independently of the commerce backend.

The caveat is subscriptions: Saleor doesn't give you a full native recurring-billing engine, so you'd still be composing subscription functionality around the commerce API and a payment/billing provider.

I'd choose Saleor over Medusa if you have requirements like:

For a custom storefront centered on recurring subscription plans and API-driven commerce, my top recommendation is Medusa—especially if you want control over the subscription domain rather than having the commerce platform dictate the UX.

My shortlist

1. Medusa — my pick

Medusa is particularly attractive because the storefront is completely separate from the commerce backend, so you can build the frontend in Next.js, React, mobile, etc., and communicate through its Store API and custom API routes. Medusa Documentation Medusa Documentation

More importantly for your use case, Medusa has an official subscription implementation recipe covering:

• monthly/yearly subscription intervals
• automatic renewals
• expiration tracking
• customer subscription management/cancellation
• subscription-specific API routes
• Stripe integration for recurring payments

The important caveat is that subscriptions aren't a native commerce primitive; Medusa gives you the framework to implement them. Medusa Documentation

That can actually be an advantage if your plans have unusual business rules.

A typical architecture would be:

Custom Storefront
     │
     ▼
Your BFF / API layer
     │
     ├── Medusa Store API
     ├── Medusa custom subscription APIs
     └── Stripe Billing
              │
              ▼
        Webhooks / events
              │
              ▼
       Subscription state

Medusa also lets you expose arbitrary custom REST API routes, so things like:

POST /subscriptions
GET  /subscriptions/:id
POST /subscriptions/:id/pause
POST /subscriptions/:id/resume
POST /subscriptions/:id/cancel
POST /subscriptions/:id/change-plan

can live alongside the commerce APIs. Medusa Documentation

docs.medusajs.com

2. commercetools — best enterprise option

I'd choose commercetools instead if you're building a large-scale enterprise subscription business and want recurring commerce functionality closer to the platform itself.

Its Recurring Orders API supports scheduled automatic orders, recurrence policies, different intervals, and the ability to pause, skip, modify, and cancel recurring orders. commercetools Documentation commercetools Documentation

One caveat: recurring orders were introduced as a public beta, so I'd validate the exact subscription/billing requirements against the current platform capabilities before committing. commercetools Documentation

docs.commercetools.com

3. Saleor — best GraphQL experience

Saleor is compelling if your engineering team strongly prefers GraphQL. Its commerce API is GraphQL-native, and the platform is designed to be headless and technology-agnostic. It also exposes extensive webhooks and extension mechanisms. Saleor Commerce Saleor Commerce

I'd rank it below Medusa for your specific requirement, though, because you'd likely still be designing more of the subscription architecture yourself.

docs.saleor.io

What I'd build

If the product is something like "choose a plan → subscribe → manage billing → upgrade/downgrade → pause/cancel → recurring fulfillment", I'd use:

Next.js + Medusa + Stripe Billing

with Medusa owning:

• products
• customers
• orders
• pricing/catalog
• fulfillment
• commerce state

Stripe owning:

• payment methods
• recurring billing
• invoices
• payment retries
• tax/billing primitives where appropriate

and a custom subscription module/API owning:

• plan eligibility
• subscription state
• upgrades/downgrades
• pauses
• renewals
• entitlements
• business-specific subscription rules

Bottom line: choose Medusa if developer control and a highly customized subscription experience are the priorities. Choose commercetools if you're operating at enterprise scale and want more recurring-order functionality built into the commerce platform. Choose Saleor if GraphQL is a major architectural requirement.

If you tell me whether these are physical-product subscriptions, SaaS memberships, or digital subscriptions, I can narrow this down considerably and propose the API/data model I'd use.

I'd choose commercetools instead if you're building a large-scale enterprise subscription business and want recurring commerce functionality closer to the platform itself.

Its Recurring Orders API supports scheduled automatic orders, recurrence policies, different intervals, and the ability to pause, skip, modify, and cancel recurring orders. commercetools Documentation commercetools Documentation

One caveat: recurring orders were introduced as a public beta, so I'd validate the exact subscription/billing requirements against the current platform capabilities before committing. commercetools Documentation

docs.commercetools.com

3. Saleor — best GraphQL experience

Saleor is compelling if your engineering team strongly prefers GraphQL. Its commerce API is GraphQL-native, and the platform is designed to be headless and technology-agnostic. It also exposes extensive webhooks and extension mechanisms. saleor.io saleor.io

I'd rank it below Medusa for your specific requirement, though, because you'd likely still be designing more of the subscription architecture yourself.

For a custom storefront where recurring subscriptions and APIs are the primary requirements, I’d shortlist these three:

My recommendation: Medusa

medusajs.com is probably the best fit if you want maximum control over the storefront and subscription business logic.

Why I’d choose it:

• API-first/headless: the storefront is completely separate from the commerce backend, and you can build it with Next.js, React, mobile apps, or another stack. Medusa Documentation Medusa Documentation
• Highly customizable: Medusa lets you create custom API routes, workflows, data models, and modules rather than forcing your business model into a rigid SaaS platform. Medusa Documentation
• Subscriptions are extensible: Medusa has a documented subscription architecture for creating subscription records, renewal jobs, custom APIs, and subscription management. Medusa Documentation
• Stripe integration is possible: you can delegate recurring payment processing to Stripe while keeping your commerce logic in Medusa. Medusa Documentation
• Good architecture for a subscription-heavy product: you could expose endpoints such as: - POST /store/subscriptions
• GET /store/customers/:id/subscriptions
• POST /store/subscriptions/:id/pause
• POST /store/subscriptions/:id/skip
• POST /store/subscriptions/:id/cancel

The important caveat is that Medusa doesn't give you a completely finished subscription SaaS out of the box. Its documentation explicitly describes building the subscription logic yourself or integrating Stripe's subscription functionality. Medusa Documentation

That is actually a strength if your subscription model is unusual.

Runner-up: commercetools

commercetools.com would be my choice for a larger enterprise operation.

It has a very strong API-first architecture and now has Recurring Orders, including recurrence policies, recurring-order APIs, and lifecycle operations such as pausing, skipping, modifying, and canceling subscriptions. commercetools Documentation commercetools Documentation

It also supports both HTTP and GraphQL APIs. commercetools Documentation

The downside is complexity and likely higher implementation/operational cost compared with Medusa.

How I'd decide

The architecture I'd use

For your particular requirements, I'd lean toward:

Next.js storefront → Medusa API → Stripe Billing → PostgreSQL

with something like:

                 ┌──────────────────┐
                 │  Custom Storefront│
                 │    Next.js/React  │
                 └────────┬─────────┘
                          │
                     REST / API
                          │
                 ┌────────▼─────────┐
                 │      Medusa      │
                 │ Commerce +       │
                 │ subscription     │
                 │ business logic   │
                 └───────┬──────────┘
                         │
             ┌───────────┴───────────┐
             │                       │
       ┌─────▼─────┐           ┌────▼─────┐
       │   Stripe  │           │PostgreSQL│
       │ recurring │           │          │
       │ payments  │           │ commerce │
       └───────────┘           └──────────┘

This gives you a completely custom customer experience while keeping payment processing and recurring billing separate from your storefront.

If your subscription model is fairly standard—monthly/annual plans, upgrades/downgrades, trials, coupons, failed-payment recovery—I'd use Stripe for billing and Medusa for commerce rather than implementing recurring payment logic yourself.

If, however, you need sophisticated things like subscription boxes, product swaps, custom renewal schedules, prepaid terms, mixed one-time/subscription carts, or complicated fulfillment rules, I'd put more of that lifecycle logic into Medusa.

Bottom line: Medusa + Stripe is my first choice for a developer-controlled, API-centric custom subscription storefront; commercetools is the stronger choice if you're already operating at enterprise scale and want more native recurring-commerce functionality. Medusa Documentation commercetools Documentation

If you tell me your subscription model (e.g. SaaS vs physical products), expected scale, and preferred frontend (Next.js/React/etc.), I can narrow this down to a specific architecture and compare Medusa vs commercetools vs Shopify headless vs Saleor.

For your requirements, I’d recommend medusajs.com as the strongest starting point.

Why Medusa fits

• True headless architecture: your storefront is a separate application, so you can build it in Next.js, React, Vue, mobile, etc. and consume Medusa through APIs. Medusa Docs
• API-first: Medusa exposes REST Store APIs and lets you create your own API routes for business-specific functionality. Medusa Docs Medusa Docs
• Subscriptions are customizable: Medusa has an official subscription implementation guide covering recurring billing, renewal, expiration, cancellation, customer subscription management, and admin views. Medusa Docs
• Stripe integration: the documented approach can use Stripe to handle recurring payments, while Medusa manages the commerce/subscription layer. Medusa Docs
• Highly extensible: you can create custom modules, data models, workflows, API routes, scheduled jobs, and admin functionality rather than fighting the platform's built-in assumptions. Medusa Docs

Architecture I'd use

Custom Next.js Storefront
        │
        │ REST / Store API
        ▼
     Medusa
   ┌───────────────┐
   │ Catalog       │
   │ Customers     │
   │ Cart/Checkout │
   │ Orders        │
   │ Pricing       │
   │ Subscription  │
   └───────┬───────┘
           │
           ├── Stripe Billing/Payments
           │
           ├── Your CRM
           ├── Fulfillment
           └── Analytics

I'd model the subscription itself in a custom Medusa Subscription Module, with fields such as:

subscription
├── customer_id
├── plan_id
├── status
├── interval
├── price
├── started_at
├── next_billing_at
├── expires_at
├── payment_provider_id
└── metadata

Then expose APIs along the lines of:

POST /store/subscriptions
GET  /store/customers/me/subscriptions
GET  /store/customers/me/subscriptions/:id
POST /store/customers/me/subscriptions/:id/cancel
POST /store/customers/me/subscriptions/:id/pause
POST /store/customers/me/subscriptions/:id/change-plan

Medusa's documented subscription recipe already demonstrates customer subscription retrieval/cancellation and scheduled renewal workflows, so you're not starting from a completely blank framework. Medusa Docs

One important caveat

Medusa doesn't provide subscriptions as a native commerce primitive. Its subscription functionality is implemented through its customization framework. Medusa Docs

If recurring subscriptions are the central business model rather than one feature of the store, I'd also evaluate commercetools. Its platform has a native Recurring Orders capability designed around recurrence schedules, including carts containing recurring and one-time items. Commercetools Documentation

So my shortlist would be:

docs.saleor.io describes its GraphQL API, payment integrations, extensions, and headless architecture, but I'd put it behind Medusa/commercetools specifically for a subscription-heavy use case. Saleor Documentation

My pick: Medusa + Next.js + Stripe if you want maximum control and a relatively developer-friendly stack. commercetools if you're building an enterprise system where recurring-order capabilities and platform maturity outweigh implementation simplicity.

If recurring subscriptions + a fully custom storefront + strong APIs are the priorities, I’d shortlist these:

My recommendation: Swell

For your specific requirements, Swell is probably the best starting point because subscriptions are a first-class capability rather than something you have to build around the commerce engine. Current comparisons specifically identify Swell as having native subscriptions, whereas Medusa and Saleor require additional subscription implementation. Swell Swell

That gives you an architecture roughly like:

Custom storefront
      │
      ▼
Next.js / React / Vue / etc.
      │
      ▼
Swell APIs
 ┌────┴───────────────┐
 │                    │
Products          Subscriptions
 │                    │
Cart / Checkout   Recurring billing
 │                    │
Orders            Customer portal
 │                    │
      └──────┬────────┘
             ▼
        Payment provider

The major advantage is that your frontend team can own the entire customer experience—plan selection, pricing pages, checkout, account management, upgrade/downgrade flows—without turning subscriptions into a separate application that you have to maintain.

When I'd choose Medusa instead

Choose Medusa if your requirements are sufficiently custom that you want to own the commerce logic.

Medusa is TypeScript/Node.js, API-driven and highly extensible, which is particularly attractive if your storefront is Next.js. However, subscriptions aren't native: Medusa's own documentation describes implementing recurring subscriptions as a customization, commonly using Stripe for the recurring payment layer. Medusa Documentation Medusa Documentation

So I'd use:

Next.js + Medusa + Stripe

if you need things like:

• Complex subscription provisioning
• Custom renewal/entitlement logic
• Multiple billing models
• Custom product bundles
• Marketplace functionality
• Deep integration with your own backend
• Full control over the commerce data model

The tradeoff is considerably more engineering.

When I'd choose Saleor

If GraphQL is a hard requirement, I'd seriously consider Saleor. It is GraphQL-native and exposes storefront/admin functionality through APIs, with extensive webhook-based extensibility. Saleor Commerce

But I wouldn't pick it primarily for subscriptions. Saleor doesn't provide the same native subscription-oriented advantage that Swell does, so you'd likely be composing it with a dedicated billing/subscription system.

Bottom line

For a subscription-heavy custom storefront:
Swell → best overall fit

For maximum engineering control:
Medusa + Stripe → best customizable architecture

For GraphQL + enterprise commerce:
Saleor → best API-centric option

For very large enterprise/composable commerce:
commercetools → worth evaluating

If you tell me whether your subscriptions are digital (SaaS/membership), physical recurring shipments, or both, I can narrow this to a concrete architecture and compare Swell vs Medusa + Stripe vs Shopify + Stripe for your use case.

Recommendation: Shopify + Storefront API

For a custom storefront centered on recurring subscription plans and APIs, I’d recommend Shopify with its Storefront API, rather than building the commerce backend from scratch.

Shopify’s Storefront API is explicitly designed for headless storefronts: you can use your own frontend while Shopify handles products, pricing, carts, checkout, inventory, orders, and other commerce primitives. Shopify

Why it fits your use case

• Subscriptions are a first-class commerce concept. Shopify's SellingPlan model supports recurring billing/delivery policies, pricing adjustments, and multiple subscription options. Shopify Shopify
• Headless storefronts are fully supported. You can build the UI in Next.js, React, Vue, mobile, etc., while consuming Shopify through GraphQL. Shopify
• Subscription selection works through the Storefront API. Your frontend can query selling plans and create carts containing subscription line items. Shopify
• Good API architecture. Keep Shopify as the commerce system of record and put your own API/BFF layer in front of it if you need custom business logic, personalization, entitlement management, or integrations.
• You don't have to build payment/subscription infrastructure yourself. That's a major advantage over an open-source commerce engine if recurring billing is central to the product.

Suggested architecture

                    Your custom storefront
                   Next.js / React / Mobile
                            │
                            ▼
                    Your API / BFF layer
                  ┌─────────┴─────────┐
                  │                   │
                  ▼                   ▼
          Shopify Storefront     Your application
               GraphQL API           services
                  │                   │
                  ▼                   ├─ Entitlements
              Shopify               ├─ User accounts
          Commerce Backend          ├─ Analytics
                  │                 └─ Integrations
                  ▼
       Products / Orders / Checkout
       Selling Plans / Subscriptions

For the frontend, Hydrogen is worth considering if you're comfortable with Shopify's stack, although you don't have to use it—you can use a conventional Next.js application instead. Shopify has an official Hydrogen subscription implementation showing selling-plan selection, subscription pricing, cart integration, and subscription management. Shopify

shopify.dev

One important caveat

If subscriptions are the core of your business model, I'd validate the exact subscription requirements before committing. Shopify's native selling-plan model is excellent for things like:

Product → monthly/weekly plan → recurring delivery → subscription management

But if you're building something more like SaaS memberships, complex usage-based billing, metered subscriptions, heavily customized billing cycles, or subscription contracts that are fundamentally different from product purchases, I'd consider separating billing/subscription management from the commerce platform.

In that situation, a stack such as:

Next.js + Shopify + Stripe Billing + your own subscription/entitlement service

can be more flexible.

My shortlist

Bottom line: for a new custom storefront where recurring plans + APIs + fast development are the priorities, I'd start with Shopify Storefront API, and use your own backend layer for anything Shopify-specific that you don't want exposed directly to the frontend. Shopify Shopify

If you tell me whether these are physical-product subscriptions, digital/SaaS subscriptions, or memberships, I can narrow this down considerably and give you a recommended stack (including Shopify vs Medusa vs Stripe Billing) and API architecture.

For a custom storefront where recurring subscriptions and API access are core requirements, I’d shortlist Swell, Medusa, and commercetools—but my first choice would depend on how much subscription logic you want to build yourself.

My recommendation: Swell

swell.is is particularly attractive if subscriptions are a first-class business model, rather than an add-on.

• Native subscriptions rather than having to bolt a subscription engine onto the commerce platform.
• GraphQL + REST APIs, which works well with a completely custom frontend.
• Headless architecture lets you build the storefront in Next.js, React, mobile, etc.
• More of the recurring-commerce functionality is handled by the platform, reducing the amount of billing/renewal code you need to own. Swell

How I'd compare the main options

One important caveat: Medusa doesn't natively provide subscription purchases. Its documentation instead shows how to implement recurring subscriptions yourself, including Stripe-based billing, renewal, expiration and cancellation workflows. Medusa Docs

That makes Medusa excellent if your subscription model is unusual—for example:

Customer → Plan → Entitlements → Subscription → Recurring Order → Usage/Access

—but it means you own more of the billing lifecycle.

If I were architecting this

I'd consider:

Custom Next.js storefront
↓
Swell API
↓
Subscription + commerce platform
↓
Stripe/payment provider
↓
Your application/entitlements API

For each plan, I'd model things like:

• billing interval
• price
• trial period
• included entitlements
• usage limits
• renewal/cancellation rules
• upgrade/downgrade behavior
• prorations
• subscription status
• customer access/entitlements

If you expect highly customized subscription workflows, I'd switch the recommendation to Medusa. Its TypeScript/Node architecture is particularly attractive when your storefront and commerce backend are both JavaScript/TypeScript. Eryx Innovations Lab

If you're talking about enterprise-scale composable commerce, with sophisticated pricing, multiple markets/channels, and a dedicated platform engineering team, I'd evaluate commercetools.com instead. Current industry comparisons generally position it toward large enterprise composable-commerce implementations. Vendure

Bottom line:
Swell if recurring subscriptions are the centerpiece and you want less infrastructure to build.
Medusa if developer control and custom subscription logic matter more than out-of-the-box recurring billing.
commercetools if this is an enterprise composable-commerce project.

If you tell me your expected subscriber count, B2C vs. B2B, billing model (monthly/yearly/usage), and preferred stack (Next.js/Node/etc.), I can narrow this to a specific architecture and API stack.

Custom Next.js storefront
↓
Swell API
↓
Subscription + commerce platform
↓
Stripe/payment provider
↓
Your application/entitlements API

For each plan, I'd model things like:

For a custom storefront where recurring subscriptions are the core business model and APIs are a first-class requirement, my top recommendation is Medusa—paired with Stripe Billing if you're comfortable making Stripe the subscription engine.

My recommendation: Medusa + Stripe

Medusa is a strong fit because it is headless, open source, TypeScript/Node.js-based, and designed around modular commerce APIs. It gives you control over products, carts, customers, orders, payments, promotions, inventory, and custom commerce logic without forcing your storefront into a particular frontend. Medusa Medusa

For subscriptions, I'd structure it roughly as:

Custom Storefront
   │
   ├── Next.js / React / mobile app
   │
   ▼
Medusa Commerce API
   │
   ├── Products / Plans
   ├── Customers
   ├── Cart / Checkout
   ├── Orders
   ├── Entitlements
   └── Custom subscription logic
          │
          ▼
      Stripe Billing
          │
          ├── Recurring charges
          ├── Payment methods
          ├── Failed payments
          ├── Invoices
          └── Webhooks

Medusa's own documentation describes using Stripe to handle recurring payment collection while Medusa handles the broader commerce experience; it also supports building custom subscription logic when you need more control. Medusa Documentation

Why I'd choose it

• API-first: Your storefront isn't tied to the commerce backend's presentation layer.
• Very customizable: Subscription tiers, signup flows, upgrades/downgrades, bundles, credits, custom checkout rules, etc. can be modeled around your business.
• TypeScript/Node.js: Particularly attractive if your frontend team already works in React/Next.js.
• No need to make Shopify's checkout model your architecture: Useful if subscriptions are the product rather than an add-on.
• Good path to mobile/apps: The same backend can serve web, native mobile, partner portals, or other clients.
• Open source: You have considerably more control over the backend than with a traditional SaaS commerce platform.

Medusa specifically highlights subscriptions and custom checkout/payment options among its B2C capabilities, and there's an existing case study where a company built subscription renewal logic directly into Medusa because provider-specific subscription implementations weren't flexible enough. Medusa Medusa

One important caveat

I wouldn't choose Medusa simply because it says "subscriptions." Its subscription capabilities are not equivalent to a mature dedicated billing system. Medusa's documentation explicitly presents Stripe as an option for recurring-payment handling and notes that its standard Stripe payment module doesn't itself implement subscriptions. Medusa Documentation

So I'd separate responsibilities:

That gives you a clean distinction between commerce and recurring financial billing.

Alternatives worth considering

Swell is actually worth a serious look if you want subscriptions to be more of a native commerce capability rather than something you assemble. Current comparisons describe Swell as API-first with native subscriptions and both GraphQL and REST APIs. Swell

Saleor is my second choice if your team strongly prefers GraphQL. It's a sophisticated headless platform with a GraphQL-first API and strong multi-channel/B2B capabilities, but subscriptions generally require additional implementation rather than being its core native strength. Vendure OSSAlt

Shopify + Hydrogen is the choice I'd make if your priority were getting to market quickly with minimal backend operations. It has an enormous ecosystem and handles much of the infrastructure for you, but subscription-heavy businesses can end up depending on additional apps/integrations, and you have less control over the underlying commerce system. Ribbsaeter Systems

Bottom line

If I were architecting this today:

🥇 Medusa + Stripe Billing — best balance of custom storefront, API control, extensibility, and subscription capability.

🥈 Swell — investigate this first if you want native subscriptions with less custom engineering.

🥉 Saleor — excellent if GraphQL and enterprise/multi-channel commerce are more important than subscription-specific functionality.

Shopify Hydrogen — choose instead if operational simplicity and speed-to-market outweigh backend control.

If you tell me roughly what the subscription is for (physical products, SaaS/software access, memberships, meal boxes, etc.) and whether you need pause/skip, upgrades/downgrades, usage-based billing, trials, coupons, or multiple payment methods, I can narrow this to a concrete architecture and API model.

For a custom storefront centered around recurring subscription plans, strong APIs, and full frontend control, I’d shortlist these options:

My recommendation: Medusa + Stripe Billing (for most custom subscription businesses)

For a product like:

• SaaS-like plans
• memberships
• recurring boxes
• usage tiers
• bundles
• customer portals
• custom checkout flows
• mobile apps consuming APIs

I would start with:

Frontend

• Next.js / React / mobile apps

Commerce backend

• Medusa

Subscription billing

• Stripe Billing

Supporting services

• CMS: Contentful or Sanity
• Search: Algolia or Elasticsearch
• Auth: Auth.js, Clerk, or your own identity service

Medusa is attractive here because it is designed as a customizable commerce framework: you can add custom API routes, workflows, and modules instead of fighting a fixed checkout model. Its subscription documentation shows patterns for creating subscription models, renewal workflows, API routes, and Stripe-based payment flows. Medusa Docs Medusa Docs

A typical architecture:

Next.js Storefront
        |
        | REST / GraphQL
        |
   Commerce API
        |
   Medusa Backend
        |
 -----------------------
 |          |           |
Products  Orders   Customers
 |
Subscription Service
 |
Stripe Billing
 |
Recurring Payments

When I would choose Saleor instead

Pick Saleor if your priorities are:

• GraphQL everywhere
• highly structured APIs
• multi-region / multi-channel commerce
• enterprise integrations
• Python/Django expertise internally

Saleor is API-only and GraphQL-native, with extensibility through APIs, webhooks, and apps. GitHub Saleor Commerce It is excellent as a commerce engine, but recurring billing usually becomes an application-layer concern rather than a core subscription system.

When I would not build subscriptions directly into commerce

Avoid putting recurring billing logic entirely inside your commerce platform if you need:

• proration
• upgrades/downgrades
• failed payment recovery
• dunning
• tax handling for recurring invoices
• usage-based billing
• complex entitlement management

A better pattern is:

Commerce Platform
        |
        |
Subscription/Entitlement Service
        |
        |
Billing Provider

Commerce handles:

• products
• orders
• inventory
• customer data

Subscription system handles:

• plans
• renewals
• invoices
• payment retries
• access rights

My ranking for your specific use case

1. Medusa + Stripe Billing — best balance of flexibility and development speed
2. Saleor + custom subscription service — best API architecture
3. commercetools + subscription platform — best enterprise scale
4. Shopify Headless + subscription apps — fastest launch, less customization
5. BigCommerce Headless — good if you want hosted commerce operations

If you are building a subscription-first business (where subscriptions are the core product rather than an add-on), I would also evaluate dedicated billing platforms such as Chargebee, Recurly, or Stripe Billing alongside the commerce layer rather than expecting ecommerce software alone to own the whole lifecycle.

If recurring subscriptions are a core part of the business model, I’d prioritize a platform with subscription primitives rather than bolting subscriptions onto a generic headless commerce engine.

My recommendation: Swell

Swell is probably the best fit for your requirements if you want:

• A fully custom storefront
• Native recurring subscriptions
• API-first commerce
• Both REST and GraphQL APIs
• Products, customers, orders, checkout, etc. managed by the commerce backend
• Less custom subscription infrastructure than you'd need with Medusa/Saleor

Recent comparisons specifically identify Swell as one of the few API-first platforms with native subscriptions plus both GraphQL and REST, whereas Medusa, Saleor, Vendure, and Shopify generally require an additional subscription solution or app. Swell

swell.is

How I'd shortlist the alternatives

Medusa is particularly attractive if you want to own the commerce backend and your team is comfortable with TypeScript/Node.js. Its modular architecture is designed for custom commerce logic, but subscriptions aren't its strongest native capability. OSSAlt Vendure

Saleor is excellent if your organization is GraphQL-heavy and needs sophisticated multi-channel, B2B, inventory, and enterprise commerce capabilities, but it likewise isn't the obvious choice when subscriptions are the central requirement. OSSAlt

Architecture I'd use

For a subscription-focused custom storefront, I'd lean toward:

Next.js / React storefront
↓
Swell APIs
↓
Products / Customers / Orders / Subscriptions
↓
Payment processor
↓
Webhooks → your application/backend

The important thing is to keep subscription lifecycle events—renewal, cancellation, failed payment, plan change, pause/resume, etc.—event-driven rather than implementing them entirely in the frontend.

Bottom line: If subscriptions are the primary differentiator, I'd start with Swell. If the requirement is instead "we need maximum backend ownership and will build the subscription engine ourselves," I'd choose Medusa. If you're building a large enterprise commerce platform around GraphQL, I'd investigate Saleor or commercetools. Swell Vendure

If you tell me your expected subscription model (monthly/annual, usage-based, multiple plans, upgrades/downgrades) and whether you prefer managed SaaS vs self-hosted, I can narrow this to a specific stack and architecture.

For a custom storefront centered on recurring subscription plans and APIs, my top recommendation is commercetools.

My ranking

1. commercetools — best overall

commercetools.com

This is the one I'd choose if subscriptions are a core business capability, rather than something you want to bolt onto a normal ecommerce backend.

Its newer Recurring Orders capability models recurrence policies, recurring prices, and recurring orders directly in the commerce API. It supports scheduled repeat orders and allows recurring purchases to coexist with one-time purchases. Commercetools Documentation Commercetools Documentation

The API architecture is also very suitable for a custom storefront: commercetools recommends using its general APIs behind a middleware/BFF for custom frontends, giving you control over exactly what your storefront exposes. Commercetools Documentation

For payments, its Checkout Transactions API can trigger payments without using the hosted Checkout UI, including payments for subscription-based orders. Commercetools Documentation

A good architecture would be:

Next.js / React storefront → your BFF/API layer → commercetools → payment provider

with your BFF handling things like:

• Plan selection
• Customer/subscriber accounts
• Subscribe / pause / resume / cancel
• Plan upgrades/downgrades
• One-time + recurring products
• Customer-specific pricing
• Webhooks/events
• Your own subscription business rules

2. Medusa — best if you want maximum developer control

medusajs.com

I'd pick Medusa if your subscription model is unusual enough that you expect to build substantial custom commerce logic yourself.

Medusa is explicitly designed as a customizable commerce framework, with custom API routes, workflows, data models, modules and event subscriptions. Medusa Documentation Medusa Documentation

The important caveat: subscriptions aren't native in the same sense as commercetools. Medusa's own documentation provides a subscription recipe where you implement recurring purchases, renewal, expiration, cancellation, etc., with Stripe as the example payment provider. Medusa Documentation

That's actually attractive if you want your subscription engine to be your application rather than a capability dictated by the commerce platform.

3. Saleor — excellent API-first alternative

saleor.io

Saleor is particularly compelling if you prefer GraphQL + open source. Its storefront and admin are fully headless, and it provides extensive APIs, webhooks, apps and extension mechanisms. Saleor Commerce GitHub

I'd put it behind commercetools for your particular requirement because recurring subscriptions aren't as central/native to its commerce model. You'd likely integrate a dedicated subscription/billing system.

What I'd actually build

If you're selling something like Basic / Pro / Enterprise monthly plans, I'd avoid making the commerce platform responsible for all subscription state.

I'd use:

Next.js → BFF → commercetools + Stripe

where:

• commercetools = products, prices, carts, orders, customers, recurring-order commerce
• Stripe = payment methods, payment collection, billing/payment events
• BFF = your subscription API and business rules
• Next.js = completely custom customer experience
• Webhook/event layer = synchronizes payment and commerce state

That gives you a clean API such as:

POST   /api/subscriptions
GET    /api/subscriptions/:id
POST   /api/subscriptions/:id/pause
POST   /api/subscriptions/:id/resume
POST   /api/subscriptions/:id/cancel
POST   /api/subscriptions/:id/change-plan
GET    /api/plans

Bottom line: choose commercetools if you want a mature enterprise-grade commerce backend with increasingly strong native recurring-order capabilities. Choose Medusa if your differentiation is the subscription logic itself and you want to own/customize virtually everything. Saleor is the strongest alternative if GraphQL and open-source control are priorities.

saleor.io

Saleor is particularly compelling if you prefer GraphQL + open source. Its storefront and admin are fully headless, and it provides extensive APIs, webhooks, apps and extension mechanisms. saleor.io github.com

I'd put it behind commercetools for your particular requirement because recurring subscriptions aren't as central/native to its commerce model. You'd likely integrate a dedicated subscription/billing system.

What I'd actually build

If you're selling something like Basic / Pro / Enterprise monthly plans, I'd avoid making the commerce platform responsible for all subscription state.

I'd use:

Next.js → BFF → commercetools + Stripe

where:

For a custom storefront centered on recurring subscription plans and APIs, I’d recommend Medusa as the strongest overall fit.

My recommendation: Medusa

docs.medusajs.com

Why it fits your use case:

• Truly headless: the storefront is a separate application, so you can build it with Next.js, React, or essentially any frontend stack. MedusaJS Documentation
• API-first: Medusa exposes REST Store APIs plus custom API routes, making it well suited to a custom frontend, mobile apps, partner integrations, and your own subscription-management UI. MedusaJS Documentation MedusaJS Documentation
• Highly customizable: you can create custom data models, modules, workflows, scheduled jobs, and API endpoints rather than trying to bend a SaaS platform's predefined subscription model around your business. MedusaJS Documentation MedusaJS Documentation
• Subscription support is achievable: Medusa has an official subscription recipe covering recurring purchases, renewals, expiration, cancellation, customer subscription APIs, and Stripe integration. Importantly, subscriptions aren't a native core feature—you implement the subscription domain using Medusa's framework. MedusaJS Documentation MedusaJS Documentation
• Stripe option: you can delegate recurring payment collection to Stripe while keeping products, orders, customers, fulfillment, and your subscription abstraction in Medusa. MedusaJS Documentation

A sensible architecture would be:

Custom Next.js storefront
        │
        ▼
Your API / BFF layer
        │
        ├── Medusa Store API
        ├── Medusa custom subscription APIs
        └── Stripe Billing
                │
                ▼
        Recurring payments

For example, I'd model:

Plan
 ├── name
 ├── interval (monthly/yearly)
 ├── price
 ├── features
 ├── products
 └── Stripe price ID

Subscription
 ├── customer
 ├── plan
 ├── status
 ├── current_period_start
 ├── current_period_end
 ├── cancel_at_period_end
 └── Stripe subscription ID

Then expose APIs such as:

GET  /store/plans
POST /store/subscriptions
GET  /store/customers/me/subscriptions
POST /store/customers/me/subscriptions/:id/cancel
POST /store/customers/me/subscriptions/:id/change-plan
POST /store/webhooks/stripe

Medusa's own subscription example demonstrates customer-facing subscription listing/cancellation endpoints and custom API routes, so this maps particularly well to your requirements. MedusaJS Documentation

Alternatives I'd consider

commercetools is particularly interesting if you're building an enterprise system. Its Recurring Orders API has first-class recurring-order concepts, schedules, pause/cancel functionality, and automatic order creation. commercetools Documentation commercetools Documentation

I'd choose Saleor if your team strongly prefers GraphQL; its architecture is API-only/headless and designed for composable extensions. GitHub

Bottom line

If your priority is "we want to own the storefront experience and expose a clean subscription API without being constrained by an ecommerce SaaS platform", I'd start with Medusa + Stripe + Next.js.

If you tell me whether you're selling physical products, digital memberships/SaaS, or both, I can narrow this down further and give you a recommended architecture—including subscription lifecycle, Stripe vs. alternative billing, database model, and API design.

For your requirements—custom storefront + recurring subscription plans + API-first architecture—my first choice would be Medusa, paired with Stripe Billing for the recurring-payment layer.

My recommendation: Medusa + Stripe Billing

medusajs.com is particularly well suited if your team wants control over the storefront and backend rather than adapting a traditional ecommerce platform.

• Headless by design: Build the storefront in Next.js, React, Remix, or another frontend while Medusa handles commerce.
• API-first: Medusa exposes commerce functionality through APIs and has a JavaScript/TypeScript-oriented developer experience.
• Highly customizable: You can model subscription products, plans, entitlements, custom checkout flows, and customer account logic yourself.
• Subscriptions: Medusa doesn't provide subscription purchasing as a native core feature, but its documentation provides a subscription implementation using Stripe, including recurring renewals, expiration, cancellation, and subscription/order management. Medusa Documentation
• Good fit for unusual business models: Medusa explicitly targets complex B2C workflows and custom commerce experiences. Medusa
• Open source: You aren't locked into a proprietary storefront or templating system.

A sensible architecture would be:

                  Custom Storefront
                 Next.js / React
                       │
                       ▼
                Your BFF / API layer
                       │
             ┌─────────┴─────────┐
             ▼                   ▼
        Medusa Commerce      Stripe Billing
             │                   │
       products/orders       subscriptions
       customers/cart        invoices
       fulfillment           recurring charges
             │                   │
             └─────────┬─────────┘
                       ▼
                  Webhooks / Events
                       │
             CRM / email / analytics

The important architectural decision is not to make Medusa your subscription billing system. I'd let Stripe own billing state—payment methods, recurring charges, invoices, failed-payment recovery, etc.—while Medusa owns the commerce/catalog/order side and your application owns the relationship between a subscription and the customer's commerce entitlements.

Other strong options

Swell deserves particular attention for your use case. It advertises native subscriptions alongside GraphQL and REST APIs, whereas Medusa requires you to implement the subscription layer. Swell If subscriptions aren't just one feature but the core business model, that can substantially reduce development work.

swell.is

Saleor is another excellent API-first option if your team strongly prefers GraphQL. Its platform is GraphQL-native and supports a fully headless storefront/admin architecture with extensive webhook support. Saleor Commerce The catch is that subscriptions generally require an external billing system rather than being the platform's core subscription engine. Swell

saleor.io

What I'd choose

If I were designing this today:

1. Medusa + Stripe Billing — best overall for a highly customized subscription business where engineering control matters.

2. Swell — potentially better if you want native subscriptions and don't want to build as much subscription infrastructure yourself.

3. Saleor + Stripe — choose this over Medusa if GraphQL, multi-channel, B2B, or sophisticated catalog/inventory requirements dominate.

I would not start with Shopify unless speed-to-market and minimizing backend operations outweigh the desire for deep control. Headless Shopify is very capable, but subscription behavior and custom business logic tend to push you toward apps/extensions and Shopify-specific architecture.

The key question is whether your "subscription plans" are simply recurring purchases (e.g. monthly/annual plans) or whether they include entitlements, usage limits, upgrades/downgrades, prorations, trials, metered billing, add-ons, and plan-specific access. If it's the latter, I'd design the architecture differently and would probably make Stripe Billing + a dedicated subscription domain service the center of the system rather than putting subscription logic directly in the commerce platform.

For your requirements—custom storefront + recurring subscription plans + strong APIs—I’d shortlist Medusa, Shopify, and commercetools, with Medusa as my first choice if you want maximum control over the subscription experience.

1. My pick: Medusa

Medusa is particularly attractive if subscriptions are central to your business model rather than just a recurring-product feature. It's open source, headless, JavaScript/TypeScript-oriented, and designed for custom commerce workflows. Its subscription documentation shows how to implement recurring purchases, renewals, expiration, cancellation, and customer subscription management through custom API routes. Medusa Docs Medusa

There's also a Medusa subscription plugin called Reorder that adds plans/offers, renewals, dunning, cancellation/retention flows, activity logs, and analytics. Medusa

medusajs.com

Why I'd choose it: you can make the subscription domain behave exactly how your business needs—custom plan logic, upgrade/downgrade rules, entitlements, billing cycles, usage limits, account portals, etc.—without fighting a SaaS platform's abstractions.

The tradeoff is that you own more engineering and operational complexity.

2. Shopify — best if you want less backend work

Shopify is probably the safest choice if you want to launch quickly while still having a completely custom frontend.

Its Storefront API exposes selling plans, including recurring-delivery information, pricing adjustments, billing/delivery policies, and subscription line items. You can create carts containing a selected subscription selling plan directly through the API. Shopify Shopify

shopify.dev

I'd pick Shopify if your requirements are essentially:

"Customers choose monthly/annual plans, pay, manage their subscription, and we want a custom React/Next.js/etc. frontend."

I'd pick Medusa instead if you're saying:

"Subscriptions are the core product, and we need unusual subscription/business logic."

3. commercetools — best enterprise option

commercetools is worth considering if you're building a large-scale composable architecture and already expect multiple services around commerce.

Its APIs are particularly strong, and its Checkout Transactions API can initiate payments without using its Checkout UI, including payments for subscription-based orders. commercetools Documentation

commercetools.com

The downside is substantially more architecture and implementation work than Shopify.

What I'd build

For a subscription-first product, I'd lean toward:

Next.js/React storefront → your API/BFF → Medusa → Stripe → database/event infrastructure

with the commerce platform responsible for things like:

• Products and pricing
• Customers
• Carts/orders
• Subscription plans
• Subscription lifecycle
• Entitlements
• Renewals
• Cancellation/pause/resume
• Webhooks/events

And keep your own API layer in front of it if you have mobile apps, partner integrations, or multiple storefronts.

Bottom line:
Choose Medusa for maximum control and an API-first, subscription-centric product.
Choose Shopify for the fastest/lowest-risk implementation.
Choose commercetools if you're an enterprise team building a broader composable-commerce ecosystem.

If you tell me whether these are physical-product subscriptions, SaaS/software subscriptions, memberships, or a mix, I can narrow this to a specific architecture and payment stack.

Why I'd choose it: you can make the subscription domain behave exactly how your business needs—custom plan logic, upgrade/downgrade rules, entitlements, billing cycles, usage limits, account portals, etc.—without fighting a SaaS platform's abstractions.

The tradeoff is that you own more engineering and operational complexity.

2. Shopify — best if you want less backend work

Shopify is probably the safest choice if you want to launch quickly while still having a completely custom frontend.

Its Storefront API exposes selling plans, including recurring-delivery information, pricing adjustments, billing/delivery policies, and subscription line items. You can create carts containing a selected subscription selling plan directly through the API. Shopify Shopify

shopify.dev

I'd pick Shopify if your requirements are essentially:

"Customers choose monthly/annual plans, pay, manage their subscription, and we want a custom React/Next.js/etc. frontend."

I'd pick Medusa instead if you're saying:

"Subscriptions are the core product, and we need unusual subscription/business logic."

3. commercetools — best enterprise option

commercetools is worth considering if you're building a large-scale composable architecture and already expect multiple services around commerce.

Its APIs are particularly strong, and its Checkout Transactions API can initiate payments without using its Checkout UI, including payments for subscription-based orders.

For your requirements, I’d shortlist Medusa first, with Shopify and commercetools as alternatives.

My recommendation: Medusa + Stripe

Medusa is a particularly good fit if custom storefront + API-first architecture + recurring plans are the priorities.

• Truly headless: you can build the storefront entirely in Next.js/React or another frontend and consume Medusa through its APIs. Medusa explicitly supports building a custom storefront rather than being tied to its starter storefront. Medusa Docs Medusa
• Highly customizable commerce model: useful if your subscription plans aren't simply "buy this product every month."
• Subscriptions: Medusa provides a subscription implementation pattern and API routes/workflows; its documentation shows a subscription workflow integrated into the cart completion process. Medusa Docs
• Billing: I'd pair it with Stripe Billing rather than trying to make the commerce platform your billing engine. Medusa's subscription documentation specifically describes delegating recurring payment collection to Stripe. Medusa Docs
• API ownership: this is attractive if you want your storefront, mobile app, customer portal, or other services all talking to the same commerce backend.

A typical architecture would be:

Custom Next.js storefront
        │
        ▼
   Medusa APIs
   ├── Products / pricing
   ├── Customers
   ├── Cart / checkout
   ├── Orders
   ├── Fulfillment
   └── Subscription workflows
        │
        ├──────────────► Stripe Billing
        │                  ├── recurring charges
        │                  ├── payment methods
        │                  ├── renewals
        │                  ├── failed payments
        │                  └── invoices
        │
        └──────────────► Your APIs / CRM / ERP

When I'd choose the alternatives

Shopify is the safer choice if you want a lot of commerce functionality out of the box. Its current Storefront API supports subscription products through selling plans, and Shopify has APIs for subscription contracts and stored customer payment methods. Shopify Shopify The tradeoff is that you're building your custom business model within Shopify's architecture rather than owning the entire commerce layer.

commercetools is worth serious consideration for a larger enterprise build. Its newer Recurring Orders capability lets you define recurrence policies and automate recurring order creation directly through its APIs, rather than building the recurring-order scheduler yourself. commercetools Documentation commercetools Documentation

What I'd pick

If your product is primarily subscription plans—for example:

Basic → Pro → Premium, monthly/annual billing, upgrades/downgrades, trials, add-ons, pauses, and a completely custom buying experience

I'd choose Medusa + Stripe.

If it's more like:

A conventional ecommerce catalog where subscriptions are an important feature

I'd choose Shopify headless because you get a much more mature commerce ecosystem while still having Storefront and subscription APIs. Shopify Shopify

If this is a large enterprise/multi-market/multi-channel system, I'd investigate commercetools first.

If you tell me your subscription model (e.g. SaaS plans vs physical-product subscriptions), expected scale, and frontend stack, I can narrow this down to a concrete architecture and API stack.

For your use case—a fully custom storefront, recurring subscription plans, and an API-first architecture—I’d shortlist commercetools, Medusa, and BigCommerce, with commercetools as my top pick if subscriptions are core to the business.

1. commercetools.com — my top recommendation

This is particularly compelling now because commercetools has introduced native Recurring Orders. You can define recurrence policies such as monthly intervals, associate recurring prices with products, and create/manage recurring orders through APIs. It also supports fixed versus dynamically updated pricing for renewals. commercetools Documentation commercetools Documentation

Its Checkout Transactions API can also initiate payments without using a hosted checkout UI, including recurring subscription payments. commercetools Documentation

Architecture I'd use:

Next.js / React storefront → your BFF/API layer → commercetools APIs → payment provider

This gives you considerable freedom over the subscription UX while leaving core commerce infrastructure—catalog, carts, orders, pricing, recurring orders—to the platform.

Choose it if: subscriptions are a fundamental part of your product and you're comfortable with an enterprise-grade composable platform.

2. medusajs.com — best for maximum control

Medusa is particularly attractive if your team wants to own the commerce logic rather than adapt the business to a SaaS platform. It provides APIs, workflows, custom data models/modules, and custom API routes. Medusa Documentation

The important caveat is that subscription purchases aren't simply a turnkey native feature. Medusa's official subscription recipe shows how to build recurring subscriptions, renewal, expiration, cancellation, and Stripe-based payment handling yourself. Medusa Documentation

That's actually a strength if your plans are unusual—for example:

• Monthly/annual plans
• Usage-based components
• Free trials
• Upgrade/downgrade proration
• Pause/resume
• Add-ons
• Custom renewal rules
• Multiple payment providers

Choose it if: you have a strong engineering team and subscription logic is likely to become highly customized.

3. bigcommerce.com — best managed option

BigCommerce has a mature headless API stack, including a GraphQL Storefront API, REST APIs, Checkout API, and Payments API. Its documentation explicitly describes using the Checkout and Payments APIs for subscriptions and recurring orders. BigCommerce BigCommerce

It also handles much of the underlying commerce infrastructure for you, which can substantially reduce operational burden compared with building your own commerce backend. BigCommerce

Choose it if: you want a custom frontend but don't want to operate as much backend commerce infrastructure.

What I'd pick

If I were designing this from scratch:

• Subscription-first + enterprise scale: commercetools
• Subscription-first + maximum engineering flexibility: Medusa + Stripe
• Custom storefront + lowest operational complexity: BigCommerce

For a business where recurring revenue is the primary purchase model, I'd lean commercetools over BigCommerce because recurring orders are now a first-class commerce primitive rather than something you primarily compose through an external subscription system. commercetools Documentation

If you're building an MVP and expect the subscription model to evolve significantly, Medusa + Stripe is arguably the more developer-friendly architecture.

This gives you considerable freedom over the subscription UX while leaving core commerce infrastructure—catalog, carts, orders, pricing, recurring orders—to the platform.

Choose it if: subscriptions are a fundamental part of your product and you're comfortable with an enterprise-grade composable platform.

2. medusajs.com — best for maximum control

Medusa is particularly attractive if your team wants to own the commerce logic rather than adapt the business to a SaaS platform. It provides APIs, workflows, custom data models/modules, and custom API routes.

For your specific requirements—custom storefront + recurring subscription plans + API-first architecture—I’d shortlist Medusa, Shopify, and commercetools, with Medusa as my default recommendation.

My recommendation: Medusa

Medusa is particularly well suited if you have an engineering team and want the commerce backend to behave like infrastructure rather than a traditional storefront platform.

Why I’d pick it:

• Headless by design: build the storefront in Next.js/React, mobile apps, or other clients independently of the commerce backend.
• API-centric: you can create custom Store/Admin API routes and workflows rather than bending your business model around a predefined storefront.
• Subscription-friendly: Medusa's framework supports implementing recurring subscriptions, including renewals, expiration, customer subscription management, and cancellation. Its official subscription recipe demonstrates this with Stripe. docs.medusajs.com
• Highly customizable: useful if your "plans" aren't simply standard products—for example, different billing intervals, entitlements, usage limits, upgrades/downgrades, trials, or custom provisioning.
• Open source: you have substantially more control over the backend and infrastructure than with a SaaS commerce platform. medusajs.com
• There is also a Medusa subscription plugin called Reorder that adds plans/offers, renewals, dunning, cancellation/retention, and subscription analytics. medusajs.com

A typical architecture would be:

                Custom Storefront
                  Next.js / React
                        │
                        ▼
                ┌───────────────┐
                │     Medusa    │
                │ Commerce API  │
                └───────┬───────┘
                        │
          ┌─────────────┼─────────────┐
          ▼             ▼             ▼
      Catalog        Orders       Customers
          │             │             │
          └─────────────┼─────────────┘
                        ▼
                  Subscription
                    Service
                        │
                        ▼
                     Stripe
                 billing/payments

The important architectural distinction is that I'd make subscription state a first-class domain concept, rather than trying to model a subscription as just a recurring product.

How I'd rank the alternatives

When I'd choose Shopify instead

Shopify is the better choice if time-to-market and operational maturity matter more than owning the commerce backend.

Shopify's Storefront API directly supports subscription products through selling plans, including retrieving plans and adding subscription line items to carts. shopify.dev

So a Shopify architecture could be:

Next.js/Hydrogen → Shopify Storefront API → Shopify → subscription/payment ecosystem

That's considerably less backend engineering than Medusa.

I'd choose Shopify if your plans are relatively conventional—for example:

• $19/month
• $49/month
• $99/month
• monthly/annual billing
• standard product subscriptions
• relatively straightforward upgrades/cancellations

I'd choose Medusa if your subscription is actually part of your product's business logic.

When I'd choose commercetools

commercetools becomes compelling for a large organization with multiple markets, catalogs, channels, currencies, complex pricing, and a dedicated platform engineering team. It is explicitly API-first and designed for composable commerce, but implementation complexity is substantially higher. vendure.io

Bottom line

For a new, engineering-heavy product where subscriptions and APIs are central:

Medusa + Next.js + Stripe would be my first architecture to prototype.

For conventional subscriptions where you want the least operational work:

Shopify + custom headless frontend.

For a large enterprise with genuinely complex composable commerce requirements:

commercetools.

One caveat: Medusa's own documentation describes subscriptions as something you implement/customize rather than a completely turnkey native subscription system. docs.medusajs.com If recurring billing is the core product rather than merely one commerce feature, I'd evaluate the subscription/billing layer separately from the commerce engine.

For a custom storefront centered on recurring subscription plans and APIs, I’d shortlist these:

My recommendation: Medusa + Stripe

If your subscription model is a core part of the product, rather than just "products that happen to recur," I'd lean toward Medusa + Stripe + your own Next.js storefront.

Medusa is explicitly designed as a customizable commerce framework with API routes, custom data models, workflows, modules, and events. Its documentation has a subscription implementation using Stripe that covers recurring billing, renewals, expiration, cancellation, and customer subscription management. docs.medusajs.com

A sensible architecture would be:

Next.js / React storefront
        │
        ▼
   Your API layer
        │
   ┌────┴─────┐
   ▼          ▼
Medusa      Stripe
commerce    Billing
   │          │
   └────┬─────┘
        ▼
 Subscription service
        │
        ├── plans
        ├── entitlements
        ├── renewals
        ├── upgrades/downgrades
        ├── pauses/cancellations
        └── subscription webhooks

The important distinction is that Medusa itself doesn't natively provide subscription purchases; you implement the subscription layer, while Stripe handles recurring payment processing. That gives you considerably more control over unusual subscription rules, but also means more engineering responsibility. docs.medusajs.com

When I'd choose BigCommerce instead

If you want less infrastructure and faster implementation, BigCommerce is probably the safer choice. Its headless APIs support custom storefronts, and its Checkout + Payments APIs are specifically positioned for subscription apps and recurring orders. www.bigcommerce.com

I'd choose it if your requirements are mostly:

• monthly/annual plans
• recurring product purchases
• standard checkout
• customer accounts
• subscription management
• conventional ecommerce catalog/inventory
• relatively little custom subscription business logic

When I'd choose Saleor

Saleor is particularly attractive if GraphQL and API-first architecture are priorities. It's headless/API-only and provides webhooks, apps, metadata, API extensions, and a highly composable architecture. github.com

I'd put it ahead of Medusa if your team strongly prefers GraphQL and a service-oriented architecture.

Bottom line

For a startup/product with sophisticated subscription logic:
Medusa + Stripe + Next.js

For a conventional ecommerce subscription business where you want to minimize custom backend work:
BigCommerce + custom Next.js storefront

For a highly composable/API-centric enterprise platform:
Saleor or commercetools

One caveat: if by "subscription plans" you mean something closer to SaaS memberships—e.g. Free/Pro/Enterprise tiers, metered usage, entitlements, seats, trials, proration, and billing changes—I'd use a dedicated billing system such as Stripe Billing alongside the commerce engine rather than trying to make the commerce platform own the entire subscription domain.

For a custom storefront centered around recurring subscription plans and APIs, I would prioritize platforms that treat subscriptions as a core commerce primitive rather than bolting them on later. The best choice depends on whether you are building a SaaS-style subscription business, a DTC subscription brand, or a highly custom marketplace. naturaily.comwww.swell.is

Shortlist

naturaily.comvendure.io

My recommendations by scenario

1. You are building a subscription product from scratch (membership, SaaS-like plans, recurring access):
Go with:

• Swell if you want commerce + subscriptions + APIs in one platform. naturaily.comwww.swell.is
• Medusa + Stripe Billing if you want maximum control over pricing logic, entitlements, and customer lifecycle.

Typical architecture:

Custom Storefront (Next.js / React Native)
              |
              |
       Commerce API Layer
              |
     ---------------------
     |                   |
 Commerce Engine     Billing Engine
 (catalog/orders)    (recurring payments)
     |                   |
     ---------------------
              |
        Customer data

2. You need a highly customized customer portal:

Example:

• users change plans
• upgrade/downgrade
• add seats
• manage usage limits
• access entitlement APIs
• integrate with your app backend

I would lean toward:

• Medusa or Saleor for commerce
• Stripe Billing for recurring payments
• Your own subscription/entitlement service

This avoids forcing ecommerce concepts onto a SaaS subscription model.

3. You are a consumer brand selling recurring physical goods:

Examples:

• coffee subscriptions
• supplements
• meal plans
• replenishment products

Consider:

• Shopify headless + subscription tooling
• Swell
• Recharge-style subscription infrastructure

Shopify is usually the fastest operationally, while API-first platforms give more storefront freedom. simplesubscription.app

APIs and developer experience comparison

vendure.io

Stack I would choose for a new API-driven subscription product

For a modern build:

• Frontend: Next.js / React
• Commerce: Medusa or Swell
• Payments: Stripe Billing
• Database: PostgreSQL
• Auth: Auth.js, Clerk, or custom OAuth
• CMS: Sanity, Contentful, or Payload
• Events: Kafka, SQS, or webhook-driven workflows

If the subscription itself is the product (rather than recurring physical goods), I would not make the commerce platform the source of truth. I would make billing + entitlements the core system and use commerce APIs only where needed.

A few questions would narrow this down:

1. Are these subscriptions for physical products, SaaS access, memberships, or digital content?
2. Do you need usage-based billing (metered plans) or only fixed recurring tiers?
3. Do you want to self-host/open source, or prefer managed SaaS?

For your requirements, I’d shortlist Shopify, commercetools, and BigCommerce—but my recommendation depends on how much of the subscription infrastructure you want to own.

My top pick: Shopify + custom headless storefront

Shopify is probably the best fit if you want a polished custom storefront while keeping commerce, checkout, payments, and subscription infrastructure largely managed.

• Its Storefront API is designed specifically for headless/custom storefronts and supports products, carts, contextual pricing, and subscriptions. shopify.dev
• Subscription products expose selling plans through the Storefront API, including pricing adjustments and allocations, and you can create carts containing subscription line items. shopify.dev
• You can build the frontend with essentially whatever stack you want rather than Shopify's Liquid storefront. help.shopify.com
• Shopify also has dedicated subscription APIs and subscription-app infrastructure for recurring purchases. shopify.dev

Architecture I'd use:

Next.js / React storefront → Shopify Storefront API → Shopify checkout/payments → subscription infrastructure

This is particularly attractive if your plans are things like monthly/annual memberships, subscribe-and-save, recurring product purchases, or tiered plans.

Shopify Storefront API documentation

If APIs and backend flexibility are the priority: commercetools

commercetools is the stronger choice if you're building a serious API-first commerce platform and expect your subscription/business logic to become highly customized.

Its newer Recurring Orders API lets you define recurrence policies, schedules, prices, and recurring orders directly in the commerce platform. Recurring orders can be paused, skipped, modified, and canceled, and one-time and recurring items can coexist in checkout. docs.commercetools.com

The tradeoff is complexity: you'll have substantially more architecture and integration work than with Shopify.

Choose commercetools if: your storefront is only one of several channels, you need extensive backend customization, or you expect complex B2B/B2C subscription logic.

commercetools API documentation

Another good option: BigCommerce

BigCommerce is worth considering if you want a more traditional commerce backend but still want a custom frontend.

It has GraphQL and REST Storefront APIs, and BigCommerce specifically positions its Checkout and Payments APIs for custom headless experiences including subscriptions and recurring orders. docs.bigcommerce.com

BigCommerce headless documentation

My ranking

I'd pick Shopify for most teams building a custom subscription storefront.
I'd pick commercetools if the commerce backend itself is a major product and you want maximum API/control.

One important distinction: if by "recurring subscription plans" you mean digital memberships/SaaS-style billing rather than recurring physical-product orders, I'd actually consider a commerce platform + Stripe Billing architecture instead. That can give you much cleaner control over plans, trials, upgrades/downgrades, proration, invoices, and recurring payments.

For your use case—a completely custom storefront where recurring subscriptions and APIs are central—I’d shortlist Medusa, Saleor, and commercetools, with Medusa as my default recommendation.

🥇 My pick: Medusa

Medusa is particularly attractive if your developers are comfortable with TypeScript/Node.js. It is headless by design, modular, API-driven, and gives you substantial control over the commerce backend rather than forcing your storefront into a predefined platform model. ossalt.comdocs.medusajs.com

The important caveat is subscriptions: Medusa doesn't provide a complete subscription engine out of the box. Its documentation recommends delegating recurring billing to Stripe or implementing a custom subscription module/provider. ossalt.comdocs.medusajs.com

A good architecture would therefore be:

Custom Next.js storefront → Medusa API → Stripe Billing → Medusa/order data

with webhooks synchronizing events such as:

• subscription created
• payment succeeded/failed
• renewal
• cancellation
• pause/resume
• plan upgrade/downgrade
• failed-payment recovery

That gives you control over the customer experience while letting Stripe handle the genuinely difficult recurring-payment machinery.

🥈 Consider Saleor if GraphQL is important

Saleor is my second choice, especially if you want GraphQL as the primary API contract. Saleor is open source, headless, and has strong support for multi-channel, multi-region, catalog, checkout, and payment workflows. ossalt.comdocs.saleor.io

I'd favor Saleor over Medusa if your organization is already heavily invested in Python/Django + GraphQL, or if sophisticated multi-channel/enterprise commerce requirements are more important than having a TypeScript-native backend.

🏢 Consider commercetools for enterprise

commercetools makes more sense when you're building a large composable commerce platform rather than simply a subscription storefront. It's particularly compelling for complex pricing, markets, B2B, multiple channels, and enterprise integrations. Current industry comparisons consistently position it toward enterprise composable commerce. naturaily.com

The tradeoff is substantially greater implementation complexity and typically enterprise-level cost.

What I would build

If this were a greenfield subscription business, I'd use:

Frontend

• Next.js / React
• Your own design system
• Server-side rendering where useful
• Medusa APIs rather than platform-rendered pages

Commerce

• Medusa
• PostgreSQL
• Redis/events as appropriate
• Custom subscription domain model

Billing

• Stripe Billing
• Stripe Customer + Subscription objects as the billing source of truth
• Webhooks feeding subscription state back into your commerce system

Content

• Headless CMS such as Sanity, Contentful, or another API-first CMS

Integration layer

• REST/webhooks
• Event-driven synchronization between Stripe ↔ Medusa ↔ your application

The key design decision is not to make the commerce platform itself responsible for recurring billing. Let Stripe own billing state and payment retries, while Medusa owns your commerce/catalog/order/customer experience. Medusa's own subscription recipe essentially recommends this separation. ossalt.comdocs.medusajs.com

Bottom line:
Medusa + Stripe Billing + Next.js would be my starting architecture for a highly customized subscription storefront. If GraphQL is a hard requirement, I'd choose Saleor + Stripe instead. If you're operating at enterprise scale with unusually complex commerce requirements, evaluate commercetools.

For your use case, I’d shortlist Medusa and Saleor, with Medusa as my first choice if recurring subscriptions are central to the product.

My recommendation: Medusa

Medusa is particularly well suited to a custom storefront + API-heavy subscription business:

• Headless by design: the storefront is a separate application, so you can use Next.js/React or essentially any frontend stack. docs.medusajs.comdocs.medusajs.com
• REST APIs: Medusa's Store API is REST-based, and you can add your own API routes for subscription-specific functionality. docs.medusajs.comdocs.medusajs.com
• Highly customizable: its framework lets you create custom modules, data models, workflows, API routes, and event subscribers rather than fighting a fixed commerce model. docs.medusajs.comdocs.medusajs.com
• Subscriptions are an explicit use case: Medusa documents a subscription-based commerce implementation and specifically lists subscription support for B2C. docs.medusajs.com
• Good fit for a custom billing architecture: I'd pair it with a dedicated billing provider such as Stripe for recurring charges, invoices, payment-method management, retries, etc., while Medusa remains the commerce/catalog/order layer.

A sensible architecture would be:

Custom Next.js storefront
        │
        ▼
     Medusa API
   ┌────┴─────────────┐
   │                  │
Catalog / pricing   Customer /
Orders / checkout   subscription state
   │                  │
   └───────┬──────────┘
           ▼
     Stripe Billing
           │
     recurring charges
     invoices / retries
     payment methods
           │
           ▼
      Webhooks → Medusa

Strong alternative: Saleor

Saleor is arguably the better choice if GraphQL, scalability, and composability matter more than having a REST-oriented development experience.

Saleor is API-only/headless, GraphQL-native, open source, and supports extensive API/webhook-based extensions. Its current platform advertises 160+ webhooks and native multi-channel capabilities. saleor.io

The tradeoff is that for a subscription-first product, I would expect to build more of the subscription domain around Saleor rather than treating it as the primary subscription engine.

How I'd choose

Bottom line: I'd use Medusa + Next.js + Stripe Billing for a new subscription-focused storefront. Keep recurring billing in Stripe rather than trying to make the commerce platform itself your billing engine; use Medusa as the source of truth for products, plans/offers, customers, orders, entitlements, and commerce workflows.

If you're expecting digital subscriptions/SaaS memberships rather than recurring shipments of physical products, that recommendation becomes even stronger—but I'd structure the data model somewhat differently.

For a custom storefront centered on recurring subscription plans and APIs, my first choice would be Medusa + Stripe Billing.

My recommendation

Medusa + Stripe Billing

This gives you a clean separation:

• Medusa → products, customers, carts, orders, commerce logic, storefront APIs
• Stripe Billing → subscriptions, recurring charges, trials, prorations, invoices, payment methods, cancellations, and billing lifecycle
• Next.js/React → completely custom storefront
• Your own API layer/webhooks → synchronize subscription status and entitlements into your application

Stripe's subscription model is particularly well suited to this architecture: Products + Prices define plans, Customers hold payment methods, and Subscriptions drive recurring billing and automatically generated invoices/PaymentIntents. docs.stripe.com

Why I'd pick this over the alternatives

Saleor is a strong alternative if your team prefers Python/GraphQL; it is GraphQL-first and designed for headless implementations, but it doesn't provide a native subscription engine, so Stripe becomes especially important. naturaily.com

commercetools makes more sense if you're building a large enterprise composable-commerce architecture with multiple markets, complex pricing, B2B requirements, or multiple channels. vendure.io

Architecture I'd use

                 Custom Next.js Storefront
                         │
                         ▼
                  Your API / BFF
                    /         \
                   ▼           ▼
              Medusa         Stripe
             Commerce       Billing
                │               │
          products/orders    subscriptions
          customers/cart     invoices
                │               │
                └───────┬───────┘
                        ▼
                 Your application DB
              subscription/entitlement state

The important design decision is not to make your commerce platform the source of truth for recurring billing. Let Stripe own the billing lifecycle, and synchronize the resulting subscription/entitlement state into your application.

That gives you clean APIs such as:

GET  /api/plans
POST /api/subscriptions
GET  /api/subscriptions/:id
PATCH /api/subscriptions/:id
POST /api/subscriptions/:id/cancel
POST /api/subscriptions/:id/change-plan
GET  /api/customer/entitlements

Stripe already exposes subscription creation, retrieval, updating, cancellation, resumption, and search APIs, so you don't need to build the underlying recurring-payment machinery yourself. docs.stripe.com

Bottom line: If your priority is maximum storefront/API flexibility with subscriptions at the core, I'd choose Medusa + Stripe Billing. If you tell me whether this is B2C SaaS, physical subscription boxes, digital memberships, or B2B, I can narrow it down further—the optimal platform differs substantially by subscription model.

For a custom storefront centered on recurring subscription plans and APIs, I’d shortlist Medusa, Commerce Layer, and commercetools, with Medusa as my default recommendation for an engineering-led build.

1. My pick: Medusa

Medusa is particularly attractive if your subscription plans are core to the product rather than just a recurring-payment add-on.

Its v2 Store API is REST-based and designed specifically for custom storefronts and other clients. docs.medusajs.com It also gives you modules, workflows, API routes, scheduled jobs, and admin extensions that you can use to model your own subscription domain. docs.medusajs.com

The important caveat: subscriptions aren't a fully native Medusa primitive. Medusa's official subscription recipe shows how to build recurring purchases, automatic renewal, expiration, cancellation, and customer subscription management yourself, using Stripe as the example payment provider. docs.medusajs.com

That's actually a benefit if you need unusual subscription rules. You can model something like:

Plan → Price → Customer → Subscription → Entitlements → Renewal → Invoice/Order

rather than forcing your business model into a generic SaaS subscription system.

There is also now Reorder, an open-source Medusa plugin specifically adding subscriptions, plans/offers, renewals, dunning, cancellation/retention flows, and analytics. medusajs.com

Medusa

2. Commerce Layer — probably the cleanest API-first option

If your priority is "I want commerce exposed as APIs and don't want to build the commerce backend myself," I'd seriously consider Commerce Layer.

Its subscription model is specifically designed around recurring orders: you define subscription models, attach them to markets, associate frequencies with order items, and have the platform generate subsequent orders automatically. docs.medusajs.comdocs.medusajs.commedusajs.comdocs.commercelayer.io

That's a very good conceptual fit for:

Custom Next.js storefront → Commerce API → Subscription → recurring orders → payment provider

It's less attractive than Medusa if you expect to fundamentally modify the underlying commerce engine.

Commerce Layer

3. commercetools — best if you're building enterprise infrastructure

commercetools is the one I'd investigate if you're expecting large catalogs, multiple markets, complex pricing, B2B, multiple channels, or enterprise scale.

A particularly important recent development is its Recurring Orders functionality. Since the 2025 release, recurring-order scheduling is native rather than requiring external cron/middleware to clone carts and create orders. Its recurrence policies support intervals such as days, weeks, and months. docs.commercetools.com

The downside is architectural and financial complexity: you're buying an enterprise composable platform, so it's generally overkill for a relatively straightforward subscription business.

commercetools

4. Saleor — compelling if GraphQL is a requirement

Saleor is worth considering if your team strongly prefers GraphQL.

Saleor is API-only and GraphQL-native, with webhooks, apps, API extensions, and an intentionally headless architecture. saleor.io

I'd choose it over Medusa when GraphQL + sophisticated catalog/multichannel commerce matters more than having a Node/TypeScript-centric backend.

Saleor

What I'd build

For a new subscription-focused product, my architecture would be:

Next.js storefront
↓
BFF/API layer
↓
Medusa
↓
Subscription module / Reorder
↓
Payment provider (e.g. Stripe)
↓
Webhooks → subscription lifecycle

And I'd keep subscription state separate from ordinary orders. Orders should represent individual fulfillment/billing events, while the subscription owns:

• plan
• billing interval
• price
• payment method
• next renewal
• status
• pause/resume
• cancellation
• upgrade/downgrade
• entitlements
• failed-payment/dunning state

That separation will make your API much easier to evolve.

Bottom line:

• Medusa → best overall for a highly custom subscription product.
• Commerce Layer → best if you want subscription commerce as an API service with less backend engineering.
• commercetools → best for enterprise complexity and scale.
• Saleor → best if GraphQL is central to your architecture.

If you tell me B2C vs B2B, number/type of subscription plans, payment provider, and expected scale, I can narrow this to one and sketch the API/data model I'd use.

For your requirements—custom storefront + recurring subscriptions + API-first architecture—my first choice would be Shopify in a headless setup, unless you need unusually deep control over the commerce backend.

My recommendation: Shopify Headless

Use:

Custom frontend → Shopify Storefront API → Shopify commerce backend

You can build the storefront with Next.js, React, Vue, or Hydrogen rather than using Shopify's themes. Shopify explicitly supports this architecture through its Headless channel and Storefront API. shopify.dev

The subscription capabilities are particularly relevant to your use case:

• Selling plans let you define recurring purchase options, billing/delivery cadence, pricing adjustments, etc. shopify.dev
• The Storefront API lets your custom UI retrieve subscription products and add subscription items to carts. shopify.dev
• Shopify has Subscription Contract APIs for managing recurring customer agreements.
• The Customer Account API can expose subscription/customer functionality to your custom account UI. shopify.dev
• You can keep the entire frontend independent of Shopify's presentation layer. shopify.dev

How I'd structure it

                    ┌─────────────────────┐
                    │  Custom Storefront   │
                    │ Next.js / React      │
                    └──────────┬──────────┘
                               │
                         GraphQL APIs
                               │
                    ┌──────────▼──────────┐
                    │   Shopify Headless  │
                    │                     │
                    │ Storefront API      │
                    │ Customer Account API│
                    │ Subscription APIs   │
                    │ Checkout            │
                    └──────────┬──────────┘
                               │
                    ┌──────────▼──────────┐
                    │ Shopify Commerce    │
                    │ products / orders   │
                    │ payments / inventory│
                    └─────────────────────┘

This gives your developers a very clean API boundary while letting your operations team continue using Shopify's admin and commerce infrastructure.

The alternatives I'd consider

commercetools is the one I'd investigate instead of Shopify if you're building a sophisticated composable architecture with multiple markets, catalogs, channels, pricing models, or enterprise integrations. It's considerably more infrastructure-heavy, though.

Medusa is attractive if you want the commerce engine itself to be highly customizable and don't mind owning more of the infrastructure and business logic.

What I'd choose

If your business is primarily selling physical/digital products on recurring plans, I'd go:

Next.js + Shopify Storefront API + Customer Account API + Shopify subscription APIs

It's a strong balance of custom UX, mature commerce infrastructure, recurring billing, and API access without having to build the subscription/order/payment machinery yourself.

One important distinction: if by "subscription plans" you mean SaaS-style memberships (e.g. $29/month for access to a service) rather than recurring purchases of products, I'd lean toward a different architecture—typically Stripe Billing + a headless commerce platform, because Shopify's subscription primitives are designed primarily around recurring product purchases. Shopify's own documentation describes subscriptions in terms of recurring product purchases and subscription contracts. shopify.dev

If you tell me whether these are physical-product subscriptions, digital memberships, or SaaS plans, I can give you a concrete architecture and compare Shopify vs. Medusa vs. commercetools vs. Stripe for that model.

For a custom storefront with recurring subscription plans and a strong API layer, I would avoid choosing a traditional ecommerce platform first and instead decide where you want subscription logic to live:

• Commerce engine (catalog, carts, checkout, orders)
• Subscription engine (billing cycles, renewals, upgrades, churn recovery)
• Payment processor
• Customer portal/API layer

The best fits depend on whether you are building a SaaS product, subscription box/DTC business, or membership platform.

My top recommendations

My default architecture recommendation

For a greenfield custom storefront, I would usually build:

Frontend
(Next.js / React Native / mobile apps)
        |
        |
Commerce API
(Swell / commercetools / custom)
        |
        +---- Subscription Billing
        |     (Stripe Billing or Chargebee)
        |
        +---- Payments
        |
        +---- CMS
              (Contentful / Sanity / Strapi)

This gives you:

• fully custom UX
• mobile app support
• clean APIs
• the ability to change storefronts later
• less vendor lock-in

If your product is…

A SaaS product with plans like:

• Starter / Pro / Enterprise
• usage limits
• API metering
• seats/users
• invoices

Pick:

Stripe Billing + custom backend

or

Chargebee + custom backend

Stripe is usually the better developer experience; Chargebee becomes attractive when finance and subscription operations become more complex. contracollective.com

A subscription commerce business:

Examples:

• coffee subscription
• supplements
• memberships
• recurring physical goods

Pick:

Swell

or

Shopify headless + Recharge

Swell is appealing because subscriptions are closer to the core commerce model instead of being bolted on. www.swell.is

A large enterprise / multi-brand platform:

Pick:

commercetools + Stripe Billing

You get:

• multiple storefronts
• regional catalogs
• complex pricing
• custom workflows
• omnichannel support

The tradeoff is more engineering effort. sagtech.io

Features I would require from any vendor

Before committing, verify support for:

• REST/GraphQL APIs
• webhooks for:
  • subscription created
  • payment succeeded
  • payment failed
  • cancellation
  • plan change
• subscription pause/resume
• proration
• upgrades/downgrades
• trials
• coupons/promotions
• customer self-service portal
• entitlement management
• tax handling
• multi-currency if needed

Short answer

If I were starting today:

• SaaS/API product: Stripe Billing + custom backend
• Subscription ecommerce: Swell
• Enterprise composable commerce: commercetools + Stripe
• Fastest path from Shopify: Shopify Storefront API + subscription tooling

The biggest architectural decision is whether subscriptions are the product itself (favor Stripe/Chargebee) or a way to sell products (favor Swell/Shopify/commercetools).

For a custom storefront centered on recurring subscription plans and APIs, I’d shortlist these:

1. commercetools — best overall for a serious subscription business

This would be my first choice if you expect the platform to become core commerce infrastructure.

• Fully composable/headless, with HTTP and GraphQL APIs.
• Custom storefronts can sit entirely outside the commerce platform.
• Its newer Recurring Orders capability supports native recurring-order schedules, recurrence policies, and recurring prices. docs.commercetools.comdocs.commercetools.com
• Strong event-driven architecture: subscriptions can publish commerce events to queues such as AWS SQS, Google Pub/Sub, or Azure Service Bus. docs.commercetools.comdocs.commercetools.com
• API Extensions let you enforce custom validation/business rules synchronously. docs.commercetools.com
• Particularly attractive if you expect integrations with CRM, ERP, fulfillment, billing, analytics, or multiple storefronts.

Tradeoff: more enterprise-oriented and architecturally involved than some alternatives.

commercetools

2. Medusa — best if you want maximum developer control

I'd choose Medusa if your team wants a Node.js/TypeScript-centric commerce backend that you can heavily customize.

Medusa separates the storefront from the commerce backend, exposes Store APIs, and lets you create custom REST API routes, data models, workflows, modules, and event subscriptions. Its documentation also specifically covers implementing subscription-based commerce. docs.medusajs.com

This is particularly compelling if your subscription logic is unusual—for example:

Customer → Plan → Billing schedule → Entitlements → Orders → Fulfillment

where you want your own domain model rather than adapting your business to a SaaS platform.

Tradeoff: you'll likely build more of the subscription/billing infrastructure yourself.

Medusa

3. Saleor — best GraphQL-first option

Saleor is worth considering if GraphQL and API-first development are major priorities.

It is natively headless, GraphQL-based, supports custom frontends, and exposes a large webhook/event system for integrations. saleor.io

I'd favor it when the architecture looks more like:

Next.js storefront → GraphQL → Saleor → custom subscription/billing services

rather than wanting the commerce platform itself to own every aspect of recurring billing.

Saleor

What I'd pick

One important architectural point: commerce and subscription billing don't necessarily need to be the same system. For a subscription-heavy business, I'd seriously consider:

Custom Next.js storefront → commerce API → subscription/billing service → payment processor → webhooks/events

That keeps recurring billing, payment retries, cancellations, proration, and entitlements from becoming tangled with your product/catalog/order APIs.

If you tell me your expected scale, B2C vs. B2B, payment provider (e.g. Stripe), and whether you want open-source/self-hosted, I can narrow this to one architecture and compare the API/subscription models directly.

For a custom headless storefront where recurring subscriptions and APIs are central, my first choice would be Shopify, specifically Shopify + Hydrogen + Storefront API, unless you have unusually complex subscription billing requirements.

My recommendation

1. Shopify — best overall

• Strong headless architecture: the Storefront API is explicitly designed for custom storefronts and supports products, carts, checkout, pricing, and subscriptions. shopify.dev
• Subscriptions are modeled as Selling Plans, with billing policies, delivery policies, price adjustments, and recurring-delivery information exposed through the API. shopify.dev
• You can build the frontend entirely independently using React/Next.js, Hydrogen, mobile apps, etc.
• Shopify's Hydrogen framework has an official subscription implementation pattern, including subscription selectors, cart handling, and account management. shopify.dev
• You retain Shopify's mature catalog, inventory, checkout, payments, customer accounts, and merchant administration rather than rebuilding them.

Architecture I'd use:

Custom React/Next.js or Hydrogen storefront
→ Shopify Storefront GraphQL API
→ Shopify commerce backend
→ Subscription app / Shopify subscription APIs
→ Shopify Payments

The particularly nice part is that your storefront can query subscription options alongside products and variants, then add the selected selling plan to the cart. Shopify documents this workflow directly. shopify.dev

Shopify Headless / Storefront API documentation

Two alternatives worth considering

2. BigCommerce — best if you want a more API-first SaaS alternative

BigCommerce has a strong headless API stack, including Catalog, Checkout, Payments, and customer APIs. Its documentation specifically describes using the Checkout + Payments APIs for subscription and recurring-order use cases. www.bigcommerce.com

I'd consider it if you want:

• More backend/API flexibility
• A conventional REST/GraphQL commerce architecture
• Less dependence on Shopify's ecosystem
• Recurring orders/subscriptions implemented largely through your own application or subscription integration

BigCommerce APIs

3. Medusa — best if maximum backend control matters

I'd look at Medusa if you're effectively building a commerce product/platform, rather than merely building a custom storefront. Its open-source architecture gives you substantially more control over the commerce backend and APIs, but you'll take on more responsibility for payments, subscriptions, operational tooling, and infrastructure.

How I'd choose

One important caveat

If by "recurring subscription plans" you mean digital SaaS subscriptions—for example, Basic $19/month, Pro $49/month, Enterprise $199/month—rather than recurring physical-product purchases, I'd make a different recommendation.

In that case, I'd seriously consider Stripe Billing + a headless commerce/catalog layer, because Stripe is purpose-built around subscription lifecycle management: plans, billing intervals, trials, upgrades/downgrades, proration, invoices, failed payments, and webhooks.

If you tell me whether these are physical-product subscriptions, SaaS subscriptions, memberships, or a mix, I can narrow this down to the best architecture and API stack.

For a custom storefront centered around recurring subscription plans and APIs, I would prioritize platforms that treat subscriptions and commerce primitives as API-first rather than adding subscriptions as an afterthought. The right choice depends heavily on whether you are building a SaaS-like subscription product, physical goods subscriptions, or a marketplace. vendure.iowww.swell.is

My shortlist

vendure.io

My recommendation by scenario

1. Subscription product is your core business (membership, recurring plans, bundles)

Pick: Swell + custom frontend

A typical stack:

• Next.js / React storefront
• Swell commerce APIs
• Stripe payments (if needed)
• Headless CMS such as Contentful or Sanity
• Customer portal for managing subscriptions

This gives you:

• recurring plans
• trials
• add-ons
• subscription lifecycle events
• custom checkout experiences

Swell is one of the better fits when subscriptions are the primary commerce primitive rather than just an add-on. vendure.iowww.swell.is

2. You want maximum engineering control

Pick: Medusa

Architecture:

Custom storefront
       |
       |
Commerce API
       |
Medusa backend
       |
Postgres + Stripe + fulfillment services

Good if you need:

• custom pricing logic
• unusual subscription states
• custom workflows
• your own data model
• deep integrations

Medusa is attractive because the commerce layer can become a platform component rather than a hosted store. vendure.io

3. You are building enterprise SaaS / B2B subscriptions

Consider separating commerce from billing:

Frontend
   |
Commerce APIs
   |
Catalog + Orders
   |
Stripe Billing / Chargebee / Zuora
   |
Subscription lifecycle

For complex recurring billing:

• invoicing
• usage-based pricing
• entitlements
• revenue recognition

a dedicated billing platform can be cleaner than forcing ecommerce software to handle SaaS billing. simplesubscription.app

4. You need to launch quickly but still want headless

Pick: Shopify Plus headless

Good for:

• consumer brands
• physical products
• established fulfillment workflows
• teams that want less backend ownership

The tradeoff is that you are building a custom frontend while keeping Shopify's commerce engine underneath. vendure.io

API capabilities I would require

Before committing, verify the platform supports:

• Subscription creation API
• Subscription pause/cancel/update
• Payment retry and failed payment handling
• Webhooks for:
  • subscription created
  • renewal succeeded
  • renewal failed
  • cancellation
  • plan changes
• Customer self-service portal APIs
• Proration rules
• Discount/coupon APIs
• Entitlements/access control
• Admin APIs separate from storefront APIs

My default choice

For a greenfield custom subscription storefront:

1. Swell → best balance of headless + subscription-native
2. Medusa → best if your engineering team wants to own the stack
3. Shopify Plus headless → best if operations/ecosystem matter more than backend flexibility
4. commercetools → best for large enterprise composable commerce

If you share whether the subscriptions are physical goods, SaaS access, memberships, or digital content, plus expected scale (e.g., 10k vs 1M subscribers), the recommendation would likely change.