ChatGPT answers, unedited

If the goal is a static frontend talking to a self-hosted commerce backend entirely through APIs, I'd shortlist these three:

My practical pick: Medusa

docs.medusajs.com

For a static site, Medusa is probably the simplest starting point. Its Store API is explicitly designed for storefronts and mobile apps, and the current API is REST-based with an OpenAPI specification available. Medusa Docs

A typical architecture would be:

Static site
  │
  │ REST / HTTPS
  ▼
Medusa
  ├── Products
  ├── Pricing
  ├── Cart
  ├── Customers
  ├── Orders
  ├── Inventory
  └── Payments
       │
       ├── PostgreSQL
       └── Payment provider

That works particularly nicely if your frontend is Astro, Next.js, React, Vue, or plain HTML/JS. Your static site doesn't need to know anything about the backend implementation.

When I'd choose the others

Saleor is compelling if you specifically want GraphQL. It has a Python/Django core and is designed around a GraphQL-first API. Eryx Innovations Lab Vendure

Vendure is worth considering if your team is heavily TypeScript-oriented but prefers GraphQL + a structured plugin architecture. It's built on NestJS and exposes GraphQL APIs. Eryx Innovations Lab Vendure

One important distinction is licensing: Medusa's core is MIT, Saleor's core API is BSD-3-Clause, while Vendure's core is GPLv3 with a commercial layer, so I'd have your team check the exact components/licenses before committing. Pawel Owerczuk Vendure

So, if you tell me your frontend stack (Astro/Next/plain HTML/etc.), whether you need subscriptions/B2B/multiple stores, and where you plan to deploy it, I can narrow this down to the architecture I'd use.

For a static/headless storefront where the backend is primarily an API, I’d narrow it to Medusa, Saleor, and Vendure. All three are designed for decoupled storefronts. Vendure

My take

1. Medusa — probably my first choice for your setup

Medusa is particularly well suited if your static site is built with JavaScript/TypeScript.

Its V2 Store API is REST, has an OpenAPI specification, and is explicitly intended for storefronts and mobile apps. It also supports publishable API keys designed for client-side storefronts. Medusa Documentation Medusa Documentation

The architecture is modular—you get products, carts, customers, inventory, orders, payments, promotions, fulfillment, etc., while being able to extend the modules and API. Medusa Documentation

Good architecture:

Static site → Medusa Store API → PostgreSQL

That makes it quite natural for something like Astro, Next.js static export, Gatsby, or a plain JS site.

docs.medusajs.com

2. Saleor — excellent if you want GraphQL

Saleor is very API-centric and GraphQL-native. Its API covers catalog, checkout, channels, promotions, payments, shipping, etc., and it has extensive webhook/app mechanisms for integrations. Saleor Documentation Saleor Commerce

I'd lean toward Saleor if you expect your storefront to make sophisticated, highly tailored GraphQL queries or you expect multi-region/multi-currency, multiple sales channels, marketplaces, or complex commerce integrations.

saleor.io

3. Vendure — great TypeScript alternative

Vendure is built with TypeScript/NestJS and exposes GraphQL Shop and Admin APIs. Its core is explicitly positioned as a framework for developers building custom ecommerce applications. Vendure Vendure

It's attractive if your backend team is already heavily invested in Node.js + TypeScript + GraphQL, especially when you'll be extending the commerce model substantially.

vendure.io

What I'd choose

For the specific phrase "plug into our static site", I'd start with Medusa unless you have a strong reason to prefer GraphQL.

The deciding factors I'd use are:

• Static/Jamstack + REST + TypeScript: Medusa
• GraphQL-first + sophisticated/headless architecture: Saleor
• TypeScript + GraphQL + substantial backend customization: Vendure

One particularly important distinction: don't choose based solely on whether the product has an API. Look closely at checkout, authentication, payments, webhooks, inventory, search, tax/shipping, and how easily you can customize those without modifying/forking the core.

If you tell me your stack (Astro / Next.js / plain HTML+JS / Hugo / etc.) and whether you need Stripe, subscriptions, digital products, or physical shipping, I can narrow this down to an architecture and API choice.

Its V2 Store API is REST, has an OpenAPI specification, and is explicitly intended for storefronts and mobile apps. It also supports publishable API keys designed for client-side storefronts. Medusa Documentation Medusa Documentation

The architecture is modular—you get products, carts, customers, inventory, orders, payments, promotions, fulfillment, etc., while being able to extend the modules and API. Medusa Documentation

Good architecture:

Static site → Medusa Store API → PostgreSQL

That makes it quite natural for something like Astro, Next.js static export, Gatsby, or a plain JS site.

docs.medusajs.com

2. Saleor — excellent if you want GraphQL

Saleor is very API-centric and GraphQL-native. Its API covers catalog, checkout, channels, promotions, payments, shipping, etc., and it has extensive webhook/app mechanisms for integrations. Saleor Documentation Saleor Commerce

I'd lean toward Saleor if you expect your storefront to make sophisticated, highly tailored GraphQL queries or you expect multi-region/multi-currency, multiple sales channels, marketplaces, or complex commerce integrations.

saleor.io

3. Vendure — great TypeScript alternative

Vendure is built with TypeScript/NestJS and exposes GraphQL Shop and Admin APIs. Its core is explicitly positioned as a framework for developers building custom ecommerce applications. Vendure docs.vendure.io

It's attractive if your backend team is already heavily invested in Node.js + TypeScript + GraphQL, especially when you'll be extending the commerce model substantially.

Yes. If the requirement is “open-source commerce backend + API-first + static/headless frontend”, I’d shortlist Medusa, Saleor, and Vendure. They’re all designed for headless use rather than being traditional storefronts with an API bolted on. Vendure

My recommendation: Medusa

docs.medusajs.com

For a typical static site built with Astro, Next.js, Nuxt, plain React, etc., I’d choose Medusa first.

• REST API — Medusa's Store API is explicitly intended for building custom storefronts and mobile apps. Medusa Docs
• TypeScript/Node.js — particularly nice if your frontend is also JavaScript/TypeScript.
• Headless by design — products, carts, customers, orders, payments, shipping, etc. live in the backend.
• Extensible — you can add your own commerce logic without turning the frontend into a monolith.
• MIT licensed, which is attractive if you're building a commercial product. Kryeo
• You can self-host it and put your static site on a CDN independently.

A simple architecture would be:

                    ┌──────────────────┐
                    │   Static Site    │
                    │ Astro / Next /   │
                    │ React / etc.     │
                    └────────┬─────────┘
                             │
                         REST API
                             │
                    ┌────────▼─────────┐
                    │     Medusa       │
                    │ Commerce Backend │
                    └────┬────┬────┬───┘
                         │    │    │
                    PostgreSQL Redis Payments

The alternatives

Saleor is particularly compelling if you specifically want GraphQL. Its documentation describes it as a GraphQL-native, API-only commerce platform, with strong support for multi-channel commerce, checkout, payments, and internationalization. GitHub Saleor Documentation

docs.saleor.io

Vendure is my other strong recommendation if you're a TypeScript team. Its Shop API is GraphQL and exposes products, collections, customers, carts, checkout, and accounts; its plugin architecture also makes extending the API unusually clean. Vendure Vendure

docs.vendure.io

The important caveat with Vendure is its current GPLv3 core license, versus Medusa's MIT license and Saleor's BSD-3-Clause core. GitHub Kryeo

What I'd pick

For most new static-site projects: Medusa.

Pick Saleor instead if:

• GraphQL is a hard requirement.
• You need sophisticated multi-channel/B2B functionality.
• Your team is comfortable with Python/Django.

Pick Vendure instead if:

• Your team is heavily TypeScript/NestJS oriented.
• You want GraphQL.
• You expect to build substantial custom commerce functionality through plugins.

If you tell me what your static site is built with (Astro, Next.js, Hugo, plain HTML, etc.) and whether you need Stripe, subscriptions, variants, inventory, or multi-vendor, I can narrow this down to the best architecture and API for your specific stack.

docs.saleor.io

Vendure is my other strong recommendation if you're a TypeScript team. Its Shop API is GraphQL and exposes products, collections, customers, carts, checkout, and accounts; its plugin architecture also makes extending the API unusually clean. docs.vendure.io docs.vendure.io

Yes. If the goal is a static frontend that talks to a self-hosted commerce backend entirely through APIs, I’d shortlist Medusa, Saleor, and Vendure. They’re all designed around headless/composable architectures. Vendure Saleor Commerce

My pick: Medusa

medusajs.com is probably the best default for your use case.

• API-first: its Store API is REST, with an OpenAPI spec and JS SDK. Medusa Documentation
• TypeScript/Node.js: particularly nice if your static site is React/Next.js/Astro/etc.
• Modular: products, carts, orders, payments, fulfillment, pricing, etc. can be customized without turning the frontend into a monolith.
• MIT license: permissive if you want to build proprietary functionality around it.
• Self-hostable: you control the database and backend.
• Your static site can remain genuinely static; it just calls Medusa's API for dynamic commerce operations.

A typical architecture would be:

Static site
(Astro / Next.js / React / plain HTML)
             |
             | HTTPS / REST API
             v
        Medusa backend
             |
       +-----+------+
       |            |
   PostgreSQL     Redis
       |
       +-- Payments
       +-- Shipping
       +-- Email
       +-- Search

How I'd rank them

Saleor is particularly compelling if you want GraphQL as the fundamental interface. Its API is GraphQL-first, with extensive webhooks and a composable architecture. Saleor Commerce Saleor Commerce

Vendure is the one I'd investigate if your backend team is strongly TypeScript/NestJS-oriented. Its Shop API is GraphQL and covers products, carts, checkout, customers, etc. Vendure Vendure

What I'd choose

If you tell me:

"We have a static Astro/Next/React site, want products + cart + checkout + orders, and don't want WordPress or Shopify."

I'd start with Medusa.

If you tell me:

"We have complicated B2B pricing, multiple channels/warehouses, and want GraphQL everywhere."

I'd look hard at Saleor.

If you tell me:

"We're a TypeScript/NestJS team and expect to heavily customize the commerce engine."

I'd look at Vendure.

The important distinction is that you don't need your frontend to be dynamically rendered by the commerce platform. These systems can act purely as the commerce/API layer behind your static site. Medusa Documentation Vendure

