ChatGPT answers, unedited

For a developer building a custom frontend, the “best” headless commerce platform depends on whether you want maximum control or minimum backend work. The strongest options today fall into a few categories. Naturaily Netguru

My shortlist for flexibility + APIs

PowerGate Software Naturaily## If I were choosing as an engineer

1. Maximum flexibility: commercetools

Pick this if your frontend is a competitive advantage and you expect complex requirements:

• Multiple storefronts
• Multi-region catalogs
• Custom pricing rules
• B2B workflows
• ERP/PIM/OMS integrations
• Marketplace or marketplace-like models

Its APIs and data model are designed around composable commerce rather than extending a traditional ecommerce platform. LaunchTry Netguru

Typical stack:

• Next.js / React frontend
• commercetools APIs
• Contentful/Sanity for CMS
• Algolia/Elastic for search
• Custom backend-for-frontend layer

Downside: you own a lot of architecture.

2. Best developer experience: Medusa

For a smaller engineering team that wants control, I would seriously consider Medusa.

Good fit if you want:

• TypeScript/Node ecosystem
• Own your database and infrastructure
• Custom checkout logic
• Custom product models
• Your own APIs/services around commerce

It feels closer to building your own commerce engine without starting from zero. Guideflow Pharos Production

3. Best GraphQL-first option: Saleor

Saleor is attractive if your team likes GraphQL and Python.

Strengths:

• Clean GraphQL API
• Open source
• Good fit for custom storefronts
• Strong developer control

Less ideal if you need a huge ecosystem of ready-made commerce integrations.

4. Pragmatic choice: Shopify headless

If the business wants to sell quickly, Shopify is hard to ignore.

You get:

• Payments
• Checkout
• Admin tooling
• Inventory/order workflows
• Huge app ecosystem

Then build your frontend separately using the Storefront API/Hydrogen approach. Vendure

The limitation is that Shopify remains the commerce core; you are customizing the experience around it rather than owning the entire commerce model.

My ranking by scenario

• Building a unique commerce product/platform: Medusa or commercetools
• Enterprise retailer with many channels: commercetools
• Startup with strong engineering team: Medusa
• Content-heavy brand site: Shopify headless + modern CMS
• B2B with complex pricing/workflows: commercetools, Medusa, or Elastic Path
• Need to launch in months, not years: Shopify headless

For a greenfield custom frontend, my default picks would be:

1. Medusa if your team wants ownership and speed of iteration
2. commercetools if this is a serious enterprise commerce platform
3. Shopify headless if business operations matter more than backend freedom

A few questions would change the recommendation significantly:

• Are you building B2C, B2B, or marketplace?
• Expected scale (SKUs/orders/day)?
• Frontend stack (Next.js, React Native, Vue, etc.)?
• Do you need custom checkout/pricing logic, or mostly a custom UI?

If you’re building the frontend yourself and your priorities are flexibility + APIs, I’d shortlist Medusa, Saleor, and commercetools. My default pick for a developer-controlled stack would be Medusa.

My ranking

🥇 I'd choose Medusa for a custom frontend

docs.medusajs.com

Medusa is particularly attractive if you're comfortable with TypeScript/Node. Its storefront is completely separate from the commerce backend, so you can build the frontend in Next.js, Remix, React Native, native mobile, or essentially whatever you want. Medusa Documentation Medusa Documentation

The important part for a custom system is that you're not limited to the platform's predefined commerce behavior. Medusa lets you:

• Create custom REST API routes
• Add your own data models
• Build custom workflows/business logic
• Create custom modules
• Subscribe to commerce events
• Extend the admin
• Use the underlying commerce modules directly in your own Node applications Medusa Documentation Medusa Documentation Medusa Documentation

Its Store API is REST-based and has an OpenAPI specification, which is convenient if your frontend/BFF architecture is API-heavy. Medusa Documentation

Architecture I'd consider:

                 ┌───────────────┐
                 │   Next.js FE  │
                 │   Web / PWA   │
                 └───────┬───────┘
                         │
                    REST / JSON
                         │
                 ┌───────▼───────┐
                 │    Medusa     │
                 │ Commerce Core │
                 └───────┬───────┘
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
      Payments       Inventory       Orders
          │              │              │
          └──────────────┼──────────────┘
                         ▼
                 Custom modules /
                 external services

That's a very good fit if your frontend is the product rather than something you're willing to bend around an ecommerce platform.

🥈 Pick Saleor if GraphQL is a major requirement

docs.saleor.io

Saleor is probably the strongest alternative if you specifically want a GraphQL-native commerce backend. Its API covers the storefront and admin, and it provides typed GraphQL tooling, custom attributes/metadata, webhooks, multi-channel commerce, and extensibility through APIs/apps. Saleor Documentation Saleor Commerce Saleor Commerce

I'd lean Saleor over Medusa if your frontend team strongly prefers:

query Product($id: ID!) {
  product(id: $id) {
    name
    pricing {
      priceRange {
        start {
          gross {
            amount
            currency
          }
        }
      }
    }
  }
}

rather than REST endpoints.

Saleor is also compelling for multi-region/multi-channel and sophisticated commerce models. Saleor Documentation Saleor Commerce

🏢 commercetools if this is serious enterprise commerce

If you're building for a large enterprise with multiple markets, brands, catalogs, currencies, teams, and integrations, I'd put commercetools on the shortlist.

The difference is that you're buying into a mature composable commerce platform rather than primarily adopting an open-source commerce framework. That can be a big advantage operationally, but usually makes more sense when enterprise budget and requirements justify it.

What I'd actually pick

For a greenfield developer-owned frontend:

