ChatGPT answers, unedited

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.