ChatGPT answers, unedited

If subscription boxes + recurring billing are core to the business, I’d narrow it to WooCommerce vs. Medusa, rather than choosing purely on “best open-source ecommerce platform.”

My recommendation: WooCommerce

For a subscription-box business, I’d pick WooCommerce if your priority is getting a reliable subscription business running with the least custom engineering.

Why:

• Subscriptions are a mature use case. WooCommerce has a large ecosystem of extensions for recurring products, renewals, failed-payment handling, coupons, shipping, taxes, etc.
• Huge ecosystem. Compared with newer headless platforms, there are substantially more existing integrations and developers available. WPBundle ossium
• Self-hosting is straightforward: WordPress + WooCommerce + your payment provider.
• You can still build a custom React/Next.js storefront later if you don't want the traditional WordPress frontend.
• For a subscription box, the boring stuff—renewals, order generation, customer account management, payment failures—is more important than having an elegant commerce API.

The downside is that WordPress/WooCommerce can become plugin-heavy and require more maintenance as you scale.

When I'd choose Medusa instead

Choose Medusa if you're a developer-heavy team and want to build the subscription system as part of your application.

Medusa is a particularly attractive choice if you're already using TypeScript/Node.js + Next.js. Its architecture is much more natural for a custom subscription-box experience than modifying WordPress. However, subscriptions aren't native: Medusa's own documentation describes implementing subscriptions as a customization, including recurring renewals and Stripe integration. Medusa Docs

So your architecture would look roughly like:

Next.js storefront
       │
       ▼
    Medusa
       │
   ┌───┴────┐
   │        │
Stripe   Your subscription service
   │        │
   └───┬────┘
       ▼
 recurring payments
       │
       ▼
 subscription → order → fulfillment

That's more work initially, but gives you much more control over things like:

• "skip this month's box"
• swap products
• different box sizes
• pause/resume
• prepaid 3/6/12-month plans
• renewal-date changes
• add-ons
• build-your-own-box
• subscription-specific shipping logic

What about Saleor?

Saleor is excellent technically—GraphQL-first, headless, composable, and explicitly designed for self-hosting. Saleor Commerce GitHub

But I wouldn't make it my first choice for a subscription-first business. Recurring billing isn't a first-class native feature, so you'd still be building the subscription/payment layer yourself. Devioand

My ranking for your specific use case

The broader 2026 landscape similarly puts WooCommerce toward the ecosystem/merchant end and Medusa/Saleor toward developer-oriented headless commerce. OpenReplay Blog Open Source Projects

If you tell me your expected scale (e.g. 500 vs. 50,000 subscribers), tech stack, and whether you need customers to customize/skip/swap boxes, I can recommend the architecture—not just the platform—and specifically compare WooCommerce + Subscriptions vs. Medusa + Stripe.

For a subscription box service with recurring billing, I would not choose purely based on “best ecommerce platform.” Subscriptions change the architecture: you need billing cycles, renewals, failed payment recovery, customer self-service, plan changes, skips, swaps, fulfillment scheduling, and inventory forecasting.

My shortlist:

www.wpbundle.com

My recommendation

1. If you want to launch a real business quickly: WooCommerce

Use:

• WordPress + WooCommerce
• WooCommerce Subscriptions (paid extension)
• Stripe Billing or Stripe payments
• Custom fulfillment logic via hooks/webhooks

Why:

• Subscription commerce is a solved problem in this ecosystem.
• You get coupons, landing pages, SEO, email integrations, reviews, affiliates, etc.
• You can hire WooCommerce developers easily.
• You can still build a custom frontend later.

The downside:

• Plugin management becomes your operational burden.
• You need discipline around updates, caching, and security.

www.wpbundle.com

2. If you are building a tech company, not just a store: Medusa

A subscription box is actually a good fit for a headless architecture:

Next.js storefront
        |
     Medusa
        |
 PostgreSQL
        |
Stripe Billing
        |
Fulfillment service

You would probably create your own concepts:

• SubscriptionPlan
• Subscription
• BillingAttempt
• ShipmentCycle
• BoxConfiguration
• Skip/Swap rules

Advantages:

• Clean TypeScript stack
• Easier to create unusual subscription logic
• Better long-term architecture

Disadvantages:

• You are building commerce software, not just configuring a store.

ossalt.com

3. I would pick Saleor only if you expect complexity

Good examples:

• multiple warehouses
• international selling
• many currencies
• B2B subscriptions
• enterprise integrations

It is a powerful headless platform, but probably more infrastructure than a typical subscription box startup needs. saleor.io

A stack I would choose today

Early-stage subscription box ($0–$1M ARR)

WooCommerce
+
WooCommerce Subscriptions
+
Stripe
+
ShipStation / custom fulfillment integration
+
Klaviyo for lifecycle email

Engineering-led startup

Next.js
+
Medusa
+
Stripe Billing
+
PostgreSQL
+
Temporal / queue workers for subscription jobs
+
Custom fulfillment service

One important design note: do not make your ecommerce platform the source of truth for subscriptions if subscriptions are core to your business. Keep a dedicated subscription domain:

Customer
   |
Subscription
   |
Billing Schedule
   |
Order Generation
   |
Fulfillment

Your ecommerce system should receive generated orders, not own the entire subscription lifecycle.

If you tell me:

1. expected subscriber count (100 / 10k / 100k+),
2. whether boxes are fixed or customizable, and
3. your tech stack (PHP/WordPress vs Node/Python),

I can narrow this to a specific architecture.

If recurring subscriptions are a core part of the product, I’d pick Medusa as the commerce foundation—but I would not make the ecommerce platform responsible for subscription billing.

My recommendation: Medusa + Stripe

medusajs.com is a strong fit if you’re building a custom subscription-box experience:

• TypeScript/Node.js — particularly nice if your storefront is Next.js.
• MIT-licensed and self-hostable, so you retain control of the backend.
• Modular architecture, which makes custom subscription/order workflows easier to build.
• You can self-host the application, database, Redis, admin, etc. Medusa Documentation ShipGarden
• The commerce engine handles the things it is good at: products, variants, inventory, carts, orders, fulfillment and discounts.

For recurring payments, I'd pair it with Stripe Billing rather than trying to bolt recurring billing directly into the ecommerce engine. That gives you a clean separation:

                 Your storefront
                  Next.js / React
                       │
                       ▼
              ┌─────────────────┐
              │     Medusa      │
              │                 │
              │ Products        │
              │ Inventory       │
              │ Orders          │
              │ Customers       │
              │ Fulfillment     │
              └───────┬─────────┘
                      │
             subscription events
                      │
                      ▼
              ┌─────────────────┐
              │ Stripe Billing  │
              │                 │
              │ Subscriptions   │
              │ Recurring bills │
              │ Payment retries │
              │ Invoices        │
              └─────────────────┘

Your own subscription service can then translate:

Stripe subscription → box schedule → Medusa order

For example, a customer subscribes to a monthly box. Stripe owns the recurring payment/subscription state. On each successful renewal, a webhook triggers your application to create the corresponding Medusa order for that month's box.

What I'd consider instead

saleor.io is particularly compelling if you're already a Python team; its GraphQL API and multi-channel capabilities are strong. Saleor Documentation Vendure

vendure.io is the other one I'd seriously evaluate against Medusa. It's TypeScript/NestJS and has a strong plugin architecture. The important distinction is its GPLv3/open-core licensing model, versus Medusa's more permissive MIT license. Vendure

One important architectural point

Don't model a subscription box as simply a recurring ecommerce order.

I'd have something like:

Customer
   │
   ├── Stripe Customer
   │      └── Stripe Subscription
   │
   └── Subscription
          ├── plan
          ├── shipping address
          ├── box contents/version
          ├── billing interval
          ├── next fulfillment date
          ├── status
          └── Medusa orders
                 ├── Box #1
                 ├── Box #2
                 └── Box #3

That gives you room for things subscription boxes commonly need later:

• Skip a month
• Pause/resume
• Change box size
• Swap products
• Seasonal boxes
• Different billing vs. shipping dates
• Failed-payment retries
• Address changes
• First-box discounts
• One-time add-ons
• Gift subscriptions
• Inventory-aware box composition

Bottom line: if you're comfortable developing the system yourself, I'd start with Medusa + PostgreSQL + Redis + Stripe Billing + Next.js, and keep the subscription-domain logic in your own application rather than deeply coupling it to Medusa.

If you tell me your stack (Next.js/Python/etc.), expected subscriber count, and whether boxes have fixed or customizable contents, I can narrow this down to an architecture I'd actually deploy.

What I'd consider instead

saleor.io is particularly compelling if you're already a Python team; its GraphQL API and multi-channel capabilities are strong. docs.saleor.io vendure.io

vendure.io is the other one I'd seriously evaluate against Medusa. It's TypeScript/NestJS and has a strong plugin architecture. The important distinction is its GPLv3/open-core licensing model, versus Medusa's more permissive MIT license. vendure.io

One important architectural point

Don't model a subscription box as simply a recurring ecommerce order.

I'd have something like:

For a subscription-box business with recurring billing, I’d shortlist Medusa, WooCommerce, and Saleor, but my default recommendation would be Medusa if you’re building a custom product rather than a simple WordPress store.

My pick: Medusa

Medusa is particularly attractive if you're comfortable developing the application yourself. It's TypeScript/Node.js, headless, modular, and designed to let you customize commerce workflows rather than forcing your business into a predefined checkout model. Current comparisons also put it among the strongest open-source choices for custom headless stores. www.wpbundle.com

For a subscription box, I'd structure it roughly as:

Medusa
→ products / variants / inventory
→ customers / orders
→ checkout / payments
→ subscription service you control
→ Stripe Billing
→ scheduled renewals
→ fulfillment batches
→ shipping

The important point is that I wouldn't make the ecommerce platform itself responsible for all your subscription logic. Treat subscriptions as a domain of your application. That gives you room for things like:

• monthly vs. quarterly boxes
• skip/pause/cancel
• change box contents before renewal
• add-ons
• prepaid subscriptions
• renewal-date changes
• failed-payment recovery
• different shipping schedules
• subscription-specific discounts
• inventory allocation for the next box

When I'd choose WooCommerce instead

Choose WooCommerce if your priority is getting the business live quickly rather than building an ecommerce system.

Its enormous extension ecosystem makes recurring payments, subscriptions, shipping, tax, email, analytics, etc. much easier to assemble than with a newer headless platform. www.wpbundle.com

The downside is that you're likely to end up stitching together WordPress + WooCommerce + subscription plugins + payment plugins + other plugins. That's perfectly reasonable for a small operation, but less attractive if your subscription workflow is a core differentiator.

When I'd choose Saleor

Saleor is compelling if you're building something larger and already have a strong Python/GraphQL team. Its GraphQL architecture and built-in multi-channel, multi-warehouse and international commerce capabilities are excellent. www.wpbundle.com

I'd consider it overkill for a typical subscription-box startup, though.

One important architectural decision

For your use case, I'd prioritize the platform based on how much subscription behavior you need to customize, rather than simply asking which ecommerce platform supports subscriptions.

If your business is:

Customer chooses "Monthly Mystery Box" → pays every month → gets whatever box you've configured for that month

WooCommerce is probably the pragmatic choice.

If it's:

Customer builds a box → subscription renews → contents can change → inventory is reserved → fulfillment happens in batches → customers can skip/pause → pricing and shipping depend on subscription state

I'd build on Medusa and keep subscription state in your own application.

If you tell me your stack (Node/Python/PHP/etc.), expected number of subscribers, and whether customers choose the contents of each box, I can recommend a specific architecture and payment/subscription setup.

For a subscription-box business with recurring billing, I’d shortlist Medusa, WooCommerce, and Saleor—but my default recommendation would be Medusa if you’re building a custom product rather than a conventional WordPress store.

🥇 I'd pick Medusa

Medusa is TypeScript/Node.js, headless, modular, and designed for custom commerce workflows. That's particularly attractive for subscription boxes because your business logic will probably go beyond simply "charge $30 every month":

• Customer chooses a box/plan
• Recurring Stripe subscription
• Skip/pause/cancel
• Change box contents before renewal
• Cutoff dates for the next shipment
• Generate an order from each successful renewal
• Inventory allocation
• Shipping-rate calculation
• Failed-payment handling
• Dunning/retry
• Swapping products between boxes
• Potentially different boxes based on customer preferences

Medusa gives you a relatively clean commerce backend on which to implement those workflows rather than fighting a traditional ecommerce system. Current comparisons also put Medusa among the strongest open-source choices for custom/headless stores. www.wpbundle.comwww.wpbundle.com

Important caveat: don't treat recurring billing as something the ecommerce platform should own. I'd make Stripe Billing the source of truth for the subscription/payment lifecycle, while Medusa owns customers, products, orders, fulfillment, and your subscription-box business logic.

A rough architecture would be:

                ┌───────────────┐
                │ Next.js Store │
                └───────┬───────┘
                        │
                        ▼
                ┌───────────────┐
                │    Medusa     │
                │               │
                │ Products      │
                │ Customers     │
                │ Orders        │
                │ Inventory     │
                │ Fulfillment   │
                └───────┬───────┘
                        │
             ┌──────────┴──────────┐
             ▼                     ▼
       ┌───────────┐         ┌───────────┐
       │  Stripe   │         │ Shipping  │
       │ Billing   │         │ Provider  │
       │           │         │           │
       │ Recurring │         │ Labels    │
       │ Payments  │         │ Tracking  │
       └─────┬─────┘         └───────────┘
             │
             │ webhooks
             ▼
       subscription
       renewal events

When I'd choose WooCommerce instead

If your priority is "get this business selling quickly", I'd seriously consider WooCommerce.

Its huge extension ecosystem means you can assemble subscriptions, payments, shipping, email, tax, coupons, etc., instead of implementing everything yourself. Current comparisons continue to identify WooCommerce as the strongest option for ecosystem breadth and relatively simple hosting. www.wpbundle.comwww.wpbundle.com

The downside is that a subscription-box business can accumulate a lot of plugin-dependent business logic. If you're an engineering-heavy startup expecting a highly customized customer experience, I'd rather start with Medusa.

When I'd choose Saleor

Choose Saleor if you're expecting something substantially more complex—multiple warehouses, countries/currencies, channels, sophisticated catalog management, etc.—and your team is comfortable with Python/Django and GraphQL. It is considerably heavier to self-host and operate. www.wpbundle.comwww.wpbundle.com

My recommendation

For a greenfield subscription-box startup:

Medusa + Next.js + Stripe Billing + PostgreSQL + a shipping API

I'd keep the subscription state synchronized through Stripe webhooks and have a renewal event trigger creation of the actual Medusa order. That separation will save you headaches around failed payments, retries, cancellations, and subscription state.

If you tell me your expected stack (TypeScript/Python/PHP), whether customers customize their boxes, and roughly how many subscribers you expect, I can narrow this down to a concrete architecture and explain exactly how I'd implement the recurring-billing flow.

For a subscription-box business with recurring billing, I’d pick Medusa if you’re comfortable building some custom functionality.

My recommendation: Medusa

Medusa is particularly well suited if you want a self-hosted, headless stack rather than a traditional “install a store and configure plugins” system.

The important caveat: subscriptions aren't a native commerce primitive in Medusa. Its official documentation provides a subscription recipe showing how to implement monthly/yearly subscriptions, automatic renewals, expiration, cancellation, and Stripe recurring payments. docs.medusajs.comdocs.medusajs.com

That actually makes it attractive for a subscription box, because you'll probably want custom logic anyway:

• Subscription plans — monthly, quarterly, etc.
• Box contents that change each cycle
• Skip/pause/cancel
• Swap products
• Add-ons
• Billing retries/dunning
• Address changes
• Renewal → order generation
• Inventory reservation
• Fulfillment/shipping per renewal
• Customer portal
• Coupons and introductory periods

Medusa's modular architecture lets you add custom data models, workflows, API routes, and integrations rather than fighting a monolithic plugin architecture. docs.medusajs.com

How I'd rank the options

\* WooCommerce's subscription functionality generally comes from extensions rather than the core platform.

When I'd choose something else

Choose WooCommerce if your priority is getting a subscription store live quickly, especially if you're already comfortable with WordPress. Its huge extension ecosystem is its biggest advantage. Current comparisons still put WooCommerce ahead on ecosystem breadth. www.wpbundle.com

Choose Saleor if you're building a sophisticated headless platform and your team strongly prefers Python/Django + GraphQL. Saleor is explicitly designed as an open-source, self-hostable headless commerce engine, with APIs, apps, webhooks, and dashboard extensions. docs.saleor.io

Choose Sylius if your team is already excellent with Symfony/PHP and you expect unusual business rules. It's a very good foundation for custom commerce, but I'd favor Medusa for a new TypeScript-based startup.

One architectural warning

Don't make the ecommerce platform your subscription billing system.

I'd structure it roughly like:

                 ┌───────────────┐
                 │   Next.js     │
                 │   storefront  │
                 └───────┬───────┘
                         │
                         ▼
                 ┌───────────────┐
                 │    Medusa     │
                 │               │
                 │ products      │
                 │ carts         │
                 │ orders        │
                 │ inventory     │
                 │ fulfillment   │
                 └───────┬───────┘
                         │
              ┌──────────┴──────────┐
              ▼                     ▼
       ┌──────────────┐      ┌──────────────┐
       │    Stripe    │      │ Your custom  │
       │ subscriptions│      │ subscription │
       │ + billing    │      │ service      │
       └──────────────┘      └──────────────┘

Let Stripe own payment methods, recurring charges, invoices, failed-payment handling, etc., while your application owns the meaning of the subscription: what box they're getting, when it ships, which products are in it, skips, swaps, and so on.

Medusa's own subscription example follows this general idea, using Stripe to capture recurring payments while the commerce application manages subscription behavior. docs.medusajs.com

Bottom line: If you're building a new subscription-box company and have developers, I'd start with Medusa + PostgreSQL + Stripe + Next.js. It's a better foundation for a highly customized subscription experience than trying to bend a conventional ecommerce CMS into a subscription platform.

For a subscription box business with recurring physical-product billing, I’d shortlist Medusa, Vendure, and WooCommerce—but my default pick would be Medusa if you’re comfortable building some subscription logic yourself.

My recommendation

1. Medusa — my pick for a new build

Medusa is TypeScript/Node-based, modular, and designed to be customized rather than forcing your business model into a predefined SaaS workflow. Its documentation specifically has a subscription-box example covering recurring orders, renewals, expiration, cancellation, and Stripe. docs.medusajs.comdocs.medusajs.com

The important caveat: subscriptions aren't a native first-class commerce primitive in Medusa. You implement the subscription module/workflows yourself, or delegate recurring payment collection to Stripe. docs.medusajs.comdocs.medusajs.com

That's actually attractive for a subscription box because you'll probably want custom concepts such as:

• subscription plans → box variants
• monthly/quarterly cadence
• skip/pause
• swap items
• cutoff dates
• failed-payment retries
• renewal orders
• inventory allocation
• shipping-date logic
• address changes
• cancellation
• one-time add-ons

Medusa gives you the underlying order/catalog/payment primitives without fighting you on those workflows. github.com

2. Vendure — arguably better if subscriptions are the core product

Vendure is worth serious consideration. There's an open-source Stripe Subscription plugin specifically designed to sell subscription products, including recurring billing, cancellation, refunds, and custom subscription strategies. docs.vendure.io

It's also TypeScript/GraphQL and has a mature plugin architecture. docs.vendure.io

If I were building a subscription-box platform where subscription lifecycle management is more important than having a maximally flexible commerce framework, I'd probably choose Vendure over Medusa.

3. WooCommerce — best if you want to ship quickly

If you don't need a headless/custom architecture, WooCommerce is hard to ignore. The ecosystem is vastly larger, and subscription functionality is a well-established use case.

The tradeoff is architectural: you're essentially building your business on top of WordPress + WooCommerce + extensions rather than starting with a modern commerce backend. For a relatively conventional store, that's perfectly reasonable; for a highly customized subscription engine, I prefer Medusa/Vendure.

4. Saleor — excellent, but probably overkill

Saleor is a strong API-only, GraphQL-first platform with excellent multi-channel capabilities and extensibility. github.com

I'd pick it if you anticipate things like multiple storefronts, countries/currencies, complex catalogs, or enterprise-scale commerce. For a startup subscription-box service, I'd generally favor the simpler Medusa/Vendure path.

What I'd build

For a new service, my stack would be roughly:

Next.js storefront → Medusa/Vendure → PostgreSQL
** ↘ Stripe Billing**
** ↘ shipping/fulfillment system**

And I'd make Stripe the source of truth for recurring payment state, rather than trying to implement credit-card rebilling yourself. Medusa's own subscription recipe explicitly recommends Stripe as an option for delegating recurring payment handling. docs.medusajs.comdocs.medusajs.com

One important architectural distinction: billing subscription ≠ box subscription.

I'd model them separately:

Customer
  │
  └── Subscription
       ├── plan
       ├── cadence
       ├── status
       ├── next_box_date
       ├── shipping_address
       └── Stripe subscription ID
              │
              ├── Renewal Order #1
              ├── Renewal Order #2
              └── Renewal Order #3

That makes things like skip a month, change box contents, retry payment, refund one shipment, or change the shipping address substantially easier to reason about.

Bottom line:

• Medusa → best overall starting point for a custom subscription-box startup.
• Vendure → my choice if recurring subscriptions are the central/most complex part of the product.
• WooCommerce → choose this if speed and existing plugins matter more than architectural elegance.
• Saleor → choose this when you're already thinking at multi-channel/enterprise scale.

If you tell me your expected monthly orders, whether customers can customize each box, and whether you're using Stripe, I can narrow this down to a specific architecture and database model.

For a subscription box business with recurring billing, I’d shortlist WooCommerce, Medusa, and Saleor, but my recommendation depends heavily on how much custom engineering you want to do.

My pick: WooCommerce

If your priority is getting a subscription-box business into production with the least custom billing work, I’d choose WooCommerce.

The important distinction is that WooCommerce itself is open source, but WooCommerce Subscriptions is a paid extension. It already handles recurring renewals, subscription lifecycle operations, and integrations with numerous gateways supporting automatic recurring payments. woocommerce.com

That makes it unusually well suited to a box business:

• Monthly/quarterly billing
• Automatic renewals
• Failed-payment handling
• Pause/cancel/reactivate
• Customer self-service
• Coupons and promotions
• Shipping integrations
• Large ecosystem of payment gateways
• Mature admin interface

The downside is that you're accepting WordPress/PHP architecture and paying for the subscription extension rather than having every component be free/open source.

If you're building a custom product: Medusa

I'd choose Medusa if you're a developer-heavy team and want a modern TypeScript/Node.js + Next.js stack.

Medusa is particularly attractive for a subscription box because its architecture lets you model something like:

Subscription → Renewal → Order → Fulfillment

and customize the workflow around it. Its official subscription recipe specifically covers recurring orders, automatic renewal, expiration, cancellation, and Stripe integration. docs.medusajs.comdocs.medusajs.com

But there's an important catch: subscriptions aren't native out of the box. You're implementing the subscription layer yourself, or integrating something such as Stripe Billing. docs.medusajs.comdocs.medusajs.com

That's actually a good thing if your business has unusual rules—for example:

"Customer chooses 3 products → we assemble a box → charge on the 15th → skip next month if inventory is low → substitute unavailable products → create fulfillment batch."

Medusa gives you much more freedom to make that workflow first-class.

Saleor: powerful, but probably overkill

Saleor is my third choice.

It's a serious headless commerce platform with GraphQL, multi-channel capabilities, multi-currency, sophisticated inventory, and an extensible app architecture. It can be self-hosted. docs.saleor.io

I'd consider it if you're building something more like:

• international subscription commerce
• multiple warehouses
• multiple storefronts/brands
• sophisticated B2B + B2C
• large catalog
• substantial engineering/DevOps team

For a straightforward subscription-box startup, though, I'd rather spend that complexity budget on the actual business.

What I'd choose

So my rule of thumb:

• Small team / want to launch quickly → WooCommerce + WooCommerce Subscriptions
• Engineering team / custom subscription experience → Medusa + Stripe Billing
• Large, complex, international commerce → Saleor

For your specific use case, I'd lean Medusa + Stripe Billing if you're comfortable building software, because subscription boxes tend to become workflow-heavy rather than simply "sell this product every month." Medusa's customization model is well suited to that, while Stripe can take the recurring-payment machinery off your hands. docs.medusajs.comdocs.medusajs.com

If you tell me your stack (Node/Python/PHP), expected number of subscribers, and whether customers choose what's in each box, I can narrow this down to a concrete architecture.

If recurring billing is central to the business, I’d narrow it to WooCommerce or Medusa rather than choosing a generic ecommerce platform.

My pick: Medusa + Stripe

For a new subscription-box business, I’d lean toward Medusa if you have development experience.

Why:

• TypeScript/Node.js and API-first, so it's a good foundation for a custom subscription experience. github.com
• You can self-host the entire commerce backend.
• Its modular architecture makes custom checkout, fulfillment, payment, and subscription logic easier to build.
• Medusa's own documentation has a subscription implementation using Stripe, including automatic renewals and cancellation. docs.medusajs.com
• There's now Reorder, an open-source Medusa subscription plugin that adds subscription plans, renewals, dunning/retry handling, cancellations, retention, and analytics. www.reorderjs.com

Medusa GitHub

When I'd choose WooCommerce instead

Choose WooCommerce if your priority is getting the business launched quickly rather than building the commerce system yourself.

Its huge plugin ecosystem makes things like:

• subscription products
• recurring payments
• coupons
• customer accounts
• shipping
• taxes
• email
• analytics
• fulfillment integrations

much easier to assemble. There are also open-source subscription plugins available, although you need to scrutinize their maintenance and payment integrations carefully. github.com

WooCommerce

What about Saleor?

Saleor is excellent if you're building a sophisticated, API-first/headless system. It's GraphQL-native, highly extensible, and designed for complex commerce. saleor.io

But for a subscription-box startup, I'd consider it more infrastructure than you need unless you already have a strong engineering team.

Saleor

My ranking for your use case

One important distinction: the ecommerce platform shouldn't necessarily be responsible for actually charging the customer's card every month. I'd have Stripe Billing/payment infrastructure handle recurring payment authorization, retries, invoices, and payment events, while your ecommerce system owns the subscription's products, box contents, orders, fulfillment, and customer experience.

For example:

Medusa → Reorder → Stripe → Webhooks → Medusa orders → Fulfillment

That separation will save you a lot of pain when you eventually need failed-payment recovery, skipped boxes, plan changes, prorations, cancellations, address changes, prepaid subscriptions, etc.

If you tell me (1) your tech stack, (2) expected subscribers in year 1, and (3) whether each box is fixed or customers customize what's in it, I can recommend the architecture I'd use and the specific open-source components I'd combine.

For a subscription box business with recurring billing, I’d pick Medusa if you’re comfortable doing some development.

My ranking

🥇 I'd choose Medusa

Medusa is a modern, TypeScript/Node.js commerce backend designed to be customized. It's particularly attractive for a subscription box because you can model the business around subscriptions → recurring orders → fulfillment, rather than trying to bend a traditional shopping cart into that shape. github.com

The important caveat: subscriptions aren't a native Medusa feature. Medusa's official subscription recipe has you implement the subscription layer yourself, with options for scheduled renewals or Stripe handling recurring payments. docs.medusajs.com

That actually isn't necessarily a bad thing for a box business. You can define exactly what you need:

Customer
   │
   └── Subscription
        ├── plan
        ├── billing interval
        ├── next billing date
        ├── shipping address
        ├── payment method
        ├── status
        └── orders
             ├── Box #1
             ├── Box #2
             └── Box #3

Then Stripe handles the payment mechanics while Medusa remains your commerce/order/fulfillment system.

🥈 WooCommerce if you want to launch quickly

If your priority is "get the subscription box store live with minimal custom engineering," I'd seriously consider WooCommerce.

Its enormous WordPress ecosystem means there are mature solutions for subscriptions, payments, shipping, email, discounts, customer accounts, etc. The downside is that you end up depending more heavily on plugins and WordPress conventions.

For a relatively conventional box business—e.g. $39.99/month, choose your box, recurring shipment—that's probably the pragmatic choice.

🥉 Sylius if this is a highly customized application

Sylius is worth considering if your team is strong in PHP/Symfony. It's explicitly a framework for building highly customized commerce applications rather than an off-the-shelf store. github.com

Interestingly, Sylius now has a Subscription Plugin providing subscription lifecycle, recurring sales, renewal schedules, and relationships between subscriptions and subsequent orders—but that functionality is part of Sylius Plus rather than the free core. store.sylius.com

Why I wouldn't make Saleor my first choice

Saleor is technically excellent: headless, GraphQL-first, API-only, extensible, and designed for composable commerce. github.com

But for a subscription-box startup, I'd rather spend engineering time on your subscription/fulfillment logic than adopting a sophisticated commerce stack and then building the recurring-commerce layer around it.

My recommendation:

• Developer-heavy startup / custom UX: Medusa + Stripe + Next.js
• Small team / want to launch quickly: WooCommerce + WooCommerce Subscriptions
• Large custom PHP/Symfony application: Sylius
• Enterprise/headless GraphQL requirements: Saleor

If you tell me roughly how the box works (fixed box vs. customer-selected products, monthly/quarterly, skip/pause, multiple boxes per customer, shipping rules, etc.), I can recommend the architecture and tell you exactly what I'd use for the recurring billing + subscription state machine.

For a subscription box service with recurring billing, I would not choose purely based on "best ecommerce platform." Subscriptions are a special case: you need recurring payments, failed-payment recovery, customer self-service, billing events, inventory cycles, and fulfillment automation.

My shortlist:

www.wpbundle.com

My recommendation

1. Choose WooCommerce if you want to validate the business

A subscription box is usually won by:

• acquisition
• retention
• email marketing
• content
• fulfillment operations

not by having the most elegant commerce backend.

WooCommerce + a subscription extension gives you:

• recurring billing
• customer account management
• coupons
• shipping integrations
• huge plugin ecosystem
• WordPress SEO/content marketing

The downside is architectural cleanliness. You will be assembling plugins, and you need to be careful about plugin quality and performance. www.wpbundle.com

A typical stack:

WordPress
 ├── WooCommerce
 ├── Subscription billing extension
 ├── Stripe
 ├── Email platform
 ├── Fulfillment/WMS integration
 └── Custom subscription logic plugin

This is probably what I would pick for a first subscription box brand.

2. Choose Medusa if you are building a technology company

If your vision is more like:

• multiple subscription products
• custom subscription lifecycle
• mobile app
• personalized boxes
• recommendation engine
• complex fulfillment rules
• marketplace-like architecture

then I would lean toward Medusa.

It is TypeScript/Node-based and designed as a headless commerce engine, so you can build your own subscription domain rather than forcing everything into an ecommerce plugin model. www.wpbundle.com

Architecture:

Next.js storefront
        |
     Medusa
        |
 ---------------------
 |        |           |
Stripe  Inventory  Fulfillment
 |
Subscription service

You would likely still use a billing system such as Stripe Billing and connect subscription events into your commerce layer.

3. I would probably not start with Saleor for this use case

Saleor is impressive for:

• multi-channel commerce
• international catalogs
• complex inventory
• enterprise workflows

but a subscription box company usually needs flexible recurring billing more than enterprise catalog complexity. saleor.io

The biggest design decision: don't make the ecommerce platform own subscriptions

For a serious subscription product, I would separate:

Commerce

• products
• orders
• carts
• customers

from:

Subscription engine

• billing schedule
• renewals
• skips
• pauses
• swaps
• upgrades
• churn handling

Example:

Customer
   |
Subscription Service
   |
Stripe Billing
   |
Creates Order
   |
Commerce Platform
   |
Fulfillment

This avoids painful migrations later.

My ranking for your exact scenario

1. WooCommerce + subscription extension → best MVP/business launch choice
2. Medusa + Stripe Billing → best long-term engineering architecture
3. Vendure + custom subscription module → good if your team is TypeScript/NestJS-heavy
4. Saleor → choose only if you already need enterprise commerce features

If you tell me:

• expected subscribers (100, 10k, 100k+)
• your tech stack (PHP/WordPress vs Node vs Python)
• whether boxes are fixed or personalized
• whether you need skip/pause/swap

I can narrow this down much more.

For a subscription box service with recurring billing, I would not choose purely based on “best ecommerce platform.” The hard parts are:

• recurring subscription lifecycle (pause, skip, swap, upgrade/downgrade)
• billing retries and failed payments
• customer self-service portal
• product rotation/curation logic
• fulfillment cycles (“ship every month”)
• inventory forecasting
• tax/shipping rules
• integrations with payment processors

Most open-source ecommerce platforms handle orders well, but subscriptions are usually an extension or custom module. designodin.com

My shortlist:

www.wpbundle.com

My recommendation by scenario

1. You want to launch quickly → WooCommerce

For most subscription boxes, I would start here.

Stack:

• WordPress + WooCommerce
• WooCommerce Subscriptions
• Stripe Billing or Stripe payments
• custom plugin for box logic
• email automation (Klaviyo, etc.)

Advantages:

• huge ecosystem
• easy admin for non-engineers
• lots of payment/shipping integrations
• excellent for content marketing

Disadvantages:

• subscription logic can become plugin-heavy
• scaling requires discipline

WooCommerce’s ecosystem is much larger than newer headless platforms, which matters when you need niche integrations. www.wpbundle.com

2. You are building a tech-first subscription company → Medusa

I would pick Medusa if your box is more like:

• “customers build their own box”
• personalized recommendations
• AI/quiz-driven subscriptions
• multiple storefronts
• mobile app + web + marketplaces

Medusa is TypeScript/Node-based and designed around modular commerce services. www.wpbundle.com

Typical architecture:

Next.js storefront
        |
     Medusa
        |
 PostgreSQL
        |
 Stripe Billing
        |
 Fulfillment system

You will likely build more yourself, but the architecture is cleaner than forcing subscription logic into WordPress.

3. I would avoid Saleor unless you have enterprise needs

Saleor is powerful and API-first, with GraphQL and strong commerce primitives. saleor.io

But for a subscription box startup it is probably more platform than you need unless you have:

• multiple warehouses
• international catalogs
• complex B2B pricing
• large engineering team

The architecture I would actually build

For a serious subscription box:

Option A (startup-friendly):

WooCommerce
   |
WooCommerce Subscriptions
   |
Stripe
   |
ShipStation / fulfillment provider
   |
Klaviyo

Option B (engineering-heavy):

Next.js
   |
Medusa
   |
Custom Subscription Service
   |
Stripe Billing
   |
Warehouse API

The key point: I would not make the ecommerce platform own subscriptions completely. Treat subscriptions as a domain service.

Example:

Subscription
{
 customer_id,
 plan_id,
 next_charge_date,
 next_box_contents,
 status,
 skips_remaining
}

Then your commerce platform handles:

• products
• carts
• orders
• payments

Your subscription service handles:

• recurring schedule
• box generation
• customer preferences
• renewals

My pick

• MVP / first 10k customers: WooCommerce + subscription extension
• Custom subscription experience / venture-scale: Medusa + Stripe Billing
• Enterprise: Saleor

For a new subscription box company, I would usually choose WooCommerce first unless your core competitive advantage is software. If your “secret sauce” is the subscription algorithm, personalization, or custom fulfillment workflow, choose Medusa.

For a subscription-box business with recurring billing, I’d shortlist Medusa first, WooCommerce second, and Sylius if you have a strong PHP/Symfony team.

My recommendation: Medusa

Medusa is probably the best fit if you're building a custom subscription-box experience rather than a conventional online store.

Why:

• Headless and developer-first — good if you're building your own React/Next.js storefront. github.comdocs.medusajs.comstore.sylius.com
• Node.js/TypeScript, which makes it attractive if your stack is already JS/TS.
• Its commerce primitives—products, carts, orders, payments, fulfillment, etc.—are open source and designed for customization. github.com
• There is now Reorder, an open-source Medusa subscription plugin covering plans, renewals, dunning, cancellation/retention and subscription analytics. www.reorderjs.com
• Medusa itself also documents a Stripe-based subscription implementation, including automatic renewal and customer cancellation. docs.medusajs.com

For a box service, that gives you a pretty sensible architecture:

Next.js storefront → Medusa → Stripe → subscription/renewal logic → fulfillment system

I'd keep Stripe as the payment/billing system rather than trying to make your ecommerce database responsible for charging cards. Your app should maintain the subscription state and fulfillment schedule while Stripe handles payment credentials, recurring charges, invoices, failed payments, etc.

How I'd rank the alternatives

WooCommerce is the pragmatic choice if you want to launch quickly and don't need a highly customized architecture. Its enormous WordPress/plugin ecosystem is a major advantage. The downside is that subscription functionality tends to live in extensions rather than being part of the core architecture.

Sylius is particularly interesting if you're a Symfony/PHP shop. Its subscription module supports recurring sales and subscription lifecycles, although the official subscription module is part of Sylius Plus, so it doesn't meet the "completely open-source subscription stack" requirement as cleanly as Medusa + Reorder. store.sylius.com

Saleor is excellent technically—GraphQL-only, headless, composable and self-hostable—but I'd avoid it for a subscription-first startup unless you already have a reason to choose it. Its core isn't designed around recurring subscriptions, meaning you'd be building an integration/app around the commerce engine. github.com

One important caveat

For a subscription box, recurring billing is only half the problem. You'll probably need:

1. Subscription plans and billing intervals
2. Stripe customer/subscription synchronization
3. Failed-payment retries/dunning
4. Skip/pause/cancel
5. Address changes
6. Box/product selection
7. Cutoff dates
8. Inventory reservation
9. Renewal-order generation
10. Fulfillment batching
11. Proration/upgrades
12. Tax handling
13. Customer self-service

That's why I'd favor Medusa + a subscription layer over picking an ecommerce platform merely because it has a "subscriptions" checkbox.

If you tell me your stack (e.g. Next.js/Node, Laravel/PHP, Python), expected subscriber count, and whether customers choose the contents of each box or receive a predetermined box, I can recommend the specific architecture I'd use and what I'd self-host vs. outsource to Stripe.

For a subscription box service with recurring billing, I would choose based less on “ecommerce features” and more on subscription lifecycle management:

• recurring payments
• failed payment retries/dunning
• subscription pauses/skips
• address changes
• recurring fulfillment orders
• inventory allocation per cycle
• customer portals
• coupons/trials/upgrades
• webhook reliability

My shortlist:

opensourceprojects.cc

My top recommendation: Spree Commerce

For a serious subscription box company, I would lean toward Spree. It is designed as an API-first commerce engine, so you can build your own customer experience rather than fighting a theme/plugin system. It supports subscription-oriented commerce patterns and is commonly used for complex catalogs and custom workflows. github.com

A good architecture would look like:

Next.js storefront
        |
        v
Spree Commerce API
        |
        +-- Stripe Billing
        |
        +-- Warehouse/fulfillment service
        |
        +-- Email/SMS automation

You would probably keep subscription state in your own service or a dedicated billing layer rather than forcing all subscription logic into the ecommerce core.

If you want the fastest path: WooCommerce

If you are validating the business and don't have a large engineering team:

• WordPress + WooCommerce
• WooCommerce Subscriptions
• Stripe
• ShipStation/Shippo/etc.

will get you shipping boxes quickly.

The downside: subscription boxes become complicated:

• “skip next box”
• “swap products”
• “change preferences”
• “seasonal boxes”
• “build your own box”
• inventory forecasting

often turn into a plugin stack.

If you are building a tech-heavy company: Medusa

Medusa is attractive if your team prefers TypeScript. It gives you a commerce backend you can customize heavily. opensourceprojects.cc

A subscription box example:

Customer chooses box
        |
Subscription created
        |
Monthly job generates order
        |
Inventory reserved
        |
Fulfillment triggered
        |
Payment captured

Medusa fits this style well, but you will build more yourself.

What I would avoid

I would probably avoid starting with:

• Magento Open Source — powerful but heavy operationally
• OpenCart/PrestaShop — good traditional stores, less pleasant for subscription workflows
• a pure billing platform — subscriptions alone are not enough; you need fulfillment/order logic

My ranking for your exact use case

1. Spree Commerce — if you have developers and expect scale
2. Medusa — if your team is Node/TypeScript focused
3. WooCommerce — if you need to launch in weeks
4. Saleor — if you want a headless GraphQL enterprise stack

One important design choice: I would not let Stripe (or any payment provider) be your “subscription database.” Store your own subscription state and treat Stripe as the payment processor.

If you tell me your stack (Laravel/PHP, Node, Python, Ruby, etc.), expected subscribers (500 vs 50k+), and whether boxes are fixed or customizable, I can narrow this down further.

For a subscription-box business with recurring billing, I’d shortlist Medusa, WooCommerce, and Sylius—but my default pick would be Medusa if you’re comfortable building/customizing software.

1. My pick: Medusa

Medusa is a particularly good architectural fit if you're building a subscription-box service rather than just putting a subscription option on a conventional store.

It's Node/TypeScript-based, modular, and designed to be customized. The important caveat is that Medusa itself doesn't natively provide subscriptions; its documentation shows implementing subscriptions using its framework plus a payment provider such as Stripe. github.com

There is also now an open-source Reorder subscription layer for Medusa that handles things such as recurring renewals, dunning, cancellation/retention, and subscription management. www.reorderjs.com

That makes a stack like:

Medusa + Reorder + Stripe + Next.js

quite compelling for a subscription box.

I'd structure it roughly as:

Next.js storefront
       │
       ▼
    Medusa
       │
 ┌─────┴───────────┐
 │                 │
Products        Orders
 │                 │
 └───────┬─────────┘
         ▼
   Subscription layer
         │
         ▼
       Stripe
         │
         ▼
Recurring payment
         │
         ▼
Create renewal order
         │
         ▼
Fulfillment / shipping

The key is that billing and commerce should be separate concepts. Stripe should be responsible for payment mandates, recurring charges, failed-payment handling, etc.; your commerce system should be responsible for turning a successful renewal into an order that gets fulfilled.

2. WooCommerce if you want to launch quickly

WooCommerce is probably the pragmatic choice if your priority is getting a working subscription store online rather than building a commerce platform.

Its huge WordPress ecosystem means you can get shipping, taxes, payments, customer accounts, coupons, email, analytics, and subscription functionality without building everything yourself. WooCommerce remains one of the dominant open-source ecommerce options. github.comwww.reorderjs.comwww.wpbundle.comgithub.comstore.sylius.com

The downside is architectural: once your subscription logic becomes unusual—skip shipments, swap products, multiple boxes, prepaid periods, custom renewal logic, inventory allocation, etc.—you can end up stitching together WordPress plugins and custom PHP.

I'd choose WooCommerce if:

• you're a small team
• you want to launch quickly
• your subscription model is fairly conventional
• you're comfortable with WordPress/PHP
• you want a massive plugin ecosystem

3. Sylius if the subscription model is very sophisticated

Sylius is attractive if you're essentially building a custom commerce application.

It's a Symfony/PHP ecommerce framework rather than a turnkey store, and it's deliberately designed for highly customized commerce. github.com

Interestingly, Sylius now has a subscription module supporting recurring sales, subscription lifecycles, renewals, and integration with external payment/billing systems—but that module is part of Sylius Plus, so it isn't the same proposition as an entirely free/open-source subscription implementation. store.sylius.com

What I wouldn't choose first: Saleor

Saleor is an excellent open-source headless commerce platform, with a GraphQL API, strong extensibility, and self-hosting support. saleor.io

But for a subscription-first business, you're likely to spend more effort building the recurring-billing layer yourself. That's not necessarily bad for a large engineering team, but it isn't my first choice when recurring billing is central to the business.

My recommendation

If I were starting this today:

Small/nontechnical team → WooCommerce

Technical startup building a differentiated subscription experience → Medusa + Stripe

Large engineering team with very unusual commerce workflows → Sylius

Large headless/enterprise commerce operation → Saleor

For your particular description—"subscription box service with recurring billing"—I'd lean Medusa + Stripe, provided you're comfortable owning some application development. It gives you a clean foundation without forcing the subscription business model into WordPress's plugin architecture.

One important consideration: don't make the ecommerce platform your subscription billing engine. Let Stripe (or another dedicated billing system) own recurring payment state, while your ecommerce backend owns products, orders, inventory, shipping, and fulfillment. That separation will save you a lot of pain once customers start skipping boxes, changing plans, having failed payments, pausing subscriptions, etc.