1. Medusa — best overall balance of API access + customization + TypeScript
2. Saleor — best if GraphQL and sophisticated/multi-channel commerce are priorities
3. commercetools — best for enterprise composable architecture
4. Vendure — worth serious consideration if you want TypeScript + GraphQL and an extensible commerce engine
5. Shopify — choose this instead if minimizing backend/operations work matters more than maximum control

The key distinction is "headless" vs. actually extensible. A platform can give you a great Storefront API while still making unusual checkout, pricing, fulfillment, marketplace, or catalog behavior painful. Medusa and Saleor are particularly interesting when you expect to modify the commerce backend itself rather than merely consume it. PowerGate Vendure

If you tell me your frontend stack (Next.js/React/etc.), B2C vs B2B, expected scale, and whether you need custom checkout/pricing/marketplace logic, I can narrow this down to one architecture and explain exactly why.

docs.saleor.io

Saleor is probably the strongest alternative if you specifically want a GraphQL-native commerce backend. Its API covers the storefront and admin, and it provides typed GraphQL tooling, custom attributes/metadata, webhooks, multi-channel commerce, and extensibility through APIs/apps. Saleor Documentation Saleor Commerce Saleor Commerce

I'd lean Saleor over Medusa if your frontend team strongly prefers:

query Product($id: ID!) {
  product(id: $id) {
    name
    pricing {
      priceRange {
        start {
          gross {
            amount
            currency
          }
        }
      }
    }
  }
}

rather than REST endpoints.

Saleor is also compelling for multi-region/multi-channel and sophisticated commerce models. Saleor Documentation Saleor Commerce

🏢 commercetools if this is serious enterprise commerce

If you're building for a large enterprise with multiple markets, brands, catalogs, currencies, teams, and integrations, I'd put commercetools on the shortlist.

The difference is that you're buying into a mature composable commerce platform rather than primarily adopting an open-source commerce framework. That can be a big advantage operationally, but usually makes more sense when enterprise budget and requirements justify it.

What I'd actually pick

For a greenfield developer-owned frontend:

1. Medusa — best overall balance of API access + customization + TypeScript
2. Saleor — best if GraphQL and sophisticated/multi-channel commerce are priorities
3. commercetools — best for enterprise composable architecture
4. Vendure — worth serious consideration if you want TypeScript + GraphQL and an extensible commerce engine
5. Shopify — choose this instead if minimizing backend/operations work matters more than maximum control

The key distinction is "headless" vs. actually extensible. A platform can give you a great Storefront API while still making unusual checkout, pricing, fulfillment, marketplace, or catalog behavior painful. Medusa and Saleor are particularly interesting when you expect to modify the commerce backend itself rather than merely consume it.

If your priority is maximum frontend freedom + strong APIs, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for an engineering-led custom frontend.

My pick: Medusa

For a developer building a custom frontend, Medusa is particularly compelling because the storefront is completely separate from the commerce backend. You can use Next.js, React, Vue, mobile clients, or essentially anything capable of consuming HTTP APIs. docs.medusajs.com

More importantly, you aren't just customizing the frontend—you can customize the commerce backend itself. Medusa's architecture gives you modules, workflows, custom API routes, data models, integrations, and event handling. docs.medusajs.com

Its Store API is REST-based and there's also an official JS SDK, which is a nice fit if your frontend is TypeScript/JavaScript. docs.medusajs.com

I'd choose Medusa if you're building things like:

• Highly customized product/catalog experiences
• Custom checkout or pricing logic
• Marketplace/multi-vendor functionality
• Multiple storefronts/apps
• Custom integrations with ERP/PIM/WMS/etc.
• A Next.js frontend where you want the backend to stay out of your way
• A commerce system that you expect to modify substantially over time

When I'd choose Saleor instead

If you're particularly enthusiastic about GraphQL, I'd seriously consider Saleor.

Saleor is essentially API-only and GraphQL-native, with the frontend completely decoupled from the backend. Its API covers products, checkout, channels, promotions, payments, etc., and it has extensive extension mechanisms. docs.saleor.io

So I'd frame it:

Medusa → maximum backend/customization freedom + REST/TypeScript ecosystem

Saleor → excellent API design + GraphQL + sophisticated multi-channel commerce

Saleor's own architecture is explicitly designed to be technology-agnostic, including admin extensions and integrations. saleor.io

When commercetools wins

If this is an enterprise-scale composable commerce project—with complicated B2B pricing, multiple markets, lots of external systems, and a substantial budget—I'd move commercetools toward the top of the list.

For a typical developer-led custom storefront, though, I'd avoid paying enterprise complexity unless you actually need it.

One important distinction

I'd separate "best API" from "best headless platform."

If you're mostly saying:

"I want to own the frontend and consume commerce as an API."

Then Saleor is arguably the cleanest architectural choice.

If you're saying:

"I want to build my own commerce product, and I want the commerce backend itself to be extensible."

Then Medusa is the more interesting choice.

My ranking for your stated requirements:

1. 🥇 Medusa — best overall for developer flexibility
2. 🥈 Saleor — best if you want GraphQL/API-first architecture
3. 🥉 commercetools — best for serious enterprise composable commerce
4. Shopify — best if operational simplicity/ecosystem beats backend freedom
5. BigCommerce — good managed middle ground

If you tell me your frontend stack (Next.js/React/etc.), backend language preference, B2C vs B2B, and whether you want self-hosting, I can narrow this down to a concrete architecture and API choice.

If your priority is maximum frontend freedom + a strong API, I’d shortlist Medusa, Saleor, and commercetools. For a developer building a genuinely custom frontend, my default pick would be Medusa.

🥇 My pick: Medusa

Medusa documentation

Medusa is particularly compelling if you want to own the architecture rather than just consume a commerce backend.

