ChatGPT answers, unedited

For a self-hosted subscription box business, I’d narrow it to WooCommerce vs. Medusa rather than looking at every open-source platform.

My practical recommendation: WooCommerce

woocommerce.com is the safer choice if your priority is getting recurring physical-product billing working reliably without building the subscription system yourself.

• WooCommerce itself is open source and self-hostable. WooCommerce
• Its Subscriptions extension handles recurring billing, renewals, trials, signup fees, expiration, billing-date alignment, and subscription management. WooCommerce WooCommerce
• It supports automatic recurring payments through compatible payment gateways and has a failed-payment retry system. WooCommerce WooCommerce
• It is particularly well suited to physical subscription boxes because each renewal generates an order, which can naturally drive fulfillment/shipping. WooCommerce
• The downside is that WooCommerce Subscriptions is a paid extension, so the overall stack isn't completely free. WooCommerce

When I'd choose Medusa instead

medusajs.com makes more sense if you're a developer and want a custom/headless architecture with your own frontend and business logic.

The important catch: subscriptions aren't native. Medusa's own documentation describes subscriptions as something you implement/customize, including automatic renewal and Stripe integration. Medusa Docs

So you'd be taking responsibility for more of the machinery:

• subscription state
• renewal scheduling
• payment-provider webhooks
• failed-payment handling
• pauses/cancellations
• subscription changes
• fulfillment generation
• customer subscription management

That's attractive if those things are part of your product's differentiation, but unnecessary complexity if you're primarily trying to sell boxes.

Quick comparison

For your particular use case, I'd start with WooCommerce + WooCommerce Subscriptions + Stripe/WooPayments, self-hosted on your own server. WooPayments can use Stripe Billing as an off-site billing engine in the U.S., while automatic renewals are supported through compatible payment methods. WooCommerce

If you tell me roughly how many subscribers you expect (e.g. 100, 10k, 100k), whether customers can customize what's in each box, and whether you're building the frontend yourself, I can narrow down the architecture and hosting stack considerably.

For a subscription box business with recurring physical-product billing, I’d narrow it to WooCommerce, Medusa, or Saleor—but they fit very different architectures.

My practical recommendation: WooCommerce

If your primary goal is running a subscription-box business rather than building ecommerce infrastructure, I'd use WordPress + WooCommerce + WooCommerce Subscriptions.

WooCommerce Subscriptions supports weekly/monthly/annual recurring payments, automatic renewals, failed-payment rebilling, customer self-service, trials, sign-up fees, and subscription changes. It also explicitly supports subscription-box use cases. WooCommerce WooCommerce

The important caveat: WooCommerce itself is open source, but WooCommerce Subscriptions is a paid extension. The current listed price is $279/year. WooCommerce

When I'd choose Medusa instead

Choose Medusa if you're comfortable writing code and want something like:

Next.js storefront → Medusa → PostgreSQL → Stripe → fulfillment/shipping system

Medusa is open source and designed as a customizable commerce framework. Its official subscription recipe covers recurring orders, renewal, expiration, cancellation, and Stripe integration—but subscriptions are not a native turnkey feature; you'd implement the subscription layer yourself. GitHub Medusa Docs

That makes Medusa particularly interesting if your box has unusual rules, such as:

• Customers choose items every month.
• Box contents change based on inventory.
• Skip/pause/upgrade logic is complex.
• Different subscription tiers have different fulfillment schedules.
• You need custom customer/account experiences.
• You eventually want mobile apps or multiple storefronts.

Saleor

Saleor is another strong self-hosted option. It's API-first and GraphQL-native, with an extensible architecture and integrations for payments, shipping, taxes, etc. Saleor Documentation Saleor Commerce

But for a subscription-box startup, I'd expect more custom subscription work than with WooCommerce.

What I'd build

If you're a small team and want to validate the business:

WordPress + WooCommerce + WooCommerce Subscriptions + Stripe

If you're a developer-led company and the subscription/fulfillment logic itself is a major differentiator:

Next.js + Medusa + Stripe + PostgreSQL

I'd avoid choosing a platform solely because it is "more modern." For subscription boxes, the difficult parts tend to be renewal handling, failed payments, skips/pauses, inventory allocation, shipping synchronization, taxes, and fulfillment, rather than the basic storefront.

If you tell me your expected number of subscribers, whether customers choose box contents, and whether you want Stripe, I can sketch the self-hosted architecture and database/subscription model I'd use.

For a subscription-box business, I’d shortlist WooCommerce, Medusa, and Saleor, but my recommendation depends heavily on whether you want a ready-to-run store or a custom application.

My pick: WooCommerce

If your priority is getting recurring physical-product billing working reliably with minimal custom engineering, I’d choose WooCommerce + WooCommerce Subscriptions.

WooCommerce Subscriptions already supports recurring schedules, automatic recurring payments through many gateways, failed-payment retries, customer self-service, upgrades/downgrades, trials, and subscription management. It specifically supports subscription-box/product-of-the-month use cases. WooCommerce

The catch: WooCommerce Subscriptions is a commercial extension, so the ecommerce platform is open source/self-hostable, but the subscription functionality isn't entirely free/open source.

woocommerce.com

If you want everything to be custom: Medusa

I'd choose Medusa if you're building a proper application rather than a conventional WordPress store.

It's a headless TypeScript/Node commerce engine designed to be customized, and it is self-hostable. GitHub

However, there's an important catch for your use case: subscriptions aren't native. Medusa's own documentation describes implementing subscription logic yourself, including renewal jobs, expiration handling, subscription management, and payment integration. Alternatively, you can delegate recurring billing to Stripe. Medusa Docs Medusa Docs

That's actually attractive if your subscription box has unusual rules such as:

• "Skip next box"
• Pause/resume
• Change box contents before renewal
• Seasonal boxes
• Different billing and shipping dates
• Build-your-own box
• Proration
• Multiple shipments per billing cycle
• Inventory-aware renewal
• Failed-payment recovery

You can model those explicitly instead of fighting a plugin's assumptions.

docs.medusajs.com

Saleor

Saleor is my third choice. It's an excellent headless, GraphQL-first commerce platform and is designed for composable/custom commerce. It is also genuinely self-hostable. Saleor Saleor

I'd pick it over Medusa if you already have a Python/Django + GraphQL team or expect complex multi-channel/enterprise commerce.

For a small-to-medium subscription-box startup, though, I think Saleor introduces more architecture than you need.

What I'd actually build

If I were starting your business today: I'd use Medusa + Stripe Billing + PostgreSQL + a Next.js storefront if engineering flexibility is important. Let Stripe handle the recurring-payment machinery, while Medusa remains the source of truth for products, orders, inventory, and fulfillment. Medusa's own documentation explicitly presents Stripe as an option for delegating recurring payment handling. Medusa Docs

If you don't have a strong engineering team, I'd go WooCommerce + Subscriptions instead. It will get you to a working subscription box considerably faster.

If you tell me roughly (1) expected subscribers, (2) whether customers choose the contents of each box, and (3) Stripe vs other payment processors, I can recommend the architecture I'd use and where I'd put subscription state, billing, inventory, and fulfillment.

For a subscription box service with recurring billing, I would not choose based only on "ecommerce features." The hard parts are usually:

• recurring payment lifecycle (renewals, retries, failed cards)
• subscription changes (skip, pause, swap box, upgrade/downgrade)
• billing proration
• customer portal
• fulfillment cycles ("ship every month")
• inventory allocation before billing
• churn analytics

Most open-source ecommerce platforms are built around one-time orders, so you may end up adding a subscription engine. The Retail Exec

My shortlist:

OpenSourceProjects.cc Toolradar## My recommendation

1. If you are building a serious subscription business: choose Medusa + a subscription service layer