If you give me your frontend stack, expected product count, B2C vs B2B, and whether you need Stripe/PayPal, I can narrow this to one and outline the exact architecture.

If your goal is a static site + separate ecommerce backend exposed through APIs, my first choice would be Medusa.

My shortlist

1. medusajs.com — my pick

Medusa is particularly well suited to your architecture because its Store API is explicitly designed for building a separate storefront. Its current v2 API is REST-based and has a JS SDK, so your static frontend can simply call the backend over HTTP. Medusa Documentation

For example:

Static site
   │
   ├── Product pages ──────┐
   ├── Cart ───────────────┤
   └── Checkout ───────────┤
                           ▼
                    Medusa API
                           │
                 ┌─────────┼─────────┐
                 ▼         ▼         ▼
              Products   Orders   Payments

That's a very natural fit if your frontend is Astro, Next.js, Nuxt, plain React, etc.

Why I'd choose it:

• TypeScript/Node.js end-to-end
• REST API is straightforward from a static frontend
• JS SDK available
• Modular backend architecture
• PostgreSQL
• Self-hostable
• MIT-licensed core
• Good choice if you're going to add custom business logic

The biggest advantage is that you aren't fighting a traditional ecommerce CMS to make it headless.

2. saleor.io — choose this for GraphQL

Saleor is excellent if you specifically want a GraphQL-first architecture. Its API covers products, checkout, channels, promotions, payments, etc., and it has a substantial extension/app model. Saleor Documentation

I'd favor Saleor when you have requirements such as:

• Multiple storefronts/channels
• Multiple currencies/regions
• Complex B2B
• Advanced inventory/warehouse requirements
• A team already comfortable with Python + GraphQL

The tradeoff is that you're operating a Python/Django backend rather than staying entirely in the JS/TS ecosystem.

3. vendure.io — excellent TypeScript alternative

Vendure is probably the strongest alternative to Medusa if you want TypeScript.

Its Shop API is GraphQL and exposes products, collections, customers, carts and checkout operations directly to a separate storefront. Vendure

I'd choose Vendure over Medusa if you particularly like:

• NestJS architecture
• GraphQL
• A more opinionated plugin architecture
• Complex B2B/omnichannel requirements

The important difference is licensing: Vendure's open-source core is GPLv3, whereas Medusa's core is MIT. Vendure

What I'd pick

For a new static/headless site, I'd rank them:

1. Medusa — best default
2. Vendure — best if you want GraphQL + NestJS
3. Saleor — best if you're Python/GraphQL-oriented or need more enterprise commerce functionality
4. WooCommerce — best if WordPress/plugin ecosystem is important

If you tell me what your static frontend is built with (Astro, Next.js, plain HTML, etc.), expected number of products, and whether you need subscriptions/B2B/multiple currencies, I can narrow this down to the best architecture and show you what the API integration would look like.

Yes. For a static/headless frontend, I’d shortlist Medusa, Saleor, and Vendure rather than traditional platforms like WooCommerce or Magento. All three are designed to expose commerce functionality through APIs.

My pick: Medusa

Medusa is probably the best default if your team is building a modern static site with React/Next.js/Astro/etc.

• API: REST Store API, plus a JS SDK.

Yes. For a static frontend + API-driven commerce backend, I’d shortlist three:

My pick: Medusa

Medusa is probably the best match if your site is already static/JS-based. Its commerce backend is designed to be consumed by an independent storefront, and its REST API is straightforward to call from a static site or serverless functions. pkgpulse WP Bundle

The architecture would look roughly like:

Static site
   │
   ├── Product pages ──────┐
   ├── Cart ───────────────┤
   ├── Checkout ───────────┤
   └── Account ────────────┤
                           ▼
                    Medusa API
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
          PostgreSQL    Payments     Shipping

That gives you freedom to build the frontend in Astro, Next.js, Nuxt, plain React, or even vanilla JS without tying the presentation layer to the commerce system.

When I'd choose the others

Saleor is particularly attractive if you want a GraphQL-first architecture. Its API covers products, checkout, channels, payments, etc., and its documentation is centered around GraphQL. Saleor Documentation

Vendure is my other strong recommendation if your team is TypeScript-heavy. Its Shop API is GraphQL and handles products, collections, customers, carts and checkout; it also has a substantial plugin/extension architecture. Vendure Vendure

Quick decision

• Static site + JavaScript/TypeScript + REST: → Medusa
• Static site + GraphQL + complex commerce: → Saleor
• Static site + TypeScript + GraphQL + lots of custom backend logic: → Vendure
• Want the least coupling to your frontend: → any of the three; they're genuinely headless.

For a typical Astro/Next.js static storefront selling physical products, I'd start with Medusa. If you tell me your frontend stack and whether you need things like Stripe, subscriptions, variants, inventory, customer accounts, or multiple stores, I can narrow it down to one and sketch the exact architecture.

Medusa is probably the best match if your site is already static/JS-based. Its commerce backend is designed to be consumed by an independent storefront, and its REST API is straightforward to call from a static site or serverless functions. pkgpulse WP Bundle

The architecture would look roughly like:

Static site
   │
   ├── Product pages ──────┐
   ├── Cart ───────────────┤
   ├── Checkout ───────────┤
   └── Account ────────────┤
                           ▼
                    Medusa API
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
          PostgreSQL    Payments     Shipping

That gives you freedom to build the frontend in Astro, Next.js, Nuxt, plain React, or even vanilla JS without tying the presentation layer to the commerce system.

When I'd choose the others

Saleor is particularly attractive if you want a GraphQL-first architecture. Its API covers products, checkout, channels, payments, etc., and its documentation is centered around GraphQL.

Vendure is my other strong recommendation if your team is TypeScript-heavy. Its Shop API is GraphQL and handles products, collections, customers, carts and checkout; it also has a substantial plugin/extension architecture.

Quick decision

Yes. If your frontend is a static site and you want the ecommerce backend exposed cleanly over APIs, I’d shortlist Medusa, Saleor, and Vendure rather than traditional platforms like WooCommerce.

My recommendation: Medusa

docs.medusajs.com is probably the best default for your use case.

Why I'd pick Medusa: its Store API is explicitly designed for external storefronts and mobile apps, and it provides REST endpoints plus an official JS SDK. You can have your static frontend call the commerce backend without coupling the frontend to the backend's rendering system. Medusa Docs Medusa Docs

That makes an architecture like this straightforward:

Static site
   │
   ├── Products ──────┐
   ├── Cart ──────────┤
   ├── Checkout ──────┤
   └── Customer ──────┤
                      ▼
                Medusa API
                      │
             ┌────────┴────────┐
             │                 │
         PostgreSQL        Payment provider

When I'd choose the others

Saleor is my pick if you specifically want GraphQL everywhere. Its API is GraphQL-first, with products, checkout, channels, payments, etc. exposed through the GraphQL API. It's particularly compelling for multi-channel or more sophisticated commerce requirements. Saleor Documentation Saleor Commerce

Vendure is excellent if your team is heavily invested in TypeScript/NestJS but prefers GraphQL. Its Shop API handles products, collections, carts, checkout and customer accounts, and its plugin system lets you extend the API itself. Vendure Vendure

The short version

• Static site + REST + TypeScript/JavaScript → Medusa
• Static site + GraphQL + sophisticated/multichannel commerce → Saleor
• Static site + TypeScript + GraphQL + highly customizable backend → Vendure

If you're using something like Astro, Hugo, Eleventy, plain HTML, or Next.js exported statically, I'd lean Medusa unless you have a strong reason to prefer GraphQL.

If you tell me your frontend stack (e.g. Astro + Stripe, Next.js, Eleventy, etc.) and whether you need subscriptions, inventory, variants, customer accounts, or just products + checkout, I can narrow it down to the best architecture.

That makes an architecture like this straightforward:

Static site
   │
   ├── Products ──────┐
   ├── Cart ──────────┤
   ├── Checkout ──────┤
   └── Customer ──────┤
                      ▼
                Medusa API
                      │
             ┌────────┴────────┐
             │                 │
         PostgreSQL        Payment provider

When I'd choose the others

Saleor is my pick if you specifically want GraphQL everywhere. Its API is GraphQL-first, with products, checkout, channels, payments, etc. exposed through the GraphQL API. It's particularly compelling for multi-channel or more sophisticated commerce requirements.

Vendure is excellent if your team is heavily invested in TypeScript/NestJS but prefers GraphQL. Its Shop API handles products, collections, carts, checkout and customer accounts, and its plugin system lets you extend the API itself.

If the goal is “static frontend + API-only commerce backend”, I’d shortlist Medusa, Saleor, and Vendure. They’re all designed for headless use rather than retrofitting a traditional storefront. Vendure OpenReplay Blog

My pick: Medusa

Medusa would be my default choice for a new project, especially if your team is JavaScript/TypeScript-heavy.

• TypeScript/Node.js backend, so it fits naturally with a modern static/React/Next.js stack.
• Modular architecture—you can customize commerce logic without turning the frontend into a monolith.
• APIs for products, carts, customers, orders, payments, shipping, etc.
• MIT licensed, which is attractive if you want maximum freedom to self-host and customize.
• You can keep the frontend completely separate: static site → API → Medusa → database/payment providers. OSSAlt Vendure

medusajs.com

When I'd choose the others

Saleor is particularly compelling if you specifically want GraphQL. Its architecture is genuinely API-only/headless, with multi-channel capabilities and webhooks/apps for extending the backend. GitHub Saleor Commerce

saleor.io

Vendure is another excellent TypeScript option. It uses NestJS and GraphQL and has a strong plugin architecture, making it attractive if you expect substantial custom commerce logic. GitHub Vendure

vendure.io

What I'd use for your architecture

Static site
   │
   │ HTTPS / REST or GraphQL
   ▼
Medusa
   │
   ├── PostgreSQL
   ├── Stripe / payment provider
   ├── Shipping provider
   └── Email / webhooks

The big advantage is that your static site doesn't need to know anything about the database or commerce internals. It just calls the commerce API.

If you tell me what your static frontend is built with (plain HTML, Astro, Next.js, Hugo, etc.) and whether you need subscriptions/B2B/multiple currencies, I can narrow this down to the best choice and show the exact API architecture I'd use.