Its commerce functionality is broken into modules—products, carts, orders, inventory, pricing, payments, fulfillment, etc.—and you can use those modules directly in your own workflows. You can also add your own data models, modules, API routes, workflows, events, and integrations. docs.medusajs.com

That means your architecture can look like:

Your Frontend
   ↓
Your BFF / API layer
   ↓
Medusa
   ├── Products
   ├── Cart
   ├── Pricing
   ├── Inventory
   ├── Orders
   ├── Payments
   └── Your custom modules
          ↓
     Your business logic

Its Store API is REST-based, with an OpenAPI reference, and there's a JS SDK if you want a more convenient client layer. docs.medusajs.com

The big advantage: you aren't limited to whatever extension points the commerce vendor decided to expose. You can actually add backend functionality.

🥈 Saleor if you strongly prefer GraphQL

Saleor documentation

Saleor is probably my choice if your frontend team is GraphQL-first.

It's GraphQL-native, technology-agnostic, headless, and designed around APIs and extensions rather than platform-specific frontend code. It also supports custom data models, apps/extensions, and 140+ webhook events. saleor.io

I'd choose Saleor over Medusa when:

• your frontend is heavily GraphQL-oriented
• you want strongly typed generated API clients
• you have multiple storefronts/channels
• you want a very clean separation between frontend and commerce backend
• you don't want to build as much commerce infrastructure yourself

🏢 commercetools for enterprise

I'd look seriously at commercetools if you're building something large enough that composable commerce, multiple systems, internationalization, and enterprise integrations dominate the requirements.

The tradeoff is that it's generally a more heavyweight/enterprise-oriented choice than Medusa or Saleor.

Where Shopify fits

Shopify developer documentation

Shopify's headless capabilities are excellent if you want Shopify's mature commerce infrastructure while replacing the storefront.

But there's an important distinction:

Headless doesn't necessarily mean extensible.

With Shopify, you can make an extremely custom frontend, but your backend commerce model remains much more constrained than something like Medusa. If your goal is "I want to invent my own commerce behavior", I'd lean Medusa/Saleor.

My decision rule

Choose Medusa if you mean:

"I want a commerce engine that I can bend to my application's architecture."

Choose Saleor if you mean:

"I want a sophisticated commerce API and I'm building around GraphQL."

Choose commercetools if you mean:

"We're building enterprise-scale composable commerce."

Choose Shopify if you mean:

"I want a custom frontend but don't want to own much of the commerce backend."

For a new custom frontend in Next.js/React + TypeScript, I'd personally start with Medusa vs. Saleor, and I'd give Medusa the edge for raw customization. Its current framework explicitly supports custom modules, data models, workflows, API routes, and integrations rather than treating customization as an afterthought. docs.medusajs.com

If you tell me your stack (e.g. Next.js + TypeScript + Postgres) and whether you need things like subscriptions, B2B pricing, multi-vendor, marketplaces, or multi-region, I can narrow it down much further.

If you’re building a custom frontend and flexibility + API quality are the priorities, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for a developer-led custom build.

🥇 My pick: Medusa

For a developer building the frontend yourself, Medusa is particularly compelling because the frontend is completely separate from the commerce backend. Its Store API is REST-based, and you can build your storefront with essentially whatever stack you want. docs.medusajs.com

More importantly, you're not limited to consuming predefined APIs. Medusa's framework lets you create custom API routes, data models, modules, workflows, integrations, and business logic inside the commerce application. docs.medusajs.com

That makes it a strong choice if your architecture looks something like:

Your custom frontend
       │
       ▼
   BFF / API layer
       │
       ▼
     Medusa
    ┌──┴───────────────┐
    │ Products          │
    │ Cart / Checkout   │
    │ Pricing           │
    │ Orders            │
    │ Inventory         │
    │ Customers         │
    └──┬───────────────┘
       │
       ├── Stripe
       ├── ERP
       ├── CMS
       ├── Search
       └── Fulfillment

The big advantage is that you can introduce your own business logic rather than fighting the platform's extension model.

🥈 Saleor if GraphQL is your priority

Saleor is arguably the cleaner choice if you want a GraphQL-native architecture.

Saleor is API-only and GraphQL-only, with no prescribed frontend technology. It also has strong native concepts around channels, regions, currencies, inventory, and multi-storefront commerce. docs.saleor.io

So I'd lean:

Medusa → REST + TypeScript + maximum backend customization

Saleor → GraphQL + strongly typed API + composable frontend

For a React/Next.js frontend, both are excellent.

🏢 commercetools if this is enterprise

commercetools is where I'd look if you're building for a large organization with sophisticated pricing, catalogs, multiple markets, ERP integrations, etc.

The tradeoff is that you're buying into a much more enterprise-oriented platform rather than getting the relatively developer-friendly "I can modify the commerce engine itself" experience you get with Medusa.

What I'd choose based on your priorities

• "I want to own the entire frontend and backend behavior." → Medusa
• "I want an extremely clean GraphQL API." → Saleor
• "I'm building enterprise composable commerce." → commercetools
• "I want Shopify's ecosystem but custom rendering." → Shopify
• "I want TypeScript + GraphQL + open source." → Vendure

One particularly important distinction: don't choose solely based on whether a platform says "headless." The real question is how much of the commerce backend can you change without resorting to hacks. Medusa's current architecture is explicitly designed around custom modules, workflows, API routes, and integrations, which is why I'd put it first for a developer-centric build. docs.medusajs.com

If you tell me your frontend stack (Next.js, Nuxt, SvelteKit, React, etc.), database, expected scale, and whether it's B2C/B2B/marketplace, I can give you a much more specific Medusa vs Saleor vs commercetools architecture recommendation.

If you’re the developer building the frontend yourself and your priorities are flexibility + APIs, I’d shortlist Medusa, Saleor, and Vendure, with Medusa as my default pick for a TypeScript/Next.js stack.

🥇 My pick: Medusa

If you're building something like:

Next.js / React → your custom UI → commerce API → PostgreSQL

I'd seriously consider Medusa.

Medusa's v2 Store API is REST-based, has an official JS SDK, and is designed specifically for custom storefronts and mobile applications. You can also extend the backend with your own modules rather than being constrained to a SaaS vendor's data model. docs.medusajs.comvendure.io

That makes it particularly attractive if your frontend isn't just a conventional storefront—for example, if you want:

• custom checkout
• unusual pricing logic
• custom product types
• marketplace functionality
• subscriptions
• custom fulfillment
• external ERP/PIM integrations
• AI/agent-driven shopping
• multiple frontend applications
• your own customer/account experience

The big advantage is that you own the commerce application architecture, rather than merely consuming a vendor's commerce API.

🥈 Saleor if API design is your #1 concern

Saleor is arguably the more interesting choice if you're specifically thinking "I want a really clean API-driven commerce backend."

Saleor is GraphQL-only and API-only, with products, checkout, channels, payments, extensions, webhooks, etc. exposed through its API architecture. github.com

I'd choose it over Medusa if:

"I have a sophisticated frontend and I want GraphQL to be the fundamental interface to commerce."

Its multi-channel architecture is also particularly compelling for international or multi-store commerce. github.com

🥉 Vendure if you're a TypeScript purist

Vendure is worth a very serious look if you want TypeScript + GraphQL + a deeply extensible plugin architecture.

It's particularly attractive for B2B, complex pricing, multi-channel, and situations where you expect to write substantial custom commerce logic. Current comparisons put Vendure alongside Medusa and Saleor as the major open-source developer-oriented options. vendure.io

What I'd actually choose

If I were starting a new custom frontend today:

Next.js + TypeScript → Medusa → PostgreSQL

I'd pick Saleor instead if I strongly preferred GraphQL.

I'd pick Vendure instead if the project was heavily B2B/custom-workflow oriented.

I'd pick commercetools if this were a large enterprise where paying for managed infrastructure and enterprise support outweighed the additional cost. docs.medusajs.comvendure.io

And I'd pick Shopify headless if the important requirement was "I don't want to operate commerce infrastructure" rather than "I want maximum backend flexibility." Shopify's headless approach gives you a custom frontend while keeping the commerce backend proprietary/managed. docs.medusajs.comvendure.io

One important distinction: don't evaluate these primarily on how nice their storefront demos look. For a custom frontend, I'd spend most of your evaluation time testing catalog modeling, checkout extensibility, pricing, promotions, inventory, webhooks, authentication, API rate limits, and how painful it is to implement a completely nonstandard business rule.

If you tell me your frontend stack (Next.js/React/etc.), B2C vs B2B, approximate catalog size, and whether you want to self-host, I can narrow this to a concrete architecture and recommend one.

If you're a developer building a custom frontend and your priority is maximum flexibility + strong APIs, the "best" choice usually comes down to how much commerce infrastructure you want to own.

My shortlist:

powergatesoftware.com

My recommendation by scenario

1. You want a truly custom product → Medusa

Pick Medusa if you are building something where commerce is part of the application, not just a store.

Examples:

• marketplace workflows
• unusual checkout logic
• custom pricing engines
• subscriptions with unique rules
• highly customized inventory
• combining commerce with SaaS/user accounts

Why:

• Node/TypeScript ecosystem
• modular architecture
• you control the backend
• easy pairing with Next.js, Remix, Nuxt, etc.

Tradeoff:

• you own more infrastructure and integrations. hunchbite.comwww.netguru.com

2. You want the cleanest frontend API → Saleor

Saleor is attractive if your frontend team thinks in GraphQL.

Good for:

• React/Next.js storefronts
• mobile apps
• multi-channel commerce
• complex product models

Its GraphQL-first approach is one of its biggest strengths. hunchbite.comwww.netguru.com

Tradeoff:

• Python/Django backend means more stack diversity if your team is mostly JS/TS.

3. You are building enterprise commerce → commercetools

Use this when you have:

• multiple brands
• multiple regions
• complex B2B pricing
• ERP/PIM integrations
• very large catalogs

It is closer to a commerce "engine" than a store platform. www.netguru.com

Tradeoff:

• expensive and requires experienced architects.

4. You want to ship quickly → Shopify headless

Shopify is hard to beat if you need:

• payments
• taxes
• fulfillment
• admin UX
• apps
• merchant tooling

You can still build a completely custom frontend with the Storefront API/Hydrogen. patrickstox.com

Tradeoff:

• you are extending Shopify, not replacing it. Some backend behaviors are constrained.

If I were choosing for a new developer-led build

My ranking would be:

1. Medusa — best balance of flexibility and developer experience
2. Saleor — best API design if you prefer GraphQL
3. Shopify headless — best if business operations matter more than backend freedom
4. commercetools — best if you already know you need enterprise complexity

A common modern stack would be:

Next.js frontend
        |
        |
Commerce API (Medusa / Saleor / Shopify)
        |
        |
Postgres + payments + search + CMS

For a custom frontend specifically, I would lean Medusa + Next.js unless you have a strong reason to choose Shopify or enterprise composable commerce. hunchbite.com

A few things would change the recommendation:

• B2B vs B2C?
• expected SKU count?
• marketplace or single merchant?
• do you need to own the backend code?
• Next.js/React, Vue, mobile, or something else?

If you’re a developer building a custom frontend and your priorities are flexibility + APIs, I’d shortlist Medusa, Saleor, and commercetools. My default pick for an engineering-led project would be Medusa.

1. 🥇 Medusa — my pick for maximum control

Medusa documentation

Medusa is particularly attractive if you're comfortable owning some backend architecture. Its storefront is completely separate from the commerce backend, and you can build it with essentially whatever frontend stack you want. docs.medusajs.com

The big advantage is that you're not limited to just consuming predefined commerce APIs: Medusa has a framework for creating custom API routes, workflows, data models, and modules inside the commerce application. docs.medusajs.com

Its Store API is REST-based, with an OpenAPI reference, and the architecture is Node.js/TypeScript-oriented. docs.medusajs.comdocs.medusajs.com

I'd choose Medusa if:

• You're using Next.js/React/TypeScript.
• You want to deeply customize commerce behavior.
• You want your own backend logic rather than working around SaaS limitations.
• You may eventually need unusual pricing, fulfillment, marketplace, B2B, subscriptions, etc.
• You want open-source/self-hosting options.

2. 🥈 Saleor — excellent if you love GraphQL

Saleor

If your frontend architecture is strongly GraphQL-oriented, Saleor may actually be the better choice than Medusa.

Saleor is GraphQL-native and exposes its storefront and admin functionality through APIs. It also supports technology-agnostic admin apps and has extensive webhook/app mechanisms. saleor.io

The tradeoff is that you're buying into a more opinionated GraphQL architecture, whereas Medusa feels more natural if you want a TypeScript/REST/custom-backend environment.

Choose Saleor if: your team says "Give me a really good GraphQL commerce backend and let me build everything else."

3. 🏢 commercetools — strongest enterprise option

commercetools

For a serious enterprise composable-commerce architecture, I'd put commercetools at the top.

Its APIs are extensive and API-first, with both HTTP and GraphQL APIs. commercetools.com

It's particularly compelling if you're building a system with multiple services around commerce—CMS, PIM, ERP, CDP, search, pricing engines, custom B2B logic, multiple channels, etc.

The downside is complexity and cost. It's considerably more infrastructure/platform than I'd introduce for a straightforward custom storefront.

What I'd pick for your situation

If you're essentially saying:

"I'm going to build my own frontend. I don't want the commerce platform dictating my UI or architecture. I want APIs I can work with directly."

I'd rank them:

Medusa → Saleor → commercetools

But the distinction is important:

• TypeScript + maximum backend customization: → Medusa
• GraphQL-first frontend: → Saleor
• Large enterprise/composable architecture: → commercetools
• Commerce should mostly be someone else's operational problem: → Shopify
• Want SaaS but more API flexibility: → BigCommerce

One thing I'd not optimize for is simply "does it have an API?" Almost all modern headless platforms do. The more important question is how much of the commerce domain can you actually customize without fighting the platform.

For a custom frontend, I'd evaluate catalog modeling, pricing/promotions, checkout, customer accounts, inventory, webhooks/events, custom entities, authentication, and how easily you can introduce your own business logic. That's where the platforms diverge substantially. saleor.iocommercetools.comdocs.medusajs.com

If you tell me your stack (e.g. Next.js + TypeScript), database, expected traffic, B2C/B2B, and whether you need subscriptions/marketplace/multi-vendor, I can narrow this to a specific architecture and recommend the best one.

If flexibility + APIs are your top priorities and you're building the frontend yourself, I’d shortlist Medusa, Saleor, and commercetools. My default pick for a developer-led custom build would be Medusa.

1. 🥇 Medusa — my pick for maximum developer control

Medusa documentation

Medusa is particularly attractive if you're building your own frontend and potentially your own business logic. Its storefront is completely separate from the backend, and its Store API is REST-based. You can also add your own API routes, data models, workflows, and modules. docs.medusajs.com

The architecture is roughly:

Your Frontend
    │
    ├── REST / Store API
    ├── Custom API routes
    │
    ▼
Medusa
    │
    ├── Products
    ├── Cart
    ├── Checkout
    ├── Customers
    ├── Orders
    ├── Inventory
    └── Your custom modules

That's a very good fit if you're using Next.js, React, Vue, Svelte, mobile apps, or multiple frontends.

The big advantage is that you're not merely customizing someone else's commerce platform—you can actually extend the commerce engine itself.

2. 🥈 Saleor — best if you love GraphQL

Saleor

If your frontend architecture is heavily GraphQL-oriented, I'd seriously consider Saleor.

Saleor is API-only and GraphQL-native, with the entire storefront/admin experience sitting on top of its API. It also has webhooks, metadata, apps, API extensions, and native multi-channel support. github.com

That makes it particularly nice for a frontend like:

Next.js / React
       │
       │ GraphQL
       ▼
    Saleor
       │
       ├── Catalog
       ├── Pricing
       ├── Channels
       ├── Checkout
       ├── Orders
       └── Customers

I'd choose Saleor over Medusa if your team strongly prefers GraphQL and Python/Django isn't a problem.

3. 🥉 commercetools — best for serious enterprise commerce

commercetools

For a large enterprise with complicated pricing, catalogs, markets, B2B requirements, multiple channels, etc., commercetools is arguably the strongest option.

Its commerce APIs are explicitly designed to be consumed directly by custom frontends and integrations, with SDKs for several languages. docs.commercetools.com

The tradeoff is cost and complexity. I'd avoid it for a relatively simple store unless there's a compelling enterprise requirement.

What I'd choose

If I were building your stack today:

• Maximum control / developer experience → Medusa
• GraphQL-first architecture → Saleor
• Enterprise / complex B2B → commercetools
• Need Shopify's ecosystem and operational simplicity → Shopify headless
• Want a middle ground between Shopify and fully custom → BigCommerce

For a developer building a truly custom frontend, I wouldn't choose based primarily on storefront features. I'd evaluate:

1. Can I model my domain without fighting the platform?
2. Can I extend checkout/order/pricing logic?
3. How good are the APIs?
4. Can I consume everything without platform-specific frontend components?
5. How good are webhooks/events?
6. Can I use my own search, CMS, payments, tax, ERP, PIM, etc.?
7. Can I run multiple storefronts/channels from one backend?
8. Can I migrate away later?

On those criteria, Medusa and Saleor are particularly compelling because they're designed around API-first/headless usage rather than treating headless as an additional presentation layer. naturaily.com

My personal starting point: Next.js + Medusa + PostgreSQL + a headless CMS + dedicated search, unless you specifically want GraphQL everywhere—in which case I'd start with Saleor.

If you’re the developer building a genuinely custom frontend, I’d narrow it to Medusa, Saleor, Shopify, and commercetools. There isn’t one universal winner—the key question is how much of the commerce backend you want to own.

My ranking for flexibility + APIs

🥇 I'd pick Medusa for a developer-first custom frontend

Medusa documentation

If your priority is "I want the commerce engine to adapt to my application", rather than adapting your application to the commerce platform, Medusa is probably the most interesting choice.

Medusa v2 exposes REST Store APIs and lets you create your own API routes. It's also built around a modular backend, so you can extend/customize the commerce logic rather than treating the commerce platform as a black box. docs.medusajs.com

I'd especially consider it if you're building:

• Next.js/React frontend
• custom checkout
• unusual pricing/promotions
• marketplace-like functionality
• subscriptions or custom fulfillment
• complex integrations
• your own backend services around commerce
• a product where commerce is part of the application, rather than the entire application

The tradeoff is that you own more infrastructure and commerce complexity.

🥈 Saleor if you love GraphQL

Saleor is particularly attractive if your frontend architecture is strongly GraphQL-oriented. It's open source and gives you considerably more backend control than Shopify while avoiding some of the architectural work of building a commerce engine yourself.

I'd pick Saleor over Medusa if your team is already heavily invested in Python/Django and GraphQL.

🥉 Shopify if you want to minimize commerce infrastructure

Shopify developer documentation

Don't dismiss Shopify just because you're building headless. Its Storefront API is GraphQL and supports products, collections, carts, checkout, customers, contextual pricing, etc. Shopify explicitly supports using your own framework—including Next.js, Vue, or essentially any HTTP client. shopify.dev

The big advantage is that you get a very mature commerce backend/admin ecosystem while completely controlling the customer-facing frontend.

Shopify's current headless architecture also lets you use its Headless channel with the Storefront API and Customer Account API while bringing your own stack. shopify.dev

I'd choose Shopify when:

"I want a completely custom frontend, but I don't want to spend six months building/maintaining commerce infrastructure."

That's a very compelling proposition.

🏢 commercetools for serious enterprise composability

commercetools

If you're building a large-scale composable commerce architecture—multiple markets, currencies, catalogs, B2B pricing, ERP/PIM integrations, multiple channels, etc.—I'd put commercetools near the top.

But for a typical startup/custom storefront, I'd probably consider it excessive compared with Medusa or Shopify.

What I'd choose based on the architecture

Next.js + completely custom business logic + maximum control

→ Medusa

Next.js + GraphQL everywhere + Python team

→ Saleor

Next.js + custom UX + want mature commerce operations

→ Shopify

Enterprise + composable architecture + complex B2B/multimarket

→ commercetools

You want to essentially build your own commerce platform

→ Medusa

One important distinction: "headless" doesn't necessarily mean "flexible." Shopify is excellent at headless presentation, but you're still operating within Shopify's commerce model. Medusa/Saleor give you substantially more control over the underlying model and backend behavior.

For a developer starting a new custom frontend today, I'd personally prototype with Medusa and Shopify side-by-side. If Medusa's APIs and data model fit your requirements, its flexibility is hard to beat; if you find yourself recreating functionality Shopify already provides, Shopify will likely win on total engineering effort. powergatesoftware.com

If you tell me your stack (Next.js/Nuxt/etc.), B2C vs B2B, subscriptions/marketplace needs, and whether you want self-hosting), I can give you a much more concrete recommendation and architecture.

If flexibility + API quality are your top criteria, I’d shortlist Medusa, commercetools, and Saleor. My default pick for a developer building a truly custom frontend would be Medusa.

My pick: Medusa

For a custom frontend, Medusa is particularly attractive because the storefront is completely decoupled. You can build it with Next.js, React, Vue, native mobile, or essentially anything that can consume HTTP APIs. Its Store API is REST-based, and it also provides a JS SDK. docs.medusajs.com

The bigger advantage is that you're not limited to consuming a fixed commerce API. Medusa lets you add custom API routes, data models, workflows, and modules, so the backend can evolve around your application's domain rather than forcing your frontend to work around the platform. docs.medusajs.com

For example, if you need:

Custom React/Next.js frontend
        ↓
Your BFF / API layer
        ↓
Medusa
   ├── Products
   ├── Pricing
   ├── Cart
   ├── Orders
   ├── Inventory
   ├── Payments
   └── Your custom modules

that's a very natural architecture for Medusa.

When I'd choose commercetools instead

If this is enterprise-scale—multiple countries, B2B, complex catalogs/pricing, multiple storefronts/channels, lots of integrations—I'd seriously consider commercetools.

Its APIs are extremely mature and designed around composable commerce. It also has extensive API extensibility through custom fields, custom objects, API extensions, subscriptions, and states. Importantly, commercetools explicitly recommends a middleware layer when you're building a custom frontend because that gives you maximum control over the APIs. docs.medusajs.comdocs.commercetools.com

So:

Maximum developer freedom → Medusa
Maximum enterprise composability → commercetools

When Saleor makes more sense

If your team is strongly GraphQL-oriented, Saleor is compelling. Its API is GraphQL-first and its documentation exposes a substantial GraphQL API/reference plus extension and app mechanisms. docs.saleor.io

I'd put it ahead of Medusa if your team specifically wants GraphQL as the primary contract between frontend and commerce backend.

What I'd choose by project

• Startup / new product / highly custom UX: Medusa
• Custom marketplace or unusual commerce model: Medusa
• TypeScript/Node-heavy team: Medusa or Vendure
• GraphQL-first architecture: Saleor
• Large enterprise / B2B / multi-market: commercetools
• Need Shopify's ecosystem and merchant tooling: Shopify headless
• Want maximum backend ownership: Medusa or Saleor

One important distinction: "headless" doesn't automatically mean flexible. Shopify, for example, gives you an excellent headless frontend experience, but you're still operating within Shopify's commerce model. Medusa and commercetools are better choices if the commerce backend itself needs to be shaped around your application.

If you tell me your stack (Next.js/React/etc.), expected scale, B2C vs B2B, and whether you want self-hosted or SaaS, I can narrow this to a specific recommendation and architecture.

If your priority is maximum frontend flexibility + strong APIs, I’d shortlist these four:

My pick: Saleor

For a developer building a completely custom frontend, I'd lean Saleor.

It's genuinely API-first rather than a traditional ecommerce platform with a headless layer bolted on. The entire platform is accessible through GraphQL, and it supports webhooks, apps, metadata, API extensions, and granular permissions. It also supports multiple channels natively. github.com

That makes it particularly attractive if your architecture looks something like:

Next.js / React / native app → BFF → Saleor → payments / search / CMS / ERP

You aren't forced to use a particular frontend framework or proprietary storefront.

Saleor developer documentation

Medusa is the one I'd investigate next

Medusa may actually be better if by "flexibility" you mean "I want to modify the commerce engine itself."

Medusa gives you a Node.js-based framework where you can add data models, modules, workflows, API routes, and custom business logic. Its storefront APIs are REST-based, and you can use its JS SDK or call the REST APIs directly. docs.medusajs.com

So I'd characterize them:

• Saleor: "Give me a powerful commerce backend and let me compose around it."
• Medusa: "Give me a commerce framework that I can reshape."

Medusa documentation

commercetools if this is enterprise

commercetools is probably the strongest choice if you're building for a large organization with complex catalogs, markets, B2B, integrations, and multiple commerce channels.

It has both HTTP and GraphQL APIs, extensive API specifications/SDKs, and is designed explicitly around composable/headless architecture. docs.commercetools.com

The downside is that it's considerably more enterprise-oriented than Medusa or Saleor.

commercetools API documentation

Don't dismiss Shopify

If you want custom frontend without owning commerce infrastructure, Shopify is still compelling. Its Storefront API is GraphQL and supports products, collections, carts and checkout; Hydrogen gives you an official React-based headless stack. shopify.dev

But if your definition of flexibility includes changing the underlying commerce model/business logic, I'd choose Saleor or Medusa instead.

My decision rule:

• 🥇 Saleor → maximum API/frontend freedom with a mature commerce core
• 🥈 Medusa → maximum ability to customize the backend itself
• 🥉 commercetools → maximum enterprise/composable capability
• Shopify → maximum operational simplicity while retaining a custom frontend

If you tell me your stack (e.g. Next.js + TypeScript), expected scale, B2C/B2B, and whether you want to self-host, I can narrow this down to the best architecture for your project.

If your priorities are maximum frontend freedom + strong APIs + the ability to customize commerce logic, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for a developer-led custom build.

My recommendation: Medusa

For a developer building a custom frontend, I'd start with Medusa.

Its architecture is unusually developer-friendly: the storefront is completely separate from the commerce backend, and you can build your frontend with whatever stack you want. Medusa exposes Store APIs and lets you add your own API routes. docs.medusajs.com

The bigger advantage is that you're not limited to extending commerce through external APIs. Medusa's framework gives you modules, workflows, data models, and custom API routes, so custom business logic can live inside the commerce application rather than becoming a collection of middleware services. docs.medusajs.com

For example, if your business needs:

Custom React/Next.js frontend
          ↓
      Your BFF/API
          ↓
      Medusa APIs
       ↙       ↘
   Commerce   Custom modules
   modules      / workflows
       ↓
   PostgreSQL

that's a very natural architecture for it.

When I'd choose Saleor instead

Saleor is probably my #2 choice, and potentially #1 if GraphQL is a major requirement.

Saleor is GraphQL-native, headless, open source, and designed to work with essentially any frontend/BFF stack. It also provides extensive webhooks and extension mechanisms. docs.saleor.io

I'd pick it if your team is particularly comfortable with Python/Django + GraphQL and you want a very API-centric architecture.

When commercetools wins

commercetools becomes more attractive when you're building for a large enterprise with complicated B2B/B2C requirements, multiple markets, channels, or a genuinely composable architecture.

It advertises 500+ commerce APIs and a large integration ecosystem, with commerce functionality decomposed into composable services. commercetools.com

The downside is that you're buying enterprise infrastructure and complexity when you may not need it.

What I'd pick by scenario

• Next.js/React + TypeScript + highly custom product → Medusa
• GraphQL-first architecture → Saleor
• Enterprise, multinational, complex B2B → commercetools
• Want Shopify's ecosystem/operations but custom frontend → Shopify
• TypeScript + GraphQL + very deep backend customization → Vendure

If you're starting from scratch today, I'd lean Medusa unless you have a specific reason to prefer GraphQL (Saleor) or enterprise composability (commercetools). Its combination of TypeScript, REST APIs, modular commerce domains, custom workflows, and custom data models makes it particularly well suited to a developer-owned frontend/backend architecture. docs.medusajs.com

If you tell me your stack (Next.js/React/etc.), expected scale, B2B vs B2C, and whether you need subscriptions/multi-vendor/multi-region, I can narrow this down to a concrete architecture and recommend the API strategy I'd use.

If flexibility + APIs are your top priorities for a custom frontend, my shortlist in 2026 would be:

My pick: Saleor

For a developer building the frontend yourself, I'd lean toward Saleor.

It's genuinely API-first rather than a traditional ecommerce platform that happens to expose APIs. Its core API is GraphQL, and the platform exposes products, checkout, payments, shipping, promotions, channels, etc. through the API. It also supports webhooks, apps, metadata, API extensions, and dashboard extensions. docs.saleor.io

That makes a stack like:

Next.js / React → your BFF → Saleor GraphQL → your services

very natural.

Saleor documentation

But consider Medusa if you want to modify the commerce engine

Medusa is arguably even more flexible from a backend-engineering perspective.

Medusa is Node/TypeScript-oriented and gives you a framework for adding custom data models, workflows, modules, API routes, integrations, and event handlers. Its storefront is completely separate from the backend, so you're free to use essentially any frontend stack. docs.medusajs.com

Its Store API is REST/OpenAPI-based, which can also be attractive if you prefer conventional HTTP APIs over GraphQL. docs.medusajs.com

Medusa documentation

The decision I'd make

Choose Saleor if:

• Your frontend is heavily custom.
• You like GraphQL and generated TypeScript types.
• You want a clean API-only architecture.
• You expect multiple storefronts/channels.
• You want to extend commerce without forking the core.

Choose Medusa if:

• You're comfortable owning more backend code.
• Your business has unusual commerce logic.
• You want to build custom modules/workflows directly into the commerce backend.
• Your team is primarily TypeScript/Node.
• REST APIs are preferable.

Choose commercetools if:

• This is a large enterprise implementation.
• You need sophisticated B2B, pricing, markets, and composable architecture.
• Budget and operational complexity aren't major constraints.

Choose Shopify if:

• You want the easiest operational path.
• Checkout, payments, apps, and merchant tooling matter more than backend freedom.
• You're happy to work within Shopify's data/model constraints.

For a developer-first custom frontend

I'd rank them:

1. Saleor — best overall API-first choice
2. Medusa — best for maximum customization
3. commercetools — best enterprise option
4. BigCommerce — best pragmatic SaaS option
5. Shopify — best ecosystem/operations, not maximum backend flexibility

One important distinction: "headless" doesn't automatically mean "flexible." The thing I'd investigate hardest is whether the platform lets you change the commerce model and business logic, not merely whether it gives you a Storefront API.

If you tell me your stack (e.g. Next.js + TypeScript + PostgreSQL) and whether you're doing DTC, B2B, marketplace, subscriptions, or something unusual, I can narrow this down to 1–2 choices and compare the actual APIs/architecture.

If flexibility + API quality are your top priorities for a custom frontend, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for a developer-led custom build.

🥇 My pick: Medusa

For a developer building their own frontend, Medusa is particularly compelling because the storefront is completely separate from the commerce backend. You can use essentially any frontend stack and consume its Store APIs or your own custom API routes. docs.medusajs.com

More importantly, you're not just customizing the frontend—you can customize the commerce engine itself. Medusa's framework lets you add API routes, workflows, data models, modules, integrations, and event subscribers. docs.medusajs.com

The current v2 API is REST-based and has separate Store and Admin APIs, with an OpenAPI specification available for tooling. docs.medusajs.com

So if you're building something like:

Your Next.js / React / Vue / mobile frontend
                 ↓
            Your BFF/API
                 ↓
        ┌─────────────────┐
        │     Medusa      │
        │                 │
        │ products        │
        │ carts           │
        │ customers       │
        │ orders          │
        │ pricing         │
        │ inventory       │
        │ fulfillment     │
        └─────────────────┘
          ↓       ↓      ↓
       Stripe    ERP    Custom services

…it gives you a lot of room to make the architecture your own.

Medusa documentation

🥈 Saleor if you want GraphQL

I'd choose Saleor over Medusa if your team strongly prefers GraphQL.

Saleor is genuinely API-first: its core API is GraphQL-only, and its storefront/admin functionality is designed to be consumed through APIs rather than a traditional monolithic frontend. It also has native multichannel support and extensive webhook/app extension capabilities. saleor.io

That's especially attractive if your frontend is heavily typed and you want queries like:

query Product($slug: String!) {
  products(filter: { slug: $slug }) {
    edges {
      node {
        id
        name
        pricing {
          priceRange {
            start {
              gross {
                amount
                currency
              }
            }
          }
        }
        variants {
          id
          name
        }
      }
    }
  }
}

rather than stitching together REST endpoints.

Saleor documentation

🏢 commercetools if you're building enterprise commerce

If this is a large-scale B2B/B2C system, especially with multiple markets, catalogs, pricing systems, currencies, regions, and external services, I'd seriously consider commercetools.

The tradeoff is complexity and cost. You're buying into a composable enterprise platform rather than getting a lightweight commerce engine you can bend however you want.

What I'd choose

Small/medium developer team + maximum control:
→ Medusa

GraphQL-first architecture:
→ Saleor

Enterprise / complex composable architecture:
→ commercetools

You want Shopify's ecosystem but your own frontend:
→ Shopify

One important distinction: "headless" doesn't automatically mean "flexible." Shopify is excellent at headless storefronts, but Medusa/Saleor give you substantially more control over the commerce backend itself.

If you tell me your stack (e.g. Next.js + TypeScript + Postgres) and whether you need B2B, subscriptions, multi-vendor, multi-region, or just standard DTC, I can narrow this down to a specific architecture and recommend the API approach I'd use.