I would start with Medusa.

Why:

• modern TypeScript stack
• API-first/headless architecture
• easier to model custom subscription workflows
• good fit for custom React/Next.js storefronts
• you can own the checkout, customer portal, and fulfillment logic

A typical architecture:

Next.js storefront
        |
        |
     Medusa
        |
        +---- Stripe Billing (or another payment processor)
        |
        +---- Subscription service
        |
        +---- Fulfillment/WMS
        |
        +---- Email/SMS

Medusa is especially attractive if your box has logic like:

• "choose 5 snacks every month"
• "pause next month's box"
• "change preferences"
• "skip summer months"
• "VIP tiers"
• "custom bundles"

It is designed as a composable commerce backend rather than a fixed storefront. OSSAlt

2. If you want to launch quickly: WooCommerce

Use WooCommerce if:

• you already know WordPress
• marketing/content is a big part of your business
• you want thousands of existing plugins
• you have limited engineering resources

The tradeoff: subscriptions become plugin-driven, and complex subscription logic can become harder to maintain. WooCommerce has a very large ecosystem, but you are often stitching together extensions rather than designing the system yourself. Open Source Groups

A common stack:

WordPress
 + WooCommerce
 + subscription extension
 + Stripe
 + fulfillment plugin

Great for a $5k–$50k/month business. Less ideal if your product logic is your competitive advantage.

3. If you expect enterprise scale: Saleor

Saleor is worth considering if you have:

• a strong engineering team
• GraphQL preference
• multiple channels (web/mobile/marketplaces)
• international commerce requirements

It is more of a commerce platform foundation than a ready-made store. Pawel Owerczuk

I would avoid starting with

Magento Open Source

Powerful, but usually too heavy for a subscription box startup unless you already have Magento expertise.

PrestaShop/OpenCart

Good traditional ecommerce systems, but subscription workflows will likely require more customization than they are worth for this use case. Velocity

The stack I would build today

For a new subscription box company:

Frontend

• Next.js

Commerce

• Medusa

Payments

• Stripe Billing

Database

• PostgreSQL

Jobs

• Redis + workers

Email

• Postmark / SendGrid

Analytics

• PostHog

Fulfillment

• custom service or ShipStation/ShipBob integration

The key design decision: do not make the ecommerce platform own your subscription logic. Treat subscriptions as a first-class domain object:

Customer
  |
Subscription
  |
Subscription Items
  |
Billing Cycles
  |
Orders
  |
Shipments

That will save you a lot of pain later.

If you tell me your expected scale (e.g., 100 subscribers vs 100k), tech stack preference (PHP/Node/Python), and whether boxes are fixed or customizable, I can narrow it to one architecture.

I’d choose WooCommerce + WooCommerce Subscriptions for a subscription-box business. It’s self-hostable, mature, and supports recurring billing, retries, customer plan management, and many payment gateways. WooCommerce WooCommerce

• WooCommerce: best if you want to launch quickly and minimize custom development.
• Medusa: better if you’re a developer building a highly custom/headless system, but subscriptions require implementation work. docs.medusajs.com
• Saleor: powerful headless option, but similarly requires external/custom subscription billing.

For a typical subscription box MVP, WooCommerce is the pragmatic choice.

For a subscription box service with recurring billing, I would choose based less on “ecommerce features” and more on how well the platform handles:

• recurring payments + failed payment retries
• subscription lifecycle (pause, skip, swap, upgrade/downgrade)
• customer self-service portals
• inventory allocation for recurring boxes
• fulfillment workflows
• webhooks/events
• payment processor integrations (especially Stripe)

The best self-hosted open-source choices are:

1. Medusa — my top pick for a custom subscription box startup

Best if you have developers and want to build a real product.

Why it fits:

• Modern Node.js/TypeScript architecture
• API-first/headless design
• Easy to build custom subscription logic around
• Good fit for a React/Next.js storefront
• You can model boxes, variants, add-ons, swaps, personalization, etc. Open Source Projects OpenReplay Blog

Tradeoffs:

• You will build more yourself
• Subscription functionality may require modules/plugins or custom development rather than being the core experience

Good stack:

• Medusa backend
• Next.js storefront
• Stripe Billing for recurring charges
• PostgreSQL
• Redis/queues for fulfillment jobs

Choose this if: your subscription box is the business, not just a normal store with recurring orders.

2. WooCommerce — fastest route to market

Best if you want to launch quickly.

Why it fits:

• Huge ecosystem
• Lots of subscription-related extensions
• Easy admin experience for non-engineers
• Great for content-heavy brands (blogs, quizzes, landing pages, SEO) Toolradar SolOPENpreneur

Tradeoffs:

• Advanced subscription logic can become plugin-heavy
• Scaling a complex subscription operation requires careful architecture
• WordPress maintenance/security becomes part of your workload

Good stack:

• WooCommerce
• WooCommerce Subscriptions
• Stripe
• WordPress
• A fulfillment integration

Choose this if: you want to validate the business in weeks, not build a commerce platform.

3. Saleor — strong enterprise-style option

Best if you want a polished API-first commerce backend.

Why it fits:

• GraphQL-first
• Python/Django ecosystem
• Strong catalog, channels, and multi-region concepts
• Good foundation for custom customer experiences OpenReplay Blog Pawel Owerczuk

Tradeoffs:

• More engineering overhead
• Subscription workflows are likely custom work

Choose this if: you already have a backend team comfortable with Python and GraphQL.

4. PrestaShop — traditional ecommerce approach

Good if your subscription box is basically:

“customers buy products, but on a recurring schedule.”

Less ideal if your subscription experience is the differentiator.

Open Source Groups

My recommendation by stage

For a subscription box company, I would probably build:

Medusa + Stripe Billing + Next.js + PostgreSQL

and keep the subscription engine separate from the commerce engine:

• Stripe handles payment state
• Your app owns subscription rules
• Medusa owns products/orders/inventory

That avoids fighting an ecommerce platform when you eventually need things like:

• “skip next month”
• “swap two items”
• “send a birthday box”
• “pause for 90 days”
• “members get exclusive boxes”
• “customize based on preferences”

If you tell me your expected scale (e.g., 100 subscribers vs 100k), tech stack, and whether boxes are fixed or customizable, I can narrow this down further.

My recommendation by stage

For a subscription box company, I would probably build:

Medusa + Stripe Billing + Next.js + PostgreSQL

and keep the subscription engine separate from the commerce engine:

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

• recurring payments + failed payment recovery
• subscription lifecycle (pause, skip, swap, upgrade/downgrade)
• recurring order generation
• inventory allocation before fulfillment
• customer portal
• shipping cadence
• tax handling
• integrations with Stripe/PayPal, fulfillment, email, analytics

Most open-source ecommerce platforms are built around one-time purchases, so subscriptions often require an extension or custom development. OpenReplay Blog Toolradar

My shortlist:

1. Medusa — best choice for a modern subscription product (my top pick)

Best if you have developers and want a long-lived custom business.

Why it fits:

• Headless, API-first architecture
• Easy to model subscriptions as a custom domain object
• Good fit with Stripe Billing, custom checkout, mobile apps, React/Next.js storefronts
• You avoid fighting a traditional ecommerce database model

Tradeoffs:

• You build more yourself: - subscription management UI
• admin workflows
• customer portal
• recurring order engine

Good architecture:

Next.js storefront
        |
     Medusa
        |
 Subscription service
        |
 Stripe Billing
        |
 Fulfillment/WMS

For a subscription box startup where the box itself is the product, this is often the cleanest foundation. OpenReplay Blog Open Source Projects

2. WooCommerce — fastest route to market

Best if you want to launch quickly and operate like a traditional merchant.

Pros:

• Huge ecosystem
• Many subscription plugins
• Lots of developers
• WordPress content + commerce together

Cons:

• Subscription logic usually lives in plugins
• Plugin conflicts can become painful
• Scaling a complex subscription business requires careful engineering

A small subscription box company can absolutely succeed with WooCommerce, especially if your needs are:

• monthly box
• fixed products
• simple skips/cancellations
• basic customer accounts

WooCommerce remains one of the most widely deployed open-source ecommerce options. Toolradar WP Bundle

3. Sylius — best if you are a PHP/Symfony team

Best for a custom commerce platform without starting from zero.

Pros:

• Very flexible
• Strong domain modeling
• Designed for custom commerce workflows
• Good API capabilities

Cons:

• More framework than ready-made store
• Requires experienced developers

It is particularly attractive if your subscription business has unusual rules, such as:

• personalized boxes
• complex bundles
• membership tiers
• B2B subscriptions

GitHub Sylius eCommerce Framework

4. Saleor — good for enterprise/headless builds

Pros:

• GraphQL-first
• Strong API model
• Good for custom storefronts

Cons:

• You will still build subscription logic
• More infrastructure than a small startup usually needs

Open Source Groups

Platforms I would probably avoid for this use case

Magento Open Source

Powerful, but usually too heavy unless you already have a Magento team. Subscription boxes rarely need that level of catalog complexity.

PrestaShop

Good traditional ecommerce platform, but I would not pick it as the foundation for a subscription-first business.

My recommendation by stage

For a subscription box startup that expects the subscription experience itself to be the product, I would lean toward:

Medusa + Stripe Billing + custom subscription service

For a simple monthly box business trying to validate demand, I would start with:

WooCommerce + a subscription extension, then migrate if the business becomes complex.

One key question changes the answer: are your boxes fixed recurring boxes (“send the same coffee box every month”) or personalized/rotating boxes (“choose items, preferences, algorithm selects contents”)? The latter strongly favors a custom/headless approach.

For a subscription box service with recurring billing, I would narrow the field more than a normal ecommerce build. The key requirements are:

• recurring subscriptions (pause, skip, swap, upgrade/downgrade)
• recurring payment tokens and failed-payment recovery
• customer self-service portal
• product variants/bundles
• inventory allocation for future boxes
• fulfillment workflows
• analytics around churn, LTV, MRR
• ability to customize the subscription logic

My shortlist:

WPBundle OSSAlt## My recommendation

If you are a startup validating the idea: choose WooCommerce

A subscription box business has lots of moving parts besides checkout. You will likely need:

• email marketing integrations
• landing pages
• SEO content
• coupons
• affiliates
• reviews
• shipping integrations
• payment gateways

WooCommerce wins because the ecosystem already exists. Its subscription functionality is mature through extensions, and WordPress gives you a built-in CMS for marketing content. WPBundle

Typical stack:

• WordPress + WooCommerce
• WooCommerce Subscriptions
• Stripe
• a fulfillment/shipping integration
• a custom plugin for box logic

This gets you to revenue fastest.

If you are building a serious subscription platform: choose Medusa

If your product is more like:

• "customers build their own box"
• personalized recommendations
• complex subscription rules
• mobile app + web + marketplace channels
• custom fulfillment engine

then I would lean toward Medusa.

It is a headless commerce backend built for developers, using TypeScript/Node.js, so you can create your own subscription domain rather than fighting a plugin architecture. Eryx Innovations Lab

A possible architecture:

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

You would probably keep subscriptions in Stripe Billing or a dedicated subscription service and let Medusa handle catalog/orders/custom commerce logic.

I would be cautious with Saleor

Saleor is excellent if you need:

• multiple warehouses
• international commerce
• complex permissions
• GraphQL-first architecture

But for a subscription box startup, you may spend more time building commerce plumbing than improving your product. It is a stronger fit for a larger engineering organization. Saleor Commerce

The architecture I would avoid

I would avoid trying to make the ecommerce platform itself own all subscription logic.

A subscription box is closer to a SaaS billing problem than a normal cart problem.

A cleaner model:

Customer
   |
Subscription service
   |
Payment provider (Stripe Billing)
   |
Commerce engine (WooCommerce/Medusa/Saleor)
   |
Fulfillment

The subscription service owns:

• billing schedule
• renewals
• skips
• pauses
• plan changes
• churn

The ecommerce platform owns:

• products
• orders
• inventory
• checkout
• customer records

My ranking for your specific use case

1. WooCommerce + Subscriptions — best first version
2. Medusa + Stripe Billing — best custom/scalable build
3. Saleor + Stripe Billing — best enterprise option
4. Bagisto — good if you already live in Laravel

If you tell me:

• expected number of subscribers (100, 10k, 100k+)
• your tech stack (PHP, Node, Python, etc.)
• whether boxes are fixed or customizable
• whether you need a mobile app

I can recommend a more exact architecture.

For a subscription box service with recurring billing, I would not choose purely based on “best ecommerce platform.” Subscription boxes have a few special requirements:

• recurring payment tokens and billing schedules
• subscription lifecycle management (pause, skip, swap, cancel)
• customer self-service portal
• box customization (preferences, variants, add-ons)
• fulfillment cycles (“ship every month”)
• failed payment retries/dunning
• inventory allocation before renewal dates
• tax/shipping rules for recurring orders

My shortlist would be:

Toolradar OpenReplay Blog## My recommendation

1. If you want to launch quickly: WooCommerce + subscription extensions

Use:

• WordPress
• WooCommerce
• WooCommerce Subscriptions (or another subscription plugin)
• Stripe Billing / Stripe gateway
• custom plugins for box logic

Why:

• Huge ecosystem
• Admin experience is friendly for non-developers
• Lots of payment integrations
• Easy marketing/content integration

WooCommerce is probably the safest choice if your first goal is proving the business model. It has an established subscription ecosystem, although advanced workflows often require plugins or custom development. opensource.builders

The downside:

• Subscription logic can become plugin-heavy
• Complex “build my box” flows get messy
• Scaling a large subscription operation may require careful architecture

Good for:

• 100–10,000 subscribers
• curated monthly boxes
• simple variants

2. If you are building a serious subscription platform: Medusa

For a developer-led company, this is probably my favorite architecture.

Medusa gives you a modern commerce backend where you can build subscription logic as modules rather than forcing your business into a traditional cart model. It is API-first/headless, so your storefront can be React/Next.js, mobile apps, etc. OpenReplay Blog

Typical architecture:

Next.js storefront
        |
        |
Medusa commerce backend
        |
        +-- Customers
        +-- Products
        +-- Orders
        +-- Inventory
        +-- Subscription service (custom)
        +-- Stripe Billing
        +-- Fulfillment system

You would likely add:

• Stripe Billing for recurring charges
• a subscription database table
• renewal jobs
• customer preference engine
• fulfillment scheduler

Good for:

• thousands to millions of subscribers
• personalized boxes
• mobile apps
• complex business rules

3. If you want enterprise-grade customization: Sylius

Sylius is a strong choice if your team is comfortable with PHP/Symfony. It is more of a commerce framework than a ready-made store, which makes it excellent for unusual workflows. GitHub

A subscription box company might model:

• SubscriptionPlan
• SubscriptionCycle
• BoxGeneration
• ShipmentBatch
• CustomerPreference

rather than trying to bend a normal product/order system.

Platforms I would be cautious about

Magento Open Source

Powerful, but probably excessive unless you have:

• a large engineering team
• complex B2B pricing
• huge catalogs
• multiple warehouses

It adds operational overhead you probably do not need early. Velocity

PrestaShop/OpenCart

Fine traditional ecommerce platforms, but subscription boxes tend to require more custom behavior than they handle elegantly. Open Source Groups

A practical stack I would choose

MVP (first 6–18 months)

WooCommerce
+ Stripe
+ subscription plugin
+ custom box-builder plugin
+ fulfillment integration

Growth stage

Next.js
+
Medusa
+
Stripe Billing
+
PostgreSQL
+
queue workers (BullMQ/Redis)
+
warehouse/fulfillment integration

If I were building a new subscription box company today, I would pick:

• WooCommerce if the priority is getting paying customers quickly.
• Medusa if the goal is building a long-lived software platform around subscriptions and personalization.

The key question is: is your “box” basically a recurring product, or is it a personalized experience where every customer gets a different box generated each cycle? That changes the architecture quite a bit.

A practical stack I would choose

MVP (first 6–18 months)

WooCommerce
+ Stripe
+ subscription plugin
+ custom box-builder plugin
+ fulfillment integration

Growth stage

Next.js
+
Medusa
+
Stripe Billing
+
PostgreSQL
+
queue workers (BullMQ/Redis)
+
warehouse/fulfillment integration

If I were building a new subscription box company today, I would pick:

If recurring physical subscription boxes are the core business, I’d pick WooCommerce unless you have a strong engineering team and specifically want a headless architecture.

My recommendation

Why WooCommerce: its subscription ecosystem is much more mature. WooCommerce Subscriptions supports automatic recurring payments, multiple billing schedules, subscriber self-management, cancellations, upgrades/downgrades, and a large selection of recurring-payment gateways. WooCommerce WooCommerce WooCommerce

The important caveat is that WooCommerce itself is open source, but WooCommerce Subscriptions is a paid extension. WooCommerce So if by "open source" you mean every component must be free/open-source, I'd look elsewhere.

If you want a developer-first stack

I'd seriously consider Medusa.

Medusa is a modern, self-hostable, TypeScript/Node commerce backend, and its architecture is much better suited to a custom subscription-box application than trying to bend WordPress into something it wasn't designed to be. However, subscriptions aren't native: Medusa's own documentation describes implementing subscriptions as a customization, including renewal, expiration, cancellation, and Stripe payment integration. Medusa Docs

That actually isn't necessarily bad. For example, you could architect:

Next.js → Medusa → Stripe Billing → PostgreSQL

with your own subscription domain model:

• subscription plan
• billing interval
• box contents
• skip/pause
• upcoming shipment
• address changes
• failed-payment recovery
• swaps/add-ons
• renewal generation
• inventory allocation

This gives you substantially more control, but you're building and maintaining those pieces yourself.

What I'd choose

• You're validating the business / want to launch quickly: WooCommerce + Subscriptions
• You're building a custom SaaS-like subscription platform: Medusa + Stripe Billing
• You expect complicated catalogs, multiple warehouses/channels, international operations: Saleor, but expect more engineering. Current comparisons generally position Saleor as the more enterprise-oriented/headless option. WP Bundle Open Source Groups
• You want everything open source and don't mind implementing billing yourself: Medusa is probably my first choice.

One particularly important consideration for subscription boxes is billing vs. fulfillment. I would not make your ecommerce platform responsible for everything. Let Stripe (or another payment processor) handle payment-method storage, recurring charges and payment failures, while your application owns the subscription and shipment state.

If you tell me your tech stack (e.g. Node/Python/PHP), expected subscribers, Stripe vs. another processor, and whether customers need to customize each box, I can recommend a specific architecture and database model.

Medusa is a modern, self-hostable, TypeScript/Node commerce backend, and its architecture is much better suited to a custom subscription-box application than trying to bend WordPress into something it wasn't designed to be. However, subscriptions aren't native: Medusa's own documentation describes implementing subscriptions as a customization, including renewal, expiration, cancellation, and Stripe payment integration.

That actually isn't necessarily bad. For example, you could architect:

Next.js → Medusa → Stripe Billing → PostgreSQL

with your own subscription domain model:

For a subscription box service with recurring billing, I would choose based less on "general ecommerce" and more on how you want to model subscriptions, renewals, customer portals, and billing events. Most open-source ecommerce platforms are built around one-time purchases; recurring billing is often an extension or an external billing system. WP Bundle Open Source Projects

My shortlist:

Open Source Groups WP Bundle## My recommendation

1. Choose WooCommerce if you want to launch and sell

For a subscription box startup, I would usually pick:

• WordPress + WooCommerce
• WooCommerce Subscriptions (paid extension)
• Stripe Billing or Stripe payments
• A custom customer portal for skips, swaps, pauses, address changes

Why:

• The ecosystem is enormous.
• You get content marketing, SEO, landing pages, email integrations, and checkout quickly.
• Subscription workflows are already common.
• You can hire developers easily.

The downside:

• WordPress plugin maintenance becomes a real operational concern.
• Complex subscription logic can become messy if you accumulate many plugins.

WooCommerce's ecosystem advantage is a major reason it remains a common self-hosted choice. WP Bundle

2. Choose Medusa if you are building a tech product, not just a store

If your subscription box has unusual rules like:

• "Every month customers choose 3 items from a rotating catalog"
• Personalized boxes generated by an algorithm
• Membership tiers
• Loyalty credits
• Complex fulfillment rules
• Mobile apps as a first-class experience

I would lean toward Medusa.

A likely architecture:

• Medusa → products, inventory, orders
• Stripe Billing → subscriptions, invoices, payment retries
• Next.js → storefront
• PostgreSQL → customer/subscription data
• Background workers → renewal jobs and fulfillment

Medusa is designed as a modular, API-first commerce backend, which makes custom workflows easier than modifying a traditional monolith. WP Bundle Eryx Innovations Lab

3. I would not start with Saleor unless you have a strong engineering team

Saleor is excellent for headless commerce, but subscription boxes usually need custom subscription logic anyway. You would still be building a billing layer around it. Eryx Innovations Lab

It makes more sense if you need:

• multi-region commerce
• complex permissions
• multiple warehouses
• enterprise-scale operations

Architecture I would avoid

I would not store recurring billing logic only inside your ecommerce database.

A better separation:

Stripe Billing
     |
     | webhooks
     v
Subscription Service
     |
     +--> Ecommerce platform (orders/products)
     |
     +--> Fulfillment system
     |
     +--> Email/SMS notifications

Your ecommerce platform should answer:

"What did the customer buy?"

Your billing system should answer:

"When should we charge them next, and what happens if payment fails?"

My ranking for your use case

1. 🥇 WooCommerce — if you want revenue quickly and your box is fairly standard
2. 🥈 Medusa + Stripe Billing — if you are building a differentiated subscription product
3. 🥉 Saleor — if you expect enterprise complexity

If you tell me:

• your stack preference (PHP / Node / Python),
• expected subscriber count (100, 10k, 100k+),
• whether boxes are fixed or customizable,

I can narrow this to a concrete architecture.

1. 🥇 WooCommerce — if you want revenue quickly and your box is fairly standard
2. 🥈 Medusa + Stripe Billing — if you are building a differentiated subscription product
3. 🥉 Saleor — if you expect enterprise complexity

If you tell me:

• your stack preference (PHP / Node / Python),
• expected subscriber count (100, 10k, 100k+),
• whether boxes are fixed or customizable,

I can narrow this to a concrete architecture.

For a subscription box service with recurring billing, I’d shortlist WooCommerce, Medusa, and Saleor, but my recommendation depends heavily on how custom your product/billing workflow needs to be.

My pick: WooCommerce

If you want to launch quickly and minimize custom engineering, use WooCommerce.

• Mature subscription ecosystem.
• WooCommerce Subscriptions supports weekly/monthly/annual recurring payments, failed-payment rebilling, upgrades/downgrades, pauses, cancellations, and payment-method changes. WooCommerce WooCommerce
• Huge plugin ecosystem for shipping, taxes, fulfillment, email, analytics, etc.
• Straightforward to self-host.
• Downside: the official Subscriptions extension is paid ($279/year currently), so the core platform is open source but your ideal recurring-billing setup isn't necessarily zero-cost. WooCommerce

If you're building a custom product: Medusa

I'd choose Medusa if you're a developer building a modern custom storefront.

It's a TypeScript/Node.js, headless commerce platform with modules for products, orders, payments, inventory, fulfillment, etc. Medusa Docs

The important catch: subscriptions aren't native. Medusa provides an official recipe for implementing them, including recurring renewal, expiration, customer cancellation, and Stripe integration. Medusa Docs Medusa Docs

That can actually be an advantage for a subscription box because you can model things like:

Subscription
├── customer
├── plan
├── billing_interval
├── next_billing_date
├── shipping_address
├── box_variant
├── skipped_cycles
├── pause/resume
└── status

        ↓ renewal

Payment → Order → Fulfillment → Shipment

You have much more control over the distinction between billing, what goes in the box, and fulfillment.

Saleor

Saleor is another strong option if you're comfortable with Python/GraphQL. It's API-first and explicitly designed for composable commerce and self-hosting. Saleor Commerce GitHub

But, like Medusa, subscription billing isn't a core native feature, so you'd be building/integrating that layer yourself. Designodin

What I'd choose

If you're building a serious subscription-box business rather than simply adding subscriptions to an existing store, I'd lean toward Medusa + Stripe Billing + a Next.js storefront. Medusa's own subscription documentation specifically describes the subscription-box pattern and shows both custom renewal logic and Stripe-based recurring billing. Medusa Docs

The architecture I'd start with is:

Next.js → Medusa → PostgreSQL
** ↘ Stripe Billing**
** ↘ shipping/fulfillment provider**

One important distinction: self-hosting the ecommerce platform does not mean you should self-host payment-card recurring billing. Let Stripe (or another PCI-compliant processor) handle the payment credentials and recurring charges, while your platform owns the subscription/business logic.

If you tell me your stack (Node/Python/PHP), expected subscribers (e.g. 100 vs 100k), and whether boxes are fixed or customers customize them, I can narrow this down to one architecture.

For a subscription box business, I’d shortlist Medusa and Sylius, with Medusa as my default recommendation if you’re comfortable doing some custom development.

My pick: Medusa

Medusa is particularly attractive if you’re building a custom subscription experience rather than a conventional online store.

The important caveat: subscriptions aren't a native Medusa feature. Medusa provides the commerce/payment framework, and its official documentation has a subscription recipe covering recurring plans, automatic renewals, expiration tracking, cancellation, and Stripe integration. Medusa Docs Medusa Docs

That architecture is actually a good fit for subscription boxes because you can model things like:

• Customer subscribes to a box/plan
• Monthly/quarterly billing
• Stripe handles recurring payment credentials
• Subscription generates an order on each billing cycle
• Customers skip/pause/cancel
• Change box size or product selections
• Different shipping dates/cutoffs
• Failed-payment recovery
• Coupons and introductory pricing
• Inventory allocation per upcoming box
• Custom subscription portal

I'd keep Stripe Billing as the source of truth for the recurring billing, rather than trying to make your ecommerce database itself perform recurring card charges. Medusa already has Stripe payment-provider support and webhook infrastructure. Medusa Docs Medusa Docs

How I'd compare the main options

• WooCommerce's subscription functionality generally comes through extensions rather than the open-source core.

When I'd choose Sylius instead

Sylius is probably the strongest alternative if you're building a serious, highly customized commerce system and your team likes PHP/Symfony.

Its current Stripe integration explicitly supports subscription/recurring payments, although Sylius itself is more of a highly customizable commerce framework than a turnkey subscription-management system. Sylius eCommerce Framework Sylius Addons Marketplace

I'd pick Sylius over Medusa if:

• Your team is strong in PHP/Symfony
• You expect complicated pricing/catalog/order rules
• You're building a larger commerce operation rather than a relatively lean startup
• You want the flexibility of a mature Symfony architecture

What about WooCommerce?

If your priority is "get the business launched quickly", don't dismiss WooCommerce.

Its enormous plugin ecosystem can make subscription boxes substantially easier to launch than building subscription infrastructure yourself. The tradeoff is that you end up depending more heavily on WordPress/plugins and potentially paid extensions.

For a technically sophisticated team building a differentiated subscription product, I'd rather have Medusa + Stripe + a custom subscription service.

The architecture I'd use

I'd roughly structure it as:

Next.js storefront
       │
       ▼
    Medusa
       │
       ├── Products / variants
       ├── Customers
       ├── Orders
       ├── Inventory
       └── Shipping
             │
             ▼
       Subscription Service
             │
             ├── Plans
             ├── Billing dates
             ├── Pauses / skips
             ├── Box configuration
             └── Renewal orders
                    │
                    ▼
              Stripe Billing
                    │
                    ▼
                 Webhooks
                    │
                    ▼
              Subscription Service

The key design decision is not to make Medusa responsible for the entire subscription lifecycle. Let Stripe handle payment collection and recurring billing; let your application handle what the customer receives and when.

That's especially important for a box business because "subscription" and "recurring payment" aren't actually the same thing.

If you tell me your stack (Node/Python/PHP), whether you're using Stripe, and whether customers can customize/skip boxes, I can recommend the exact platform + architecture I'd use and explain why.

For a subscription box service with recurring billing, I would not choose purely based on “best ecommerce platform.” Subscriptions change the architecture: you need recurring payments, subscription lifecycle management, failed payment recovery, customer self-service, renewals, skips/pauses, upgrades/downgrades, fulfilment scheduling, and inventory allocation.

My shortlist:

WPBundle Toolradar## My recommendation

If you are a small-to-medium subscription box startup:

Pick WooCommerce + a subscription system.

Why:

• Fastest route to revenue.
• Huge ecosystem for payments, shipping, email marketing, coupons, tax, fulfilment integrations.
• WordPress gives you landing pages, SEO, blogs, and campaigns out of the box. WPBundle
• You can self-host cheaply.

Typical stack:

• WooCommerce
• WooCommerce Subscriptions (or another subscription extension)
• Stripe Billing/Stripe payments
• A fulfilment/inventory plugin
• Email automation (Klaviyo, Mailchimp, etc.)
• Custom plugin for box customization rules

The downside: subscription logic can become messy if your product is unusual (e.g., “choose 5 snacks every month,” rotating boxes, swaps, credits, loyalty tiers).

If your box model is the product itself:

Pick Medusa.

For example:

• Customer picks preferences.
• Your system assembles a different box every month.
• Customers can swap items.
• You need subscription pause/resume rules.
• You have multiple fulfilment centres.
• You want a mobile app.

Medusa is designed as a modular, API-first commerce backend, which makes custom workflows cleaner than forcing everything through plugins. WPBundle Eryx Innovations Lab

A modern stack could be:

• Medusa commerce backend
• Next.js storefront
• Stripe Billing for recurring payments
• Postgres database
• Separate subscription service/workflow engine
• Warehouse/fulfilment integration

The tradeoff: you are building more yourself.

I would avoid starting with Saleor unless you already have a strong engineering team.

Saleor is excellent for headless, GraphQL-first commerce and complex operations, but subscription billing is typically something you integrate rather than a core feature. Saleor Commerce Designodin

My decision tree

• Need to launch in <3 months → WooCommerce
• Need a custom subscription experience → Medusa
• Expect enterprise complexity from day one → Saleor
• Selling thousands of SKUs internationally → Magento/Open Source

For most subscription boxes, I would start with WooCommerce if validating the idea, then migrate to a custom Medusa-style architecture once the business proves the need.

A few details would change the recommendation:

1. What kind of box is it (food, beauty, collectibles, B2B supplies, etc.)?
2. Do customers choose contents, or is it a fixed monthly box?
3. What stack does your team know (PHP/WordPress, Node/TypeScript, Python)?
4. Roughly how many subscribers do you expect in year one?

For a subscription-box business, I’d shortlist WooCommerce and Medusa, with WooCommerce as the pragmatic choice and Medusa as the better choice for a custom/headless product.

My recommendation

Pick WooCommerce if:

• You want to launch quickly.
• Your box is essentially a product with monthly/quarterly renewals.
• You want a mature admin UI for products, customers, orders, coupons, taxes, shipping, etc.
• You don't want to build the subscription system yourself.

WooCommerce + its Subscriptions extension supports automatic recurring payments, trials, sign-up fees, customer subscription management, and multiple payment gateways. WooCommerce WooCommerce

Pick Medusa if:

• You're building a custom React/Next.js storefront.
• You have a TypeScript/Node team.
• The subscription box has unusual business logic—e.g. customers choose items each cycle, skip/pause boxes, change contents before a cutoff, have multiple boxes, custom fulfillment schedules, etc.
• You want the commerce backend to be a programmable foundation rather than a WordPress application.

Medusa is particularly attractive architecturally, but there's an important catch: subscriptions aren't native. Medusa's own documentation describes implementing recurring subscriptions yourself or integrating Stripe's subscription functionality. Medusa Documentation Medusa Documentation

How I'd rank them for your use case

Saleor is a very capable self-hosted, headless platform, but I'd be reluctant to choose it specifically because your defining requirement is recurring billing rather than extremely complex commerce infrastructure. Saleor Commerce Saleor Commerce

One architectural point I'd strongly recommend

Don't make your ecommerce platform responsible for charging cards on a schedule.

For example:

Storefront → Commerce platform → Stripe Billing → Webhooks → Subscription/fulfillment system

Let Stripe handle the ugly billing problems—failed cards, retries, payment methods, invoices, billing dates, etc.—and let your ecommerce system handle:

• What's in the customer's box
• Product/catalog data
• Subscription status
• Skip/pause/cancel
• Box customization
• Fulfillment dates
• Shipping
• Inventory
• Orders

That distinction makes Medusa + Stripe a particularly interesting architecture for a serious custom subscription-box business, even though you have to build the subscription layer around Medusa. Medusa explicitly documents this Stripe-based approach. Medusa Documentation

If you tell me your stack (e.g. Next.js/Node, Laravel/PHP, Python) and whether customers choose/customize what's in each box, I can recommend the specific platform + architecture I'd use.

Don't make your ecommerce platform responsible for charging cards on a schedule.

For example:

Storefront → Commerce platform → Stripe Billing → Webhooks → Subscription/fulfillment system

Let Stripe handle the ugly billing problems—failed cards, retries, payment methods, invoices, billing dates, etc.—and let your ecommerce system handle:

For a subscription box service with recurring billing, I would not choose purely by “best ecommerce platform.” The key question is whether subscriptions are a first-class concept in the platform or something you will bolt on.

My shortlist:

WPBundle OpenReplay Blog## My recommendation

Choose WooCommerce if you want to launch a real subscription box business quickly

A subscription box typically needs:

• recurring payments
• customer self-service (“skip next box,” “change address,” “pause subscription”)
• coupons/referrals
• email marketing integrations
• landing pages and SEO content
• inventory management
• shipping integrations

WooCommerce has the biggest ecosystem for these merchant workflows. Its subscription capabilities are usually handled through the mature subscription extension ecosystem rather than custom development. OSSAlt

A typical stack:

• WordPress + WooCommerce
• WooCommerce Subscriptions
• Stripe Billing or Stripe gateway
• ShipStation/Shippo/etc.
• Klaviyo or similar email platform
• Redis + object caching
• Managed VPS (not cheap shared hosting)

This is what I would pick for a first subscription box company doing, say, hundreds to tens of thousands of subscribers.

Choose Medusa if your subscription box is really a software product

Use Medusa if you expect unusual rules:

• “Build your own box” flows
• complex product personalization
• subscription tiers with custom entitlements
• gamification/loyalty
• mobile apps
• multiple storefronts
• unusual fulfillment logic

Medusa is a headless, Node/TypeScript commerce engine, so it fits teams that want to own the architecture. The tradeoff is that you will build more of the subscription layer yourself. WPBundle

A possible architecture:

• Medusa backend
• Next.js storefront
• Stripe Billing for recurring payments
• Postgres
• Redis queues
• custom subscription service

I would be cautious with Saleor for this use case

Saleor is excellent technology, especially for complex catalogs and headless commerce, but a subscription box startup often does not need its level of architectural complexity on day one. Saleor Commerce

The biggest architectural decision: where subscriptions live

I would avoid making the ecommerce platform your billing engine.

A more durable design is:

Storefront
    |
Commerce platform
    |
Customer + order data
    |
Subscription system
    |
Stripe Billing
    |
Payment processor

Let Stripe handle:

• recurring charges
• failed payments
• card updates
• invoices
• dunning

Let your ecommerce platform handle:

• products
• inventory
• orders
• fulfillment

This separation makes future migrations much easier.

My ranking for your specific idea

1. WooCommerce + Stripe + subscription extension

Best chance of getting to revenue quickly.

2. Medusa + Stripe Billing

Best if you are a developer building a differentiated subscription platform.

3. Vendure + custom subscriptions

Good TypeScript option if you prefer a plugin architecture.

4. Saleor

Great engineering choice, probably unnecessary unless you already have a strong backend team.

If you tell me:

• expected subscriber count (100, 10k, 100k+)
• your tech stack (PHP/WordPress vs Node vs Python)
• whether boxes are fixed or customizable
• B2C only or also wholesale

…I can narrow this to a concrete architecture.

If recurring billing is central to the business, I’d narrow it to WooCommerce, Medusa, and Saleor—but my recommendation depends heavily on how custom your service will be.

My pick: WooCommerce if you want to launch quickly

woocommerce.com is probably the safest choice for a subscription-box business.

Why:

• Subscriptions are a mature feature, not something you have to build yourself. WooCommerce Subscriptions supports automatic recurring payments, renewals, cancellations, trials, billing-date alignment, etc. WooCommerce WooCommerce
• It handles physical-product inventory and shipping naturally—important for a box business.
• There's a large ecosystem of payment gateways, fulfillment, tax, shipping, CRM, email, and analytics integrations.
• You can support things like monthly/quarterly boxes, skips, pauses, upgrades, coupons, limited subscription terms, and variable products. WooCommerce
• Automatic recurring payments are supported by numerous payment gateways. WooCommerce

The downside: WooCommerce Subscriptions itself is a paid extension, so while WooCommerce is open source/self-hostable, the most convenient subscription functionality isn't entirely free. WooCommerce

If you're building a custom software product: Medusa

medusajs.com would be my choice if you're a development-heavy team and want a modern, headless architecture.

Medusa is particularly attractive if you want:

• Next.js/React storefront
• Custom subscription logic
• Custom box-building/configuration
• Multiple fulfillment workflows
• Your own customer portal
• Mobile apps later
• Complex integrations
• Full control over the commerce backend

However, subscriptions aren't native in Medusa. Their documentation provides a recipe for implementing recurring subscriptions and automatic renewal using Stripe, but you're responsible for building and maintaining that logic. Medusa Docs

That's a significant distinction for a subscription business.

Saleor: excellent, but probably overkill

saleor.io is a strong option if you're building something fairly sophisticated and want a GraphQL-first, headless commerce platform. It's explicitly designed to be self-hosted and extended through apps. Saleor Commerce Saleor Documentation

I'd consider it for a larger engineering team, particularly if you need multi-region, multi-channel, B2B, or complex catalog capabilities.

But for a straightforward subscription-box startup, I'd rather spend that engineering effort on the actual subscription experience.

What I'd choose

For your specific use case, I'd start with WooCommerce + WooCommerce Subscriptions + Stripe/WooPayments, unless you already know you need a highly customized application.

One important architectural point: don't build recurring card billing yourself. Let Stripe/payment infrastructure handle payment-method storage, retries, card updates, and recurring charging; your ecommerce application should primarily manage the subscription state, products, inventory, and fulfillment. WooPayments, for example, supports recurring subscription charges and card account updating. WooCommerce

If you tell me roughly how the box works (e.g. fixed box vs. customer chooses items, monthly vs. quarterly, skip/pause, Shopify-like customer portal, expected orders/month), I can recommend the architecture and stack I'd use—including whether WooCommerce or Medusa will be cheaper to operate.

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

• recurring payments and retries (failed cards, dunning)
• subscription lifecycle (pause, skip, swap, upgrade/downgrade)
• recurring fulfillment cycles
• customer self-service portal
• inventory allocation before each shipment
• tax/invoicing
• churn analytics

Most open-source ecommerce platforms handle products/orders well, but subscriptions are often better handled by integrating a billing system such as Stripe Billing or a dedicated subscription module. DesignOdin

My shortlist:

Toolradar OpenReplay Blog## My recommendation

1. If you are building a serious subscription business: choose Medusa + Stripe Billing

This would be my default for a new subscription box startup.

Architecture:

• Medusa → products, carts, customers, orders, inventory, fulfillment workflows
• Stripe Billing → recurring charges, invoices, failed payment recovery
• Next.js (or similar) → storefront and customer portal
• Background workers → monthly box generation, renewals, inventory reservation

Why:

• modern TypeScript stack
• API-first
• easier to customize than older monolithic platforms
• good fit for “build your own Dollar Shave Club/BarkBox-style experience”

The tradeoff: you will build more yourself. Medusa is not a turnkey subscription-box app. Open Source Projects DesignOdin

2. If you want to launch quickly: WooCommerce + subscription extensions

Choose this if your priority is validating the business.

Pros:

• enormous ecosystem
• lots of payment integrations
• easy marketing/content management through WordPress
• many developers know it

Cons:

• subscription logic can become plugin-heavy
• complex fulfillment rules may become harder to maintain
• scaling a large subscription operation requires more engineering

WooCommerce remains one of the most widely deployed open-source ecommerce options because of its ecosystem. Toolradar

3. If you expect enterprise complexity: Saleor or Sylius

Consider these if you need:

• multiple warehouses
• complex inventory rules
• international markets
• custom pricing
• multiple storefronts

They are excellent foundations but require a stronger engineering team. OpenReplay Blog GitHub

Platforms I would probably avoid for a subscription box startup

• Magento Open Source: powerful, but operationally heavy unless you already have Magento expertise.
• PrestaShop/OpenCart: good traditional stores, but subscription workflows usually require more customization.

Velocity## A practical stack I would build today

For a new subscription box company:

Frontend:
Next.js

Commerce:
Medusa

Payments:
Stripe Billing + Stripe Checkout

Database:
PostgreSQL

Jobs:
BullMQ / Redis workers

Email:
Customer.io / Postmark

Shipping:
Shippo / EasyPost integration

Your core data model should probably be:

Customer
 └── Subscription
      ├── Plan
      ├── Billing schedule
      ├── Box contents
      ├── Shipment history
      └── Payment status

The ecommerce platform should support that model—not force you to fake subscriptions as repeated orders.

If you are a solo founder trying to get the first 1,000 customers, I would lean WooCommerce. If you are a developer building a long-term subscription platform, I would pick Medusa.

If recurring billing/subscriptions are central to the business, I’d shortlist Medusa, WooCommerce, and Vendure—but for a new custom subscription-box service, my default pick would be Medusa.

My recommendation

1. Medusa — best overall for a custom build

• TypeScript/Node.js, headless, and highly customizable.
• MIT-licensed and self-hostable.
• Good fit if you’re building your own frontend and fulfillment/subscription logic.
• The important catch: subscriptions aren't native. Medusa's own documentation provides a recipe for implementing subscriptions with Stripe, including automatic renewals, expiration, cancellation, and subscription/order administration. Medusa Documentation Medusa Documentation
• This is actually a reasonable architecture for a subscription box: let Stripe Billing handle recurring payment mechanics, while Medusa owns products, orders, customers, inventory, fulfillment, etc.

2. WooCommerce — best if you want the easiest path

WooCommerce has by far the larger plugin/ecosystem world, and it makes sense if you're comfortable with WordPress. The downside is that you're adding WordPress/PHP and typically relying on an extension for subscriptions rather than designing the system around your own application architecture. WPBundle WPBundle

I'd choose it if your priority is "get the store running quickly", rather than "build a custom commerce application."

3. Vendure — worth considering for TypeScript

Vendure is another TypeScript/NestJS option with a plugin-oriented architecture and GraphQL API. It's particularly attractive if you already like NestJS and want a more structured commerce framework. pkgpulse Eryx Innovations Lab

What I'd build

For a subscription-box company, I'd lean toward:

Next.js storefront
       │
       ▼
    Medusa
   ┌───┴──────────────┐
   │                  │
Products          Orders/Fulfillment
Customers         Inventory
   │
   ▼
Stripe Billing
   │
   ├── recurring charges
   ├── payment failures
   ├── retries
   └── subscription lifecycle

Then your application maintains the subscription-box business logic, e.g.:

• monthly/quarterly plans
• box contents
• skip/pause
• swap products
• shipping-address changes
• cutoff dates
• renewal → order creation
• inventory allocation
• fulfillment
• cancellation
• failed-payment handling

That's preferable to trying to make your ecommerce engine itself become a full recurring-billing system.

One important caveat

Don't pick Medusa solely because it's "open source." Subscription billing is the unusual part of your business, and none of the major headless OSS platforms should be assumed to have Shopify-level subscription functionality built in. Medusa explicitly says its subscription functionality requires customization. Medusa Documentation

So my ranking for your specific use case is:

Saleor is excellent for complex multi-channel/enterprise commerce, but I'd consider it overkill for a typical subscription-box startup unless you already have a Python/GraphQL stack. Eryx Innovations Lab

If you tell me your stack (e.g. Next.js/Node, Django, Laravel, etc.), expected number of subscribers, and whether boxes are fixed or customers customize their box, I can recommend the architecture I'd actually use—including Stripe, database schema, renewal flow, and self-hosting setup.

If you’re building a subscription-box business and want to self-host, my first choice would be Medusa—provided you’re comfortable doing some development work.

My recommendation: Medusa

Medusa is a particularly good fit because it is designed as a customizable commerce backend rather than a rigid storefront platform. It has modules for products, orders, inventory, fulfillment, payments, pricing, customers, etc., and it can be self-hosted. Medusa Docs Medusa Docs

More importantly, Medusa has an official subscription implementation recipe covering:

• Monthly/yearly subscription intervals
• Automatic renewals
• Subscription expiration
• Customer cancellation
• Saved payment methods for subsequent charges
• Stripe integration
• Admin views for subscriptions and orders Medusa Docs

The important caveat is that subscriptions aren't a native turnkey feature. Medusa's documentation explicitly treats them as something you implement using its framework. Medusa Docs

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

subscription → upcoming box → product selection → inventory allocation → payment → fulfillment → shipment → next billing cycle

rather than simply charging a customer every month for the same SKU.

docs.medusajs.com

How I'd rank the alternatives

WooCommerce is the other option I'd seriously consider. Its enormous extension ecosystem means you can assemble subscriptions, payments, shipping, taxes, and fulfillment without building as much yourself. The downside is that a subscription-box operation can eventually turn into a collection of WordPress plugins and custom glue code.

Saleor is excellent if your team is already comfortable with Python/GraphQL and you expect a sophisticated headless architecture. Its core provides catalog, checkout, channels, promotions, payments, etc., but subscription billing would still be an application-level concern. Saleor Documentation Saleor Commerce

One architectural recommendation

I wouldn't make the ecommerce platform itself the source of truth for recurring billing.

I'd structure it roughly as:

Medusa
→ products/catalog
→ carts/orders
→ inventory
→ fulfillment

Stripe
→ customer/payment method
→ recurring billing
→ invoices
→ payment retries
→ failed-payment handling

Your subscription service
→ subscription state
→ billing schedule
→ box contents
→ skip/pause/cancel
→ upcoming shipment
→ renewal workflow

Medusa's payment architecture supports third-party providers such as Stripe, and its subscription recipe specifically demonstrates using Stripe for recurring charges. Medusa Docs Medusa Docs

That separation will save you a lot of pain when you eventually need pause/skip, failed payments, changing box contents, proration, refunds, address changes, and fulfillment timing.

Bottom line: if you're a developer building a differentiated subscription-box product, I'd choose Medusa + Stripe + a custom subscription domain. If your priority is launching quickly with minimal custom engineering, I'd choose WooCommerce instead.

If recurring subscriptions are the core of the business, I’d choose Medusa if you’re comfortable building the subscription layer yourself.

My ranking

1. Medusa — best fit for a modern custom subscription-box service
2. WooCommerce — best if you want the fastest path to a working store and a huge plugin ecosystem
3. Saleor — excellent for larger/complex commerce, but subscriptions still require external billing
4. Vendure — interesting TypeScript alternative, particularly if your team already uses NestJS

Why I’d pick Medusa

Medusa is TypeScript/Node-based, headless, modular, and designed for customization. It gives you the commerce primitives—products, carts, orders, payments, fulfillment, etc.—without forcing your subscription business into a conventional one-time-purchase model. Eryx Innovations Lab Medusa Documentation

The important caveat is that Medusa does not natively provide subscription purchases. Its own documentation describes implementing subscriptions as a customization, including recurring billing, renewals, expiration, cancellation, and customer subscription management, with Stripe used as the example billing provider. Medusa Documentation

For a subscription box, that's actually a reasonable architecture:

                    Your storefront
                         │
                    Next.js / etc.
                         │
                         ▼
                    ┌─────────┐
                    │ Medusa  │
                    └────┬────┘
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
      Products        Orders        Customers
          │              │
          └──────┬───────┘
                 ▼
        Subscription service
                 │
                 ▼
          Stripe Billing
                 │
                 ▼
       recurring payment events
                 │
                 ▼
          Create next order
                 │
                 ▼
             Fulfillment

I'd keep subscription state and payment scheduling in Stripe Billing, rather than trying to make Medusa itself behave like a billing engine. Medusa becomes your commerce/order/fulfillment system, while Stripe is authoritative for recurring payment state.

When I'd choose WooCommerce instead

If your priority is "get this launched quickly with minimal custom development", I'd seriously consider WooCommerce.

Its enormous extension ecosystem means you're much more likely to find existing solutions for subscriptions, payment gateways, shipping, tax, customer accounts, coupons, etc. WPBundle ossium

The downside is that you're buying into the WordPress/WooCommerce ecosystem: PHP, WordPress updates, plugin compatibility, and potentially a fairly plugin-heavy architecture.

For a subscription box with relatively conventional requirements, that's not necessarily bad. In fact, it may be the most economical choice.

When I'd choose Saleor

I'd pick Saleor if you're building something substantially more complex—for example:

• Multiple countries/currencies
• Multiple warehouses
• Multiple storefronts/channels
• Complex B2B pricing
• Large catalog
• A team already experienced with Python/Django/GraphQL

Saleor is powerful, but subscription billing isn't a native core feature either, so you still need Stripe Billing or another recurring-payment system. Designodin

The decision I'd make

For your specific description, I'd go with Medusa + Stripe Billing + PostgreSQL + a Next.js storefront.

One architectural point I'd emphasize: don't model a subscription box as simply "a product that automatically creates an order every month." You'll eventually need skips, pauses, plan changes, failed payments, prorations, address changes, cutoff dates, box contents, shipment generation, and potentially one-time add-ons. Designing the subscription domain separately from ordinary orders will save you a lot of pain later.

If you tell me your planned stack (e.g. Next.js + TypeScript + Stripe) and whether customers choose their box contents or receive a fixed box, I can sketch the Medusa subscription architecture/database model I'd use.

For a subscription-box business, I’d shortlist Vendure and Medusa, with Vendure as my first choice if recurring billing is central to the product.

My recommendation

1. Vendure — best fit for subscription boxes

Vendure is TypeScript/NestJS, self-hostable, and has a plugin architecture that makes custom commerce workflows relatively straightforward. More importantly, there is an existing Stripe Subscription plugin that handles recurring subscriptions, cancellation at period end, refunds, webhooks, and custom subscription strategies. Vendure Developer Hub Vendure

That maps nicely to a box business:

• Customer chooses a box/plan
• Stripe creates the recurring subscription
• You fulfill one box per billing cycle
• Customer can skip/cancel
• You can change box contents between cycles
• Webhooks drive fulfillment when payment succeeds
• Different billing intervals can be implemented
• Multiple channels/markets are supported

The big caveat is GPLv3 licensing, so I'd have your lawyer check the implications if you're modifying/distributing the platform itself. Vendure

2. Medusa — best if you want maximum flexibility

Medusa is probably the better choice if your engineering team is comfortable building the subscription layer yourself. Its official documentation explicitly provides a recipe for subscriptions with Stripe, including automatic renewals, expiration tracking, customer cancellation, and an admin view. However, subscriptions aren't native to Medusa; you're implementing the functionality using its framework. Medusa Docs

That's actually attractive for a subscription box because your business model will probably become more complicated than simply "charge $30 every month."

For example, you might eventually want:

Subscription → billing cycle → box configuration → inventory reservation → fulfillment → shipment → renewal

Medusa gives you a lot of freedom to model that yourself.

3. WooCommerce — best if you want the fastest conventional store

I'd choose WooCommerce if you're less engineering-heavy and want a huge ecosystem of plugins and merchant tooling. It's considerably more opinionated around WordPress, though, and I'd be less enthusiastic about building a sophisticated subscription/fulfillment system on top of it.

What I'd pick

Current comparisons also put Medusa, Saleor, and Vendure among the leading modern self-hosted headless options, with Medusa particularly attractive for TypeScript teams. Ship Garden pkgpulse

One architectural suggestion

For a subscription box, don't make the ecommerce platform itself responsible for the entire subscription system.

I'd structure it roughly like:

Vendure/Medusa
→ products, customers, orders, prices, inventory

Stripe
→ payment methods, recurring billing, invoices, failed-payment recovery

Your subscription service
→ subscription state, billing-cycle logic, box selection, skips, pauses, swaps

Fulfillment service
→ pick/pack/ship each cycle

That separation will save you a lot of pain once you have things like "charge on the 15th, lock box contents on the 10th, skip February, swap one item, and don't ship until payment succeeds."

If you tell me your stack (Next.js/Node/Python/etc.), expected subscribers, and whether customers choose the contents of each box, I can narrow this down to a concrete self-hosted architecture.

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.