Yes. For a static-site frontend that talks to an ecommerce backend entirely through APIs, I’d shortlist Medusa, Saleor, and Vendure. They’re all designed for headless/composable commerce. Vendure OpenReplay Blog

My pick: Medusa

Medusa would be my default choice if your frontend is something like Astro, Next.js, plain React, or another static/Jamstack setup.

Medusa's big advantage is that it feels like a commerce backend rather than a website platform. Your static site can fetch products, create carts, handle checkout, retrieve orders, etc., without needing WordPress or a traditional storefront. Current comparisons also put Medusa ahead for JavaScript/TypeScript teams wanting a modular OSS foundation. Vendure OSSAlt

When I'd choose the others

Saleor — choose this if you specifically want GraphQL and expect sophisticated multi-channel, international, B2B, or catalog requirements. Its API is GraphQL-first and its documentation exposes the API reference and commerce operations directly. Saleor Documentation

Vendure — particularly attractive if your team is heavily invested in TypeScript/NestJS and wants a highly extensible commerce framework. Its Shop API is GraphQL and covers products, customers, carts, checkout, and accounts; it also has a plugin system for extending the API. Vendure Developer Hub Vendure Developer Hub

What I would build

For a relatively normal store, I'd use:

Static site
(Astro / Next.js / React / etc.)
          │
          │ HTTPS API
          ▼
      Medusa
          │
     PostgreSQL
          │
   ┌──────┼────────┐
   ▼      ▼        ▼
 Stripe  Email   Search

The frontend stays static/fast, while Medusa handles the stateful stuff: products, prices, carts, customers, orders, payments and fulfillment.

One important distinction: don't pick WooCommerce just because it's the most established open-source ecommerce system. It's excellent if you want WordPress, but for a new API-driven static frontend, Medusa/Saleor/Vendure are much more naturally aligned with the architecture. Wpbundle

Bottom line:

• Medusa → best default for a modern static/JS frontend.
• Saleor → best if GraphQL + complex commerce is the priority.
• Vendure → best if you want a TypeScript-native, highly extensible commerce framework.

If you tell me what your static site is built with (Astro, Next.js, Hugo, plain HTML, etc.) and whether you need Stripe, subscriptions, variants, accounts, or multi-vendor, I can narrow it down to one and sketch the API architecture.

Medusa's big advantage is that it feels like a commerce backend rather than a website platform. Your static site can fetch products, create carts, handle checkout, retrieve orders, etc., without needing WordPress or a traditional storefront. Current comparisons also put Medusa ahead for JavaScript/TypeScript teams wanting a modular OSS foundation. Vendure OSSAlt

When I'd choose the others

Saleor — choose this if you specifically want GraphQL and expect sophisticated multi-channel, international, B2B, or catalog requirements. Its API is GraphQL-first and its documentation exposes the API reference and commerce operations directly. Saleor Documentation

Vendure — particularly attractive if your team is heavily invested in TypeScript/NestJS and wants a highly extensible commerce framework. Its Shop API is GraphQL and covers products, customers, carts, checkout, and accounts; it also has a plugin system for extending the API. docs.vendure.io docs.vendure.io

What I would build

For a relatively normal store, I'd use:

Static site
(Astro / Next.js / React / etc.)
          │
          │ HTTPS API
          ▼
      Medusa
          │
     PostgreSQL
          │
   ┌──────┼────────┐
   ▼      ▼        ▼
 Stripe  Email   Search

The frontend stays static/fast, while Medusa handles the stateful stuff: products, prices, carts, customers, orders, payments and fulfillment.

One important distinction: don't pick WooCommerce just because it's the most established open-source ecommerce system. It's excellent if you want WordPress, but for a new API-driven static frontend, Medusa/Saleor/Vendure are much more naturally aligned with the architecture.

Bottom line:

For a static site + API-driven ecommerce backend, I would shortlist Medusa, Saleor, and Vendure. They are all designed for headless builds rather than traditional theme-based stores. OpenReplay Blog Vendure

My recommendation depends on your stack:

1. Medusa — best default choice for modern web stacks

Best if: your frontend is Next.js, React, Astro, Vue, Svelte, etc., and your team likes JavaScript/TypeScript.

Why it stands out:

• API-first architecture
• Node.js + TypeScript backend
• REST APIs plus SDKs
• Flexible modules for products, carts, orders, payments, fulfillment
• Easy to extend with custom business logic
• MIT license (friendly for commercial projects) Vendure

Good fit:

• Custom storefronts
• DTC brands
• Startups
• Static site generators consuming commerce APIs

Tradeoffs:

• You may build more custom features yourself compared with older ecommerce suites
• Less "everything included" than Magento/WooCommerce

My pick for most teams building a static frontend today: Medusa.

2. Saleor — best API design if you like GraphQL

Best if: your team prefers GraphQL and Python/Django.

Strengths:

• GraphQL-first API
• Strong product/catalog modeling
• Good support for multi-channel, inventory, and complex commerce setups
• Mature admin experience Vendure WP Bundle

Tradeoffs:

• Python stack
• More infrastructure complexity
• May feel heavier for a small storefront

A good choice for:

• Enterprise-ish catalogs
• Multiple storefronts
• B2B commerce

3. Vendure — best for TypeScript teams needing structure

Best if: you want a strongly structured TypeScript commerce framework.

Strengths:

• TypeScript/NestJS
• GraphQL API
• Plugin architecture
• Good fit for complex workflows and B2B scenarios Vendure

Tradeoffs:

• Smaller ecosystem than some competitors
• Licensing/open-core considerations may matter depending on how you extend it Vendure

Quick comparison

OpenReplay Blog OSSAlt## For a static site specifically, I would choose:

• Astro/Next.js + custom storefront → Medusa
• Need GraphQL everywhere → Saleor
• Large TypeScript engineering team → Vendure
• Need thousands of existing merchant plugins → WooCommerce (headless mode)

A common architecture would be:

Static frontend (Astro / Next.js)
        |
        | API calls
        ↓
Headless commerce backend (Medusa/Saleor/Vendure)
        |
        ├── PostgreSQL
        ├── Payment provider (Stripe, etc.)
        ├── Shipping provider
        └── CMS (optional)

If you tell me your frontend stack (Astro, Next.js, Hugo, plain HTML, etc.), catalog size, and whether you need subscriptions/B2B/multi-vendor, I can narrow it to one.

If your storefront is static (Astro, Next.js static export, plain HTML, etc.) and you want the backend to be purely commerce/API, I’d shortlist Medusa, Saleor, and Vendure. They’re all designed for headless use. Vendure OpenReplay Blog

My pick: medusajs.com

Medusa is probably the best default for your setup, especially if your team is comfortable with JavaScript/TypeScript.

• REST API designed specifically for storefronts and mobile apps. Medusa Documentation
• TypeScript/Node.js, so it's a natural fit with modern JS frontends.
• Modular architecture—you can add/customize payments, shipping, pricing, inventory, etc.
• MIT licensed, which is very permissive for commercial projects. Vendure
• Your static site can simply call the commerce API for products, carts, checkout, customer accounts, etc.
• You can self-host the backend independently of the frontend.

How I'd rank them

Saleor is particularly compelling if you want GraphQL as your primary API and have Python expertise; its API is explicitly GraphQL-first and it supports extensive webhooks/extensions. Saleor Saleor

Vendure is another excellent TypeScript choice, particularly for B2B, multi-channel, and highly customized commerce. Its Shop API is GraphQL and handles products, customers, carts, checkout, and accounts. docs.vendure.io docs.vendure.io

For your architecture

I'd do:

Static site
   │
   │ HTTPS / REST
   ▼
Medusa
   │
   ├── PostgreSQL
   ├── Redis
   ├── Payment provider
   ├── Shipping
   └── Email / webhooks

The important point is that the frontend doesn't need to be hosted alongside the ecommerce backend. Your static site can live on a CDN, while Medusa runs separately as the commerce API.

Bottom line: choose Medusa unless you specifically want GraphQL (→ Saleor) or have unusually complex B2B/multi-channel requirements (→ Vendure). For a straightforward static-site + API architecture, Medusa is the one I'd start with. Vendure Medusa Documentation

If you tell me what your static site is built with (Astro, Next.js, Hugo, plain HTML, etc.) and whether you need Stripe, subscriptions, variants, inventory, or customer accounts, I can narrow it down further.

For a static site + API-driven ecommerce backend, I’d focus on platforms that were designed as headless commerce engines, not traditional storefronts with an API bolted on. The strongest open-source choices today are usually:

Medusa, Saleor, and Vendure. OpenReplay Blog Vendure

My shortlist

Vendure ShipGarden## My default recommendation: Medusa

For a static frontend (Astro, Next.js static export, Gatsby, Eleventy, custom React, etc.), I would usually start with Medusa.

Why:

• Built specifically for headless commerce
• TypeScript end-to-end (nice if your frontend is JS/TS)
• Good fit for custom storefronts
• Modular backend (products, carts, payments, fulfillment can be extended)
• Self-hostable with no SaaS lock-in

A typical architecture:

Static site
    |
    | REST/API calls
    |
Medusa backend
    |
PostgreSQL
    |
Payment + shipping providers

Vendure## When I would choose Saleor instead

Pick Saleor if you need things like:

• Multiple warehouses
• Multiple sales channels
• Complex pricing rules
• Strong GraphQL workflows
• A more enterprise-style commerce model

The tradeoff is that it is a Python/Django backend, so it may not fit as naturally if your team is entirely JavaScript/TypeScript. Designodin

When I would choose Vendure

Pick Vendure if:

• Your team already uses NestJS/TypeScript
• You expect heavy customization
• You like a plugin-based architecture

It is a strong engineering choice, especially for teams that want to extend the platform deeply. Vendure

Platforms I would be cautious about for a new headless build

• WooCommerce: excellent ecosystem, but the core model is WordPress-first rather than API-first. Good if you already need WordPress.
• Magento/Open Source: powerful, but usually too heavy unless you have enterprise requirements.
• PrestaShop: better as a traditional store platform than a pure headless backend.

Quick decision rule

• Next.js/Astro/static frontend + small/medium team → Medusa
• Enterprise catalog/B2B complexity → Saleor
• TypeScript/NestJS engineering team → Vendure
• Need a CMS too → pair one of these with a headless CMS like Strapi, Payload CMS, or Sanity

If you tell me your frontend stack (Astro/Next/etc.), expected catalog size, and whether you need subscriptions, B2B pricing, or multiple warehouses, I can narrow it to one.

For a static site (Astro, Next.js static export, Gatsby, Hugo, plain HTML + JS, etc.), you want a headless-first commerce backend with a strong API, webhooks, and easy customization. The best choice depends on your stack, but the current shortlist is usually:

OpenReplay Blog Vendure## My recommendation

Choose Medusa if:

• Your frontend is React/Next.js/Astro/Svelte/etc.
• Your team prefers JavaScript/TypeScript.
• You want to build custom checkout, subscriptions, bundles, marketplaces, or unusual flows.
• You want the backend to feel like a commerce API rather than a CMS.

Medusa is often the easiest fit because your frontend and backend can share the same language ecosystem. ShipGarden

Typical architecture:

Static Site
   |
   | REST API / SDK
   |
Medusa Backend
   |
PostgreSQL
   |
Payments / Shipping / Tax providers

Choose Saleor if:

• You love GraphQL.
• You have complicated product data.
• You need multi-channel, multi-region, warehouse, or B2B features.
• Your team is comfortable operating Python/Django.

Saleor’s GraphQL-only approach is attractive for frontend teams that want a single strongly typed API surface. WPBundle

Choose Vendure if:

• Your developers already use NestJS/TypeScript.
• You expect lots of custom plugins and domain logic.
• You want a more structured backend framework.

Vendure## I would avoid starting with Magento/Open Source or WooCommerce for a new static-site build unless you have a specific reason:

• Magento is powerful but operationally heavy.
• WooCommerce has an enormous plugin ecosystem, but its architecture is still WordPress-centric rather than headless-native. WPBundle

A practical shortlist

For most teams building a static frontend today:

1. Medusa — best general-purpose headless backend.
2. Saleor — best GraphQL commerce API.
3. Vendure — best TypeScript enterprise-style framework.

If you tell me your frontend stack (Astro/Next/Vue/etc.), product complexity (simple catalog vs variants/subscriptions/B2B), and whether you need an admin UI for non-developers, I can narrow it down.

If the requirement is “headless backend + static site + strong APIs + open source”, I’d shortlist Medusa, Saleor, and Vendure. All three are genuinely designed to be decoupled from the storefront. Vendure OSSAlt

My pick: Medusa

Medusa is probably the best default choice for a modern static/JS storefront.

• TypeScript/Node.js — excellent fit if your site is React/Next/Astro/etc.
• REST Store API — straightforward to consume from a static frontend. Medusa v2 exposes its storefront APIs under /store. Medusa Docs
• Modular architecture, so you can customize products, carts, payments, shipping, pricing, etc.
• Open-source and self-hostable.
• You can keep the frontend completely separate from the commerce backend.
• Particularly attractive if your developers are already JavaScript/TypeScript-oriented.

docs.medusajs.com

How I'd rank them

Saleor is especially compelling if you like GraphQL. It is API-only/headless and GraphQL-native, with strong multi-channel capabilities and extensive webhook/app support. GitHub Saleor Commerce

docs.saleor.io

Vendure is my other strong recommendation if you want TypeScript but prefer GraphQL and a very extensible plugin architecture. Its Shop API handles products, collections, customers, carts, checkout, and more. GitHub Vendure Developer Hub

docs.vendure.io

For your architecture

I'd build it roughly like:

Static site
(Astro / Next / Gatsby / plain HTML)
          │
          │ REST / GraphQL
          ▼
    Medusa backend
          │
     ┌────┼─────┐
     ▼    ▼     ▼
  Postgres Payments Shipping

The static site handles presentation and SEO, while Medusa handles products, inventory, carts, checkout, customers, orders, payments, and fulfillment.

If you tell me what your static-site stack is (Astro, Next.js, Hugo, plain HTML, etc.) and whether you need subscriptions/B2B/multi-vendor, I can narrow this down to the best one and give you a concrete architecture.

For a static site + headless commerce backend, I’d shortlist these open-source options. The “best” depends mostly on your team’s stack and how much commerce complexity you need. Vendure pkgpulse

My top picks

1. Medusa — best default choice for modern JS stacks

Best for: Next.js/Astro/React static sites, custom storefronts, startups, SaaS-style commerce.

Why it stands out:

• Built headless-first (not a traditional CMS with APIs bolted on)
• Node.js + TypeScript backend
• Strong API model for products, carts, orders, payments, fulfillment
• Easy to extend with custom modules
• Good fit if your frontend team already writes TypeScript Vendure OSSAlt

Tradeoffs:

• You are building the storefront experience yourself
• Some enterprise features require more customization than older platforms

I’d pick this for most new headless builds.

2. Saleor — best GraphQL-first option

Best for: teams that want a clean GraphQL API, multi-channel commerce, international catalogs.

Strengths:

• Python/Django backend
• GraphQL-native API
• Strong product/catalog modeling
• Good for complex inventory, channels, and larger commerce operations Vendure

Tradeoffs:

• Better fit if your team is comfortable with Python
• Heavier operational stack than a pure JS solution

3. Vendure — best structured TypeScript commerce framework

Best for: teams building more complex commerce systems.

Strengths:

• TypeScript + NestJS
• GraphQL API
• Plugin architecture
• Good fit for B2B, multi-store, marketplaces, and custom workflows Vendure Eryx Innovations Lab

Tradeoffs:

• Smaller ecosystem than some competitors
• License considerations matter if modifying core code ShipGarden

Quick comparison

OpenReplay Blog WPBundle## For a static site specifically

If your stack is something like:

• Astro
• Next.js static export
• Eleventy
• Hugo
• Nuxt generate
• plain HTML + JS

I’d lean:

1. Medusa → easiest developer experience for a custom storefront
2. Saleor → if you need sophisticated catalog/inventory rules
3. Vendure → if you expect the commerce backend itself to become a major application

A common architecture would be:

Static frontend (Astro / Next / etc.)
          |
          | API calls
          v
Headless commerce backend
          |
          +-- PostgreSQL
          +-- Payment provider
          +-- Shipping provider
          +-- CMS (optional)

If you tell me your frontend stack (Astro, Next, Hugo, etc.), product count, B2C vs B2B, and whether you need subscriptions/marketplace features, I can narrow it to one.

For a static site + headless ecommerce backend, I’d focus on platforms that were designed API-first rather than older systems retrofitted with APIs. The strongest open-source options today are generally:

OpenReplay Blog Vendure## My recommendation

Pick Medusa if:

• Your frontend is a static site built with Astro, Next.js, Nuxt, SvelteKit, Gatsby, etc.
• Your team prefers JavaScript/TypeScript
• You want to customize checkout, pricing, fulfillment, subscriptions, or integrations
• You want something closer to a "commerce backend framework" than a traditional store builder

Medusa is usually the easiest fit because your storefront developers and backend extension developers can stay in the same ecosystem. Vendure OSSAlt

Typical architecture:

Static frontend
(Astro / Next.js / SvelteKit)
          |
          | API calls
          v
Medusa backend
          |
          +-- PostgreSQL
          +-- Stripe
          +-- Shipping providers
          +-- CMS

Pick Saleor if:

• You strongly prefer GraphQL
• You have complex inventory, channels, warehouses, or B2B requirements
• Your team is comfortable operating Python/Django

Saleor’s GraphQL-first approach is one of its biggest strengths. WPBundle Designodin

Pick Vendure if:

• Your team already likes NestJS/TypeScript
• You want a plugin architecture
• You expect a lot of custom commerce logic

Vendure is particularly attractive for teams that want a strongly structured TypeScript backend. Vendure

What I would avoid for a new headless build

• Magento/OpenMage unless you already have Magento expertise.
• WooCommerce for a pure API-first project unless you specifically need WordPress and its plugin marketplace.
• Building checkout/order logic yourself on top of a CMS.

Short answer

For a static site, my shortlist would be:

1. Medusa — best general-purpose headless ecommerce backend
2. Saleor — best GraphQL/API purity and complex commerce
3. Vendure — best TypeScript enterprise-style option

If you tell me your frontend stack (Astro, Next.js, plain HTML, etc.), catalog size, and whether you need subscriptions/B2B/multiple warehouses, I can narrow it down.

If your priority is “static frontend + open-source commerce backend + strong APIs,” I’d shortlist Medusa, Saleor, and Vendure. All three are designed for headless use rather than retrofitting a traditional storefront. github.comgithub.com

My pick: Medusa

For most teams building a static site with a modern JS/TS frontend, Medusa would be my first choice.

Why Medusa: your static site can simply consume its commerce API for products, carts, customers, orders, etc. Its Node/TypeScript architecture also means you can keep your commerce customization in the same ecosystem as a typical Astro/Next.js/React frontend. Current comparisons also put Medusa ahead when developer simplicity and JS/TS are the main considerations. www.pkgpulse.com

When I'd choose the others

Saleor — choose this if you need sophisticated commerce: multiple channels, currencies, warehouses, B2B, complex catalog/pricing, etc. It is particularly attractive if your team likes GraphQL. Saleor is genuinely API-only rather than a traditional store with an API bolted on. github.com

Vendure — choose this if you're strongly committed to TypeScript/NestJS + GraphQL and expect substantial custom business logic. Its plugin architecture is excellent for extending the core without maintaining a fork. github.comgithub.com

What I'd build

For a straightforward static site, I'd do:

Static frontend
→ Astro / Next.js / Nuxt
→ Medusa API
→ PostgreSQL
→ Stripe/payment provider
→ object storage/CDN for images
→ webhooks for order/payment events

That gives you a completely decoupled storefront: the frontend can be deployed to a CDN/static host while the commerce backend runs separately.

One important distinction: don't pick WooCommerce just because it's open source. It's possible to use WooCommerce headlessly, but if you're starting from scratch and the primary requirement is an API-driven backend, Medusa/Saleor/Vendure are much more natural architectural fits. blog.openreplay.com

Bottom line:

• 🥇 Medusa — best default for a modern static/JS site
• 🥈 Saleor — best for sophisticated/enterprise GraphQL commerce
• 🥉 Vendure — best for TypeScript + highly customized commerce

If you tell me what your static site is built with (Astro, Next, Hugo, plain HTML, etc.) and roughly how complex the store is, I can recommend one and sketch the exact API architecture.

Yes. If your frontend is a static site and you want the commerce layer to be completely separate and API-driven, I’d shortlist Medusa, Saleor, and Vendure.

My pick: Medusa

Medusa is probably the best default for your setup.

• API-first: Medusa v2 exposes REST Store APIs specifically intended for storefronts and mobile apps. Medusa Documentation Medusa Documentation
• TypeScript/Node.js: particularly nice if your static site uses React, Next.js, Astro, etc.
• Headless by design: your static frontend can call the commerce API without having the ecommerce server render pages.
• Extensible: custom API routes and backend modules are straightforward to add.
• Self-hostable/open source: you control the database and backend rather than being tied to a hosted storefront.
• It has a relatively large developer ecosystem compared with the other open-source headless options. OSSAlt OSSAlt

A typical architecture would be:

Static site
  │
  ├── Product pages ────────┐
  ├── Cart ─────────────────┤
  ├── Checkout ─────────────┤
  └── Account ──────────────┤
                            ▼
                     Medusa API
                            │
                ┌───────────┼───────────┐
                ▼           ▼           ▼
           PostgreSQL    Payments    Shipping

The alternatives

Saleor is especially compelling if you like GraphQL. Its API is GraphQL-first and it has strong support for channels, multi-region commerce, warehouses, promotions, and extensibility. Saleor Documentation

Vendure is the one I'd investigate if you want everything in TypeScript but prefer GraphQL. Its Shop API handles products, customers, carts and checkout, and its plugin architecture lets you extend the GraphQL schema. Vendure Docs Vendure Docs

What I'd choose

For a new project:

Static Astro/Next/React site → Medusa → PostgreSQL → Stripe

That's the combination I'd start with unless you have a specific reason to prefer GraphQL.

If you tell me what your static site is built with (Astro, Next.js, plain HTML, Hugo, etc.) and whether you need subscriptions/B2B/multiple stores, I can narrow this down to the best backend and show you the API architecture.

For a static site + API-driven ecommerce backend, I’d shortlist Medusa, Saleor, and Vendure. They were built for headless use, unlike older platforms that were later adapted to APIs. OpenReplay Blog Vendure

My default recommendation:

1. Medusa — best overall for most modern stacks

Best if your frontend is:

• Astro
• Next.js
• Nuxt
• SvelteKit
• React/Vue static sites

Why it’s a strong fit:

• Node.js + TypeScript backend (same ecosystem as many modern frontends)
• API-first architecture
• Good REST APIs and SDKs
• Easy to customize products, carts, checkout, payments, fulfillment
• MIT license (friendly for commercial use) Vendure

Typical architecture:

Static site (Astro/Next/etc.)
        |
        | API calls
        |
     Medusa
        |
 PostgreSQL + payment/shipping providers

Choose Medusa if you want your developers to build the shopping experience rather than fight the platform.

2. Saleor — best API design / enterprise features

Best if you prefer:

• GraphQL everywhere
• Python/Django
• complex catalogs
• B2B commerce
• multi-channel selling

Strengths:

• Very polished GraphQL API
• Strong inventory and channel concepts
• Good for large catalogs and complex business rules Designodin

Tradeoff:

• More infrastructure complexity than a lightweight Node solution.

3. Vendure — best structured TypeScript backend

Best if:

• Your team likes NestJS
• You need a plugin architecture
• You expect deeper enterprise customization

Strengths:

• TypeScript end-to-end
• GraphQL API
• Clean extension model Vendure

Tradeoff:

• Smaller ecosystem than Medusa.

What I would avoid for your use case

WooCommerce

Great if you need WordPress plugins and an admin-driven store, but it is not my first choice for a pure static/headless build. You end up making WordPress behave like an API commerce engine.

Magento Open Source

Powerful, but usually too heavy unless you have enterprise-scale requirements.

My pick by scenario

For a new static site today, I’d probably start with Medusa + your static frontend + a CMS (like Sanity, Strapi, Payload, or Directus) for editorial content. That keeps commerce, content, and presentation cleanly separated. Vendure

If you tell me your frontend stack (Astro/Next/Gatsby/plain HTML/etc.), product count, and whether you need subscriptions, B2B pricing, or multi-vendor support, I can narrow it down.

Yes. If your frontend is a static site and you want the commerce backend to be completely decoupled, I'd shortlist Medusa, Saleor, and Vendure. All three are designed around APIs rather than requiring you to use their storefront. Open Source Groups Vendure

My pick: Medusa

For most teams, I'd start with Medusa.

Why I'd choose Medusa

• Very good fit for a static frontend. Your site can call the commerce API for products, carts, customers, checkout, etc., while remaining completely independent of the backend.
• TypeScript/Node.js means your frontend and backend can live in essentially the same ecosystem.
• It's deliberately modular, so you aren't adopting a giant monolithic CMS/ecommerce application.
• The API approach works well with Next.js, Astro, Gatsby, plain React, or even a completely static HTML site.
• MIT licensing is particularly attractive if you're building a commercial product and want minimal licensing friction. Current comparisons put Medusa, Saleor, and Vendure among the leading open-source headless options. Vendure ShipGarden

When I'd pick Saleor instead

Saleor is probably the better choice if your team specifically wants GraphQL or you're building a relatively sophisticated commerce operation.

Saleor is GraphQL-native and provides APIs for things like catalog, checkout, channels, promotions, payments, and multi-region commerce. Saleor Documentation Saleor Commerce

I'd lean Saleor for:

• Multiple storefronts/channels
• International/multi-region commerce
• Complex product/catalog requirements
• A Python/Django team
• Teams that strongly prefer GraphQL

When I'd pick Vendure

Vendure is the interesting alternative if you're a TypeScript shop but want a more structured, extensible commerce framework.

It exposes separate Shop and Admin GraphQL APIs, and its architecture is explicitly designed for arbitrary storefronts. Vendure Developer Hub Vendure Developer Hub

I'd choose Vendure when:

• You're heavily invested in TypeScript/NestJS
• You need substantial custom business logic
• B2B is important
• You want a plugin architecture
• GraphQL is preferable to REST

What I would not choose

I wouldn't start a new static-site project with WooCommerce, Magento, or PrestaShop unless you specifically need their enormous existing plugin/ecosystem ecosystems. They're capable of headless implementations, but they're fundamentally different architectural choices from something built headless-first. OpenReplay Blog

Bottom line

If you told me nothing else about the project:

Static frontend + open-source + API-driven ecommerce → Medusa.

If you're GraphQL-first / enterprise / complex multi-channel → Saleor.

If you're TypeScript + highly customized B2B/commerce logic → Vendure.

If you tell me what your static site is built with (Astro, Next.js, Hugo, Eleventy, plain HTML, etc.) and whether you need Stripe, subscriptions, variants, inventory, customer accounts, or multiple stores, I can narrow this down to one and sketch the architecture.

Yes. For a static site + separate ecommerce backend, I’d shortlist Medusa, Saleor, and Vendure. The best default for most teams is Medusa.

1. Medusa — my recommendation

If your static site is Astro, Next.js, Nuxt, plain React, etc., Medusa is probably the easiest backend to plug in.

Its Store API is REST-based, and it also provides an official JavaScript SDK. The API is specifically designed for storefronts and mobile apps. docs.medusajs.com

Advantages:

• TypeScript/Node.js end-to-end
• REST API is straightforward from a static frontend
• Official JS SDK
• Modular architecture
• Products, carts, orders, payments, fulfillment, promotions, etc.
• Self-hostable and MIT licensed
• Easy to put behind your own API/domain
• Good fit if you expect to add custom business logic later

Medusa API documentation

I'd pick this if: your developers are primarily JavaScript/TypeScript and you want the least friction between the static frontend and commerce backend.

2. Saleor — best if you specifically want GraphQL

Saleor takes a different approach: it's API-only and GraphQL-native. Its own project describes the API as the sole way to interact with and extend the backend. It also has strong multi-channel capabilities. github.com

That's attractive if your frontend already has a sophisticated GraphQL architecture.

The tradeoff is that you're operating a Python/Django backend rather than Node/TypeScript.

I'd pick this if: GraphQL is a major architectural requirement, or you have substantial B2B/multi-channel complexity.

3. Vendure — excellent TypeScript alternative

Vendure is also TypeScript, but uses NestJS and GraphQL with a fairly opinionated plugin architecture. It's particularly interesting when you expect substantial customization of the commerce engine. www.eryxinnovationslab.com

The big thing to investigate is licensing: Vendure's core is GPLv3/open-core rather than the permissive MIT license used by Medusa. vendure.io

What I'd build

For a typical setup:

Static site
→ Astro / Next.js / Nuxt
→ Medusa Store API
→ PostgreSQL
→ payment provider
→ shipping/tax integrations

Your static site can remain almost entirely static. Product/category data can be fetched at build time, while cart, checkout, customer accounts, and order operations hit the commerce API dynamically.

My ranking for your use case:

1. 🥇 Medusa — best default
2. 🥈 Saleor — choose this if GraphQL/B2B is important
3. 🥉 Vendure — choose this if you want a very extensible TypeScript/NestJS backend

I would not start with WooCommerce/Magento for a new static headless build unless you specifically need their enormous plugin ecosystems. They're viable headless backends, but Medusa/Saleor/Vendure are much more naturally designed around the API-first architecture you're describing. docs.medusajs.comwww.eryxinnovationslab.comblog.openreplay.com

If you tell me what your static frontend is (Astro, Next, Hugo, Eleventy, etc.) and roughly how complex the store is, I can narrow this down to one and sketch the architecture.

If the frontend is a static site and you want the commerce backend to be consumed entirely through APIs, I’d shortlist Medusa, Saleor, and Vendure. For most teams, my default pick would be Medusa.

🥇 My pick: Medusa

docs.medusajs.com

Medusa is particularly well suited to your architecture because its Store API is explicitly designed to power a separate storefront, including a webshop or mobile app. Its APIs are REST-based and there's an official JavaScript SDK, making it a natural fit if your static site is using React/Next/Astro/etc. Medusa Docs

The architecture would look roughly like:

Static site
   │
   │ HTTPS / REST
   ▼
Medusa
   ├── Products
   ├── Customers
   ├── Cart
   ├── Checkout
   ├── Orders
   ├── Payments
   └── Inventory
        │
        ├── PostgreSQL
        └── Redis

The big advantage is that the frontend doesn't need to be coupled to the commerce server. You can deploy your static site to Cloudflare Pages, Netlify, Vercel, S3/CloudFront, etc., while running Medusa separately.

When I'd choose Saleor instead

saleor.io

Saleor is arguably the more attractive option if GraphQL is a major requirement. It's API-only/headless, GraphQL-native, and has particularly strong multi-channel and B2B capabilities. Saleor Commerce Vendure

I'd pick it over Medusa if you have things like:

• Multiple storefronts/channels
• Complex B2B pricing
• Multiple warehouses
• A Python team
• A strong preference for GraphQL

Vendure

Vendure is another excellent option if your team is strongly TypeScript-oriented. It's built on NestJS and uses GraphQL, with a plugin/strategy architecture that makes substantial customization possible. Vendure

Its main drawback compared with Medusa is the GPLv3/open-core licensing model, whereas Medusa uses MIT licensing. That matters if you're planning substantial modifications to the underlying platform rather than simply extending it.

What I'd do for your situation

If you tell me "we have a static Astro/Next/React site, need products + cart + Stripe + orders, and don't want WordPress", I'd go:

1. Medusa — best default
2. Saleor — if GraphQL/B2B is important
3. Vendure — if you want a deeply customizable TypeScript/NestJS backend

I would not start with WooCommerce for a new project whose primary requirement is headless APIs. It can absolutely work headlessly, but you're effectively carrying WordPress along as the commerce engine; Medusa/Saleor/Vendure were designed around the decoupled architecture from the beginning. wpbundle.com

If you give me your frontend stack (Astro, Next, plain HTML, etc.), payment provider, and whether you need subscriptions/B2B/multiple stores, I can narrow this to one and sketch the exact architecture/API flow.

Vendure

Vendure is another excellent option if your team is strongly TypeScript-oriented. It's built on NestJS and uses GraphQL, with a plugin/strategy architecture that makes substantial customization possible.

For a static site that needs a commerce backend via APIs, I’d focus on platforms that were built headless-first, not traditional stores that merely added APIs later. The strongest open-source options right now are usually:

OpenReplay Blog Vendure## My recommendation by scenario

Pick Medusa if:

• Your frontend is Astro, Next.js, Nuxt, SvelteKit, React, etc.
• You want a clean API backend and your own UI.
• Your developers prefer JavaScript/TypeScript.
• You expect custom checkout flows, subscriptions, bundles, or unusual product logic.

Medusa is probably the closest match to “Shopify backend, but self-hosted and API-native.” Vendure

Pick Saleor if:

• You have a large catalog.
• You need multi-channel, multi-region, inventory complexity, B2B pricing, or enterprise workflows.
• Your team likes GraphQL.

Saleor’s GraphQL-first approach is one of its biggest strengths. WPBundle

Pick Vendure if:

• Your team is already TypeScript-heavy.
• You want a very extensible backend with plugin-based customization.
• You’re building something more like a commerce platform than a simple store.

Vendure## What I would avoid for a new headless build

• Magento/Open Source unless you already have Magento expertise. It is powerful but heavy.
• WooCommerce unless you specifically need WordPress plugins/content workflows. It can work headlessly, but the architecture is less clean than platforms designed API-first. WPBundle

A common modern stack

A setup I’d consider for a static site:

• Frontend: Astro / Next.js / SvelteKit
• Commerce API: Medusa
• CMS: Payload CMS, Strapi, or similar
• Database: PostgreSQL
• Payments: Stripe
• Hosting: your preferred cloud/VPS

If you tell me your frontend framework (Astro, Next.js, plain HTML, etc.), catalog size, and whether you need subscriptions/B2B, I can narrow it to one choice.

Yes. For a static/headless storefront, I’d narrow it to Medusa, Saleor, and Vendure rather than traditional platforms like WooCommerce or Magento. All three are designed to put the storefront behind APIs. Vendure Saleor Commerce

My pick: Medusa

If your frontend is something like Astro, Next.js, Nuxt, or another static/Jamstack site, I’d start with Medusa.

• API: REST, with a JS SDK; Medusa's Store API is specifically intended for webshops and mobile apps. Medusa Docs
• Stack: Node.js + TypeScript.
• Architecture: Modular, so you can replace/customize things like payments, fulfillment, pricing, and inventory.
• Self-hosting: Yes; MIT-licensed according to current comparisons. Vendure
• Best fit: A development team already comfortable with JavaScript/TypeScript that wants a flexible commerce backend without adopting a huge monolithic ecommerce system.

docs.medusajs.com

The alternatives

Saleor is particularly attractive if you want a GraphQL-first backend. It has first-class concepts for channels, checkout, promotions, payments, multi-region commerce, and extensions. Saleor Documentation Saleor Commerce

Vendure is probably the one I'd evaluate alongside Medusa if your team is strongly TypeScript/NestJS-oriented. Its core is GraphQL-based and its plugin/strategy architecture is designed for substantial customization. Vendure

For your specific architecture

If you mean something like:

Static site
(Astro / Next.js / Nuxt)
        |
        | HTTPS API
        v
   Medusa / Saleor
        |
   +----+----+---------+
   |    |    |         |
Products Cart Orders Payments
   |                   |
   +------ PostgreSQL -+

that's exactly the architecture I'd recommend.

I'd choose Medusa unless you have a reason to choose GraphQL. Its REST Store API maps very naturally onto a static frontend, and custom API routes can also be added when your business logic doesn't fit the built-ins. Medusa Docs Medusa Docs

If you tell me what static framework you're using (Astro, Next.js, Hugo, plain HTML, etc.), expected catalog size, and whether you need subscriptions/B2B/multiple currencies, I can narrow this down to the best 1–2 options and outline the exact backend/frontend architecture.

If your frontend is a static site and you want a backend you can consume entirely through APIs, I’d shortlist Medusa, Saleor, and Vendure. For most teams, I’d pick Medusa.

🥇 My pick: Medusa

Medusa Store API documentation

Medusa is particularly attractive if your site is something like Astro, Next.js static export, Nuxt, Gatsby, or plain HTML/JS. Its v2 Store API is REST-based, with a JavaScript SDK, so your static frontend can simply call the commerce backend for products, carts, customers, checkout, etc. docs.medusajs.com

The architecture I'd use is:

Static frontend
(Astro / Next.js / plain JS)
          │
          │ HTTPS API
          ▼
      Medusa
          │
    ┌─────┼─────┐
    ▼     ▼     ▼
 Postgres Payments Search

That keeps the frontend completely independent of the commerce server.

When I'd choose Saleor instead

Saleor open-source commerce

Choose Saleor if your API requirements are strongly GraphQL-oriented, or you're expecting things like multiple markets, warehouses, currencies, channels, and more sophisticated international/B2B commerce. Saleor is GraphQL-native and explicitly designed to work with arbitrary frontend stacks. saleor.io

The downside is that its backend stack is heavier than Medusa's, so I'd be less inclined to choose it for a relatively straightforward store.

When I'd choose Vendure

Vendure headless commerce comparison

Vendure is a very good choice if your team is TypeScript/NestJS-heavy and you want a strongly typed, plugin-oriented commerce framework. It's especially interesting for B2B, multi-channel, and highly customized commerce. Its core is open source, but its licensing model differs from the permissive MIT/BSD licenses of Medusa and Saleor. docs.medusajs.comsaleor.iovendure.io

What I would do

For a new static-site ecommerce build today:

1. Medusa — default choice
2. Saleor — if GraphQL/complex commerce is important
3. Vendure — if you're already deeply invested in TypeScript/NestJS

I would not start with WooCommerce, Magento, or PrestaShop for this particular architecture unless you specifically need their mature plugin ecosystems. They're capable of being headless, but Medusa/Saleor/Vendure were designed much more naturally around an API-driven frontend. blog.openreplay.com

If you tell me what your static site is built with (Astro, Next.js, Hugo, plain HTML, etc.), expected product count, and whether you need subscriptions/B2B/multiple currencies, I can narrow this to one and sketch the recommended architecture.

For a static site (Astro, Next.js static export, Gatsby, Hugo, custom React, etc.) you’ll want a headless-first commerce backend with a strong API, webhooks, and good extensibility. The best open-source choices today are usually:

OpenReplay Blog Vendure### My recommendation by scenario

1. Static marketing site + custom storefront → Medusa

• Your frontend calls APIs for: - products
• prices
• carts
• checkout
• customer accounts
• orders
• TypeScript backend matches well with modern frontend stacks.
• Modular architecture makes it easier to add custom business logic. ShipGarden

2. Large catalog / B2B / multiple warehouses → Saleor

• Excellent GraphQL model.
• Strong for: - multiple channels
• complex inventory
• permissions
• B2B workflows. WPBundle

3. You want a TypeScript backend but more enterprise structure → Vendure

• Built on NestJS.
• Plugin architecture is very developer-friendly.
• Good if your team already likes Angular/Nest-style patterns. Vendure

What I would avoid for a new headless build

• Magento/OpenMage unless you already have Magento expertise. It can do almost anything, but it is a much heavier operational commitment.
• WooCommerce if the goal is purely API-first commerce. It works, but you’re adapting a WordPress commerce system rather than starting with a headless engine.

A typical architecture

Static frontend
(Astro / Next.js / Gatsby)
        |
        | API calls
        ↓
Headless commerce backend
(Medusa / Saleor / Vendure)
        |
        ├── PostgreSQL
        ├── Payment provider
        ├── Shipping provider
        ├── CMS (optional)
        └── Search (Meilisearch/Algolia/etc.)

If your site is mostly content + a small/medium product catalog, I’d lean Medusa + a headless CMS (like Strapi, Sanity, or Directus). If it’s a serious commerce operation, I’d compare Saleor vs Medusa first. OSSAlt

A couple of details would change the recommendation:

• What frontend are you using (Astro, Next.js, plain HTML, etc.)?
• Rough catalog size (50 products vs 50,000)?
• B2C only or B2B pricing/accounts?
• Do you need subscriptions, marketplaces, or multiple warehouses?

If the frontend is already static and you want the backend primarily as an API, I’d shortlist Medusa, Saleor, and Vendure rather than traditional platforms like WooCommerce/Magento.

My pick: Medusa

For a new headless build, Medusa is probably the best default. It was designed around headless/composable commerce, uses TypeScript/Node.js, and is particularly comfortable if your frontend stack is React/Next.js or another JavaScript-based stack. contracollective.com

Saleor is the one I'd choose if your team specifically wants GraphQL and you expect things like multiple warehouses, channels, currencies, or sophisticated international/B2B commerce. Its core is explicitly GraphQL-first and headless. saleor.io

Vendure is compelling if you're a TypeScript team but want a very extensible plugin architecture and GraphQL throughout. Its Shop API exposes products, customers, carts, checkout, etc. directly to your storefront. docs.vendure.io

For your architecture

I'd build:

Static site → Commerce API → Medusa → PostgreSQL

with:

• Static frontend: Astro / Next.js / plain HTML
• Commerce: Medusa
• Database: PostgreSQL
• Payments: Stripe
• Images: S3-compatible storage/CDN
• Search: Algolia, Meilisearch, or Typesense if needed
• CMS: optional — Sanity/Contentful/etc.
• Hosting: your preferred Node/container platform

The important advantage is that the static site doesn't need to know anything about the commerce backend's implementation. It just calls APIs for products, carts, checkout, customer accounts, etc.

If you tell me your frontend stack (Astro, Next.js, plain HTML, etc.), approximate product count, and whether you need subscriptions/B2B/multiple warehouses, I can narrow it down to one and give you the recommended architecture.

For a static site + API-driven commerce backend, I’d shortlist these:

ossalt.comblog.openreplay.com

My recommendation

For a static frontend (Astro, Next.js static export, Gatsby, Nuxt, custom React, etc.) I would usually pick:

1. Medusa — best overall starting point

Choose this if:

• your frontend team uses JavaScript/TypeScript
• you want to own the backend
• you need products, carts, checkout, payments, inventory, orders via APIs
• you expect custom business logic

Why:

• built specifically for headless commerce
• TypeScript ecosystem matches modern frontend stacks
• modular architecture makes customizations easier
• good fit for a "commerce engine behind a static site" model

contracollective.com

Typical architecture:

Static Site (Astro / Next / React)
        |
        | REST API / SDK
        |
     Medusa
        |
  PostgreSQL + Redis
        |
Payments / Shipping / ERP

2. Saleor — best API design if GraphQL is your priority

Pick Saleor if:

• your team loves GraphQL
• you have complex catalogs
• you need multi-channel, multi-region, B2B features
• Python/Django is acceptable

Its GraphQL-first approach is one of its biggest strengths. contracollective.com

3. Vendure — best for highly customized commerce apps

Pick Vendure if:

• your backend team is TypeScript-heavy
• you need deep plugins/custom workflows
• you have B2B requirements like customer-specific pricing or approval flows

It is more of a commerce framework than a drop-in store. contracollective.com

I would avoid starting with:

• Magento/Adobe Commerce unless you already need enterprise Magento features. It is powerful but much heavier operationally.
• WooCommerce if the goal is a clean API-first architecture. It works, but its center of gravity is still WordPress. ossalt.comblog.openreplay.com

Quick decision rule

• Next.js/Astro + custom storefront → Medusa
• GraphQL everywhere → Saleor
• Complex B2B workflows → Vendure
• Marketing site already in WordPress → WooCommerce

If you tell me your frontend stack, product count, payment provider, and whether you need subscriptions/B2B/multi-vendor, I can narrow it down further.

If the frontend is a static site and you want the ecommerce backend to be almost entirely API-driven, my shortlist would be:

🥇 I'd start with Medusa

Medusa documentation

For a static site, Medusa is particularly attractive because its v2 Store API is REST-based, with all storefront routes under /store, and it provides a JavaScript SDK. That makes it straightforward to call from a Next.js/Astro/Nuxt/static frontend without adopting GraphQL. docs.medusajs.com

I'd choose it if your architecture looks something like:

Static frontend
     │
     │ REST / JSON
     ▼
  Medusa API
     │
 ┌───┼────────┐
 ▼   ▼        ▼
DB  Payments  Search

It's also TypeScript/Node-based, which is a nice fit if the rest of your application is JavaScript/TypeScript.

🥈 Vendure if customization is the priority

Vendure documentation

Vendure is excellent if you expect to build a lot of custom commerce behavior. It exposes separate Shop and Admin GraphQL APIs and has a strong plugin architecture. You can even extend the GraphQL schema with your own queries and mutations. docs.vendure.io

The tradeoff is that you're committing to GraphQL rather than the simpler REST model.

🥉 Saleor for GraphQL-heavy teams

Saleor documentation

Saleor is a strong choice if you specifically want GraphQL-first commerce, particularly for sophisticated catalogs, channels, currencies, and multi-region setups. Its documentation exposes a comprehensive GraphQL API reference and APIs for products, checkout, payments, channels, promotions, etc. docs.saleor.io

The big question is whether your team wants to operate a Python/Django backend rather than Node/TypeScript.

My recommendation

For a new static/headless site:

Medusa → easiest overall choice
Vendure → choose if you anticipate lots of custom business logic/B2B
Saleor → choose if GraphQL and sophisticated multi-channel commerce are central requirements

I would not pick WooCommerce for a greenfield project solely because it's open source. It's excellent when you're already invested in WordPress, but Medusa/Vendure/Saleor were designed much more naturally around headless commerce.

If you tell me your frontend stack (Astro/Next.js/etc.), product complexity, payment provider, and whether you need subscriptions/B2B, I can narrow this to one and sketch the API architecture.

Yes. If the requirement is “open-source commerce backend + API + static/headless frontend”, I’d shortlist Medusa, Saleor, and Vendure rather than traditional platforms like WooCommerce/Magento.

My pick: Medusa

Medusa is probably the best default if your team is building the frontend in JavaScript/TypeScript.

Medusa is particularly attractive because its commerce functionality is modular: products, carts, orders, payments, inventory, fulfillment, etc. can be extended without turning your storefront into a monolith. Current comparisons also put it ahead when the team is TypeScript-first and wants maximum composability. contracollective.comgithub.com

When I'd choose Saleor instead

Saleor is arguably the stronger choice if you specifically want a GraphQL-first API and have a more sophisticated catalog/multi-channel setup.

Saleor describes itself as headless and API-only, with GraphQL as its sole API, and supports things like multiple channels, currencies, stock, webhooks and extensibility through apps. github.com

I'd pick it over Medusa if you're expecting:

• multiple countries/currencies/channels
• complicated catalog structures
• multiple warehouses
• a GraphQL-centric engineering team
• larger enterprise-scale commerce requirements

The tradeoff is that you're taking on a Python/Django backend rather than staying entirely in the Node/TypeScript ecosystem. contracollective.com

Vendure is the sleeper option

Vendure is worth serious consideration if your team likes TypeScript + NestJS + GraphQL.

Its Shop API exposes products, collections, customers, carts, checkout and account operations through GraphQL, while its plugin architecture lets you customize the backend without forking core code. github.com

I'd lean Vendure for a more structured/B2B-heavy system where you expect substantial custom commerce logic.

For your static site

A clean architecture would be:

Static site
   │
   │ HTTPS / REST or GraphQL
   ▼
Commerce API
(Medusa / Saleor / Vendure)
   │
   ├── Products
   ├── Cart
   ├── Checkout
   ├── Customers
   ├── Orders
   ├── Inventory
   └── Payments

Your static frontend can be Astro, Next.js, Nuxt, plain HTML/JS, etc. The frontend doesn't need to know how the commerce backend is implemented.

If I were starting this today, I'd use Medusa + PostgreSQL + Stripe + your existing static frontend. It gives you a relatively straightforward API-driven architecture while keeping the backend fully under your control.

If you tell me what your static site is built with (Astro, Next, Hugo, plain HTML, etc.) and whether you need subscriptions/B2B/multiple warehouses, I can narrow this down to the best one and show you the API architecture.

Yes. For a static/headless storefront, I’d shortlist Medusa, Saleor, and Vendure rather than traditional platforms like WooCommerce or Magento. All three are designed to put the storefront behind APIs. contracollective.com

My pick: Medusa

If your static site is built with Next.js, Astro, Nuxt, plain React, or another JS/TS stack, I’d start with Medusa.

• REST Store API — straightforward to call from a static frontend. docs.medusajs.com
• TypeScript/Node.js — good fit for a modern JS stack.
• Modular architecture makes it relatively easy to customize carts, payments, fulfillment, pricing, etc.
• Has a JS SDK in addition to its APIs. docs.medusajs.com
• MIT-licensed, which is attractive if you want maximum freedom around deployment and customization. contracollective.com

How I'd rank them

Saleor is particularly compelling if you want a GraphQL-only architecture: its APIs are the primary way to interact with and extend the system, and it has strong multichannel capabilities. saleor.io

Vendure is also very good for a static frontend. It exposes separate Shop and Admin GraphQL APIs, with the Shop API covering products, carts, checkout, customers, etc. docs.vendure.io Its TypeScript/NestJS plugin architecture is a major advantage if you expect substantial backend customization. github.com

For your architecture

I'd lean toward:

Static site → Medusa Store API → PostgreSQL

with your payment provider, search, email, and shipping services plugged into the backend.

The important distinction is that you don't need the ecommerce backend to render your website. It just owns things like products, inventory, carts, customers, orders, discounts, and checkout; your static site consumes those capabilities through the API.

If you tell me what your static site is built with (Astro/Next/etc.), whether you need subscriptions, and roughly how complex the catalog/checkout is, I can narrow this to one and lay out the recommended architecture.

Yes. If the goal is a static site that talks to a self-hosted, open-source commerce backend entirely through APIs, I’d shortlist Medusa, Saleor, and Vendure. blog.openreplay.com

My pick: Medusa

Medusa is probably the best default for your use case.

Why Medusa: its v2 Store API is REST-based, with endpoints specifically intended for storefronts and mobile apps, plus an official JavaScript SDK. You can put a static frontend on top without having to build your own commerce API layer. docs.medusajs.com

It's also TypeScript/Node-based and designed around modular commerce components, which makes it particularly attractive if you expect to customize things like pricing, fulfillment, payments, inventory, or integrations. docs.medusajs.com

When I'd choose the others

Saleor — choose this if you specifically want GraphQL and have a more sophisticated catalog/multi-channel setup. Its entire commerce API is GraphQL-first and it has strong support for channels, warehouses, and complex product data. docs.saleor.io

Vendure — choose this if your team is heavily invested in TypeScript + GraphQL, particularly for B2B or highly customized workflows. Its Shop API exposes products, customers, carts and checkout through GraphQL. docs.vendure.io

Architecture I'd use

Static site
  │
  │ REST / GraphQL
  ▼
Medusa
  │
  ├── PostgreSQL
  ├── Payments
  ├── Inventory
  ├── Orders
  ├── Customers
  └── Admin dashboard

Your static frontend can therefore remain completely separate from the commerce backend:

/products
/product/widget
/cart
/checkout

The frontend fetches product/catalog data from Medusa, creates carts, adds line items, and hands checkout/payment operations to the backend. You don't need WordPress, PHP, or a server-rendered storefront.

Bottom line: for a new project where the frontend is already static and you want an API-driven backend, I'd start with Medusa. If you're deliberately choosing GraphQL, I'd investigate Saleor first; if you're building sophisticated B2B commerce, Vendure deserves a serious look. docs.medusajs.comdocs.saleor.ioblog.openreplay.com

If you tell me what your static site is built with (plain HTML, Astro, Next static export, Hugo, etc.) and whether you need Stripe/PayPal, customer accounts, or subscriptions, I can narrow this down to the best architecture.

Yes. For a static-site frontend + API-driven commerce backend, I’d shortlist Medusa, Saleor, and Vendure. They’re all designed around headless commerce rather than bolting an API onto a traditional storefront. contracollective.comdocs.medusajs.comsaleor.iogithub.com

My pick: Medusa

If your static site is something like Astro, Next.js, Nuxt, Gatsby, or plain HTML/JS, I'd start with Medusa.

Its Store API is REST-based, with an official JavaScript SDK, so your frontend can simply call the backend for products, carts, customers, checkout, etc. docs.medusajs.com

Medusa documentation

Why I'd choose it:

• TypeScript/Node fits modern static-site tooling.
• API-first rather than frontend-first.
• Modular architecture—you can replace/customize commerce components.
• REST is straightforward from a static frontend.
• MIT licensing is attractive if you want maximum freedom. contracollective.com

When I'd choose Saleor instead

Pick Saleor if you want GraphQL everywhere and expect substantial catalog, multi-channel, multi-region, or enterprise complexity.

Saleor is explicitly GraphQL-native and designed to let essentially any frontend consume the commerce API. saleor.io

Saleor documentation

When I'd choose Vendure

Pick Vendure if you're a TypeScript/NestJS team and anticipate sophisticated B2B, marketplace, subscription, or custom business logic. Its Shop API is GraphQL and specifically exposes products, carts, checkout, customers, etc. github.com

Vendure documentation

Bottom line: for a new static-site project where you want a clean API backend and don't have unusual enterprise requirements, I'd use Medusa. If you're specifically a GraphQL shop, Saleor is probably the better choice.

If you tell me your frontend stack (e.g. Astro/Next.js/11ty) and whether you need Stripe, subscriptions, customer accounts, inventory, or multi-vendor, I can narrow it down to one.

If the goal is a static site that talks to a commerce backend entirely through APIs, I’d shortlist Medusa, Saleor, and Vendure rather than traditional WooCommerce/Magento.

My pick: Medusa

Medusa is probably the best default if your team is JavaScript/TypeScript-oriented.

• API: REST Store API, with an official JS SDK. docs.medusajs.com
• Stack: Node.js/TypeScript
• Architecture: highly modular—you can customize or replace pieces such as payments, inventory, fulfillment, etc.
• Static frontend: works well with Next.js, Astro, Gatsby, plain JS, or essentially anything capable of HTTP requests.
• Open source: MIT-licensed according to current comparisons. docs.medusajs.comvendure.iodocs.vendure.io

How I'd rank them

Saleor is particularly attractive if you want GraphQL everywhere. Its current platform exposes a broad GraphQL API and webhooks, and it can be self-hosted without requiring its cloud service. saleor.io

Vendure is another excellent choice. Its Shop API and Admin API are both GraphQL, and the core is designed around an extensible plugin architecture. docs.vendure.io

For your specific description—"static site + ecommerce backend"—I'd start with Medusa unless you have a strong reason to prefer GraphQL. You can keep the frontend completely static and have it call the Medusa Store API for products, carts, customers, and checkout.

If you tell me what your static-site stack is (Astro, Hugo, Next static export, Eleventy, plain HTML, etc.) and whether you need Stripe, subscriptions, or multiple currencies, I can narrow it down to one.

If the goal is a headless backend that your static site talks to entirely through APIs, my shortlist in 2026 is:

My pick: Medusa

I'd start with Medusa if you're building a new static/Next.js/Astro/etc. storefront. It's designed as a headless commerce engine rather than a traditional CMS/storefront, and its TypeScript architecture makes it particularly convenient when your frontend is JavaScript/TypeScript. Current comparisons also put it ahead for modularity and composable commerce workflows. contracollective.com

The architecture would look roughly like:

Static site → Medusa API → PostgreSQL

with Medusa handling:

• Products / variants
• Carts
• Checkout
• Customers
• Orders
• Inventory
• Payments
• Shipping
• Promotions

That gives you complete freedom over the frontend while keeping commerce logic in the backend.

When I'd choose Saleor instead

Pick Saleor if you're particularly interested in GraphQL. Its storefront and admin interfaces are API-driven, and it has a very broad GraphQL API. It's especially attractive if you have a complicated catalog, multiple channels/regions, or expect several different clients (web, mobile, POS, etc.). saleor.io

The tradeoff is that you're taking on a Python/Django backend rather than staying in the Node/TypeScript ecosystem.

When I'd choose Vendure

Vendure is my third choice, but potentially the first if you're building B2B or highly customized commerce. It's TypeScript/NestJS and exposes its commerce functionality through GraphQL. Its plugin/strategy architecture is particularly nice when you need to replace things like pricing, shipping, tax, or fulfillment behavior. docs.vendure.io

What I wouldn't choose

I wouldn't start a new project with WooCommerce, Magento, or PrestaShop if the primary requirement is "API backend for a static site." They can absolutely be made headless, but their architecture and ecosystems are centered more around traditional storefronts/CMS experiences. blog.openreplay.com

Bottom line:
Medusa → best default
Saleor → best GraphQL/complex-commerce choice
Vendure → best TypeScript/B2B customization choice

If you tell me what your static site is built with (Astro, Next.js, Hugo, plain HTML, etc.) and whether you need Stripe, subscriptions, accounts, or just a simple product/cart/checkout flow, I can narrow it down to one and sketch the API architecture.

If the requirement is “open-source backend + static/headless frontend + strong APIs,” I’d shortlist Medusa, Saleor, and Vendure. All three are purpose-built for headless commerce rather than traditional storefronts. vendure.io

My pick: Medusa

For a static site, I'd start with Medusa.

Its Store API is explicitly designed for storefronts and mobile apps, with REST endpoints for products, carts, checkout, customers, etc., and it provides an official JavaScript SDK. docs.medusajs.com

That makes the architecture very straightforward:

Static site → Medusa Store API → database/payment/shipping services

You can host the static frontend essentially anywhere and keep the commerce backend completely separate.

Medusa Store API documentation

When I'd choose the others

Saleor is my choice if your team really likes GraphQL or you expect sophisticated multi-channel/international commerce. Saleor is API-only and GraphQL-native, with channels controlling things like pricing, currencies, inventory and products. github.com

Saleor open-source project

Vendure is particularly compelling if you're a TypeScript/NestJS shop and anticipate lots of custom commerce logic. It has separate Shop and Admin GraphQL APIs and a strong plugin architecture. github.com

Vendure documentation

Bottom line

If you told me “we have an Astro/Next.js/static site and just need a solid commerce backend exposed over APIs”, I'd evaluate them in this order:

1. Medusa → easiest default
2. Vendure → best if TypeScript customization is important
3. Saleor → best if GraphQL and complex commerce are priorities

If you tell me your frontend framework, expected catalog size, payment provider, and whether you need subscriptions/B2B/multiple stores, I can narrow this to one and sketch the recommended architecture.

If the goal is “static site in front, commerce backend behind an API”, I’d shortlist Medusa, Saleor, and Vendure. All three are genuinely headless and designed to decouple the storefront from the commerce backend. contracollective.com

My pick: Medusa

Medusa would be my default choice for a new project, especially if your team is JavaScript/TypeScript-oriented.

• REST Store API — very straightforward to consume from a static site; Medusa v2 exposes its storefront APIs under /store. docs.medusajs.com
• TypeScript/Node.js — fits naturally with Next.js, Astro, React, etc.
• Highly modular — you can customize payments, fulfillment, inventory, pricing and other commerce domains rather than fighting a monolithic platform. contracollective.com
• Good fit for custom storefronts — your static frontend can call the backend for products, carts, customers and checkout while remaining completely independent.
• MIT licensed, which is attractive if you want maximum freedom around deployment and modification. contracollective.com

The alternatives

Saleor is particularly compelling if you want GraphQL. Its architecture is built around a broad GraphQL API and handles things like channels, regions, currencies and complex catalogs very well. The tradeoff is a Python/Django backend rather than Node/TypeScript. docs.medusajs.comcontracollective.com

Vendure is arguably the nicest choice if your team loves TypeScript and prefers GraphQL. Its Shop API exposes products, collections, customers, carts and checkout operations, while the Admin API handles management. docs.vendure.io

For your architecture

I'd probably build:

Static site
(Astro / Next.js / React / plain HTML)
          │
          │ REST/GraphQL
          ▼
       Medusa
          │
    ┌─────┼────────┐
    ▼     ▼        ▼
Postgres Payments Shipping

The frontend doesn't need to know anything about your database or commerce implementation. It just consumes the API.

One important distinction: if by “static site” you mean literally static HTML with client-side JavaScript, that's still fine. The browser can call the commerce API directly for catalog/cart operations, while sensitive operations such as payment processing should remain behind appropriate server-side boundaries.

If you tell me your frontend framework (Astro, Next.js, Hugo, plain HTML, etc.), payment provider, and whether you need subscriptions/B2B, I can narrow this to one choice and outline the API architecture.