ChatGPT answers, unedited

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.