ChatGPT answers, unedited

For a custom dropshipping site where API-driven integrations are the priority, I'd shortlist Medusa and Saleor, with Medusa as my default recommendation.

My pick: Medusa

Medusa is particularly well suited if you're building a dropshipping system that needs custom supplier, inventory, fulfillment, and order-routing logic.

• REST APIs: Medusa v2 exposes dedicated Store and Admin REST APIs, with OpenAPI specs available—very convenient for integrating supplier APIs, ERP systems, fulfillment services, etc. Medusa Docs Medusa Docs
• Highly customizable: You can create custom API routes, data models, modules, workflows, and event subscribers rather than trying to force dropshipping logic into plugins. Medusa Docs
• Decoupled storefront: Your frontend can be Next.js, React, mobile, or essentially whatever you want; storefronts communicate with Medusa through APIs. Medusa Docs
• Good fit for automation: Its architecture lends itself to workflows such as supplier order → payment → fulfillment → tracking → customer notification.
• Open source: You have considerably more control over the commerce backend than with SaaS-first platforms.

docs.medusajs.com

When I'd choose Saleor instead

Saleor would be my choice if you specifically want a GraphQL-first architecture.

Saleor is API-only/headless and GraphQL-native, with 140+ webhooks and extensive extension capabilities. Saleor Commerce Saleor Commerce Its multi-channel capabilities are also strong, which could be useful if you're eventually operating multiple storefronts, regions, currencies, or supplier catalogs. GitHub

docs.saleor.io

How I'd rank them for your use case

commercetools is worth considering if you're building something enterprise-scale; its architecture is explicitly designed around API-first connectivity and composable commerce. Commercetools

For a dropshipping architecture specifically

I'd lean Medusa + Next.js + PostgreSQL + a queue/event system:

                 ┌───────────────┐
                 │    Next.js    │
                 │   storefront  │
                 └───────┬───────┘
                         │ REST API
                         ▼
                 ┌───────────────┐
                 │    Medusa     │
                 │    Commerce   │
                 └───────┬───────┘
                         │
              ┌──────────┼──────────┐
              ▼          ▼          ▼
          Supplier A  Supplier B  Supplier C
          API/feed    API/feed    API/feed
              │          │          │
              └──────────┼──────────┘
                         ▼
                  Order/Inventory
                    orchestration
                         │
                         ▼
                  Fulfillment APIs

The key advantage is that supplier synchronization doesn't have to be your storefront's problem. I'd put supplier adapters behind your commerce backend, normalize their products/inventory into your own model, and use asynchronous jobs/webhooks for inventory and order synchronization.

If you're starting from scratch today, I'd choose Medusa unless you have a strong reason to make GraphQL the center of your architecture—in which case I'd choose Saleor.

For a custom dropshipping site where API integrations and developer speed are priorities, I’d shortlist Medusa, Saleor, and Shopify headless.

My recommendation: Medusa

medusajs.com would be my first choice if you're building a highly customized dropshipping backend.

Why:

• API-first: Medusa v2 exposes REST Store and Admin APIs, with an official JS SDK and OpenAPI specs. Medusa Documentation Medusa Documentation
• Good fit for custom supplier integrations: You can build your own modules/workflows for supplier catalogs, inventory synchronization, fulfillment, order routing, etc.
• Less platform lock-in: You control the application architecture rather than adapting your frontend to a hosted commerce platform.
• JavaScript/TypeScript friendly: Particularly attractive if your stack is Next.js/Node/TypeScript.
• Dropshipping-specific advantage: You can model supplier → product → inventory → fulfillment relationships yourself instead of fighting a conventional store abstraction.

How I'd rank them

Saleor is particularly compelling if you prefer GraphQL. Its platform is API-only and GraphQL-native, with webhooks, apps, multi-channel support, and technology-agnostic frontends. Saleor Documentation Saleor Commerce

saleor.io

Shopify Headless is the pragmatic choice if you want to minimize commerce infrastructure work. Shopify provides the Storefront API plus Hydrogen, and its Headless channel supports multiple custom storefronts. Shopify Shopify

hydrogen.shopify.dev

commercetools is excellent technically, particularly for sophisticated integrations and enterprise-scale commerce. Its APIs include both HTTP and GraphQL, with explicit performance guidance. commercetools Documentation commercetools Documentation

commercetools.com

For your specific use case

I'd lean Medusa + Next.js + a supplier-integration service:

                 Your Next.js Store
                        │
                        ▼
                 Medusa Commerce
              ┌─────────┼─────────┐
              ▼         ▼         ▼
          Catalog     Cart      Orders
              │                   │
              ▼                   ▼
       Supplier Sync        Fulfillment Router
        ┌─────┼─────┐        ┌────┼─────┐
        ▼     ▼     ▼        ▼    ▼     ▼
     Supplier A  B   C      A    B     C

The key architectural decision is not to make the supplier APIs part of your storefront request path. Sync supplier catalog/inventory asynchronously, normalize everything into your commerce backend, and send orders to suppliers through background jobs/webhooks. That gives you much better latency and resilience.

Bottom line: If you're genuinely building the commerce system yourself, Medusa is my pick. If GraphQL is a hard requirement, I'd choose Saleor. If your priority is getting to market quickly while outsourcing much of the commerce complexity, choose Shopify Headless.

For a custom dropshipping site where API-driven integrations are the priority, I’d pick Medusa as the default choice.

My ranking

Why I'd choose Medusa

docs.medusajs.com

Medusa is particularly well suited to dropshipping because you're likely going to need custom logic around:

• Supplier/product synchronization
• Supplier-specific inventory
• Automated order forwarding
• Tracking-number ingestion
• Product/catalog normalization
• Dynamic pricing and margins
• Multiple fulfillment providers
• Custom shipping rules
• Webhooks and background workflows

Medusa V2 exposes separate Store and Admin REST APIs, and its framework lets you create custom API routes, data models, workflows, modules, and event subscriptions. Medusa Docs Medusa Docs

That makes an architecture like this fairly natural:

                 Your storefront
                 Next.js / React
                       │
                       ▼
                 Medusa API
                /     |      \
               /      |       \
        Product DB   Orders   Customers
             │         │
             ▼         ▼
       Supplier APIs  Fulfillment
       ├─ Supplier A
       ├─ Supplier B
       └─ Supplier C

The important distinction is that Medusa isn't forcing your supplier integrations into a marketplace/plugin model. You can implement the integration as your own module/workflow and control the business logic.

When I'd choose Saleor instead

docs.saleor.io

Saleor would be my #2 choice, and arguably #1 if your team strongly prefers GraphQL.

Saleor is API-only/headless and GraphQL-native, with extensive webhook and app capabilities. Its architecture is explicitly designed for technology-agnostic integrations and composable commerce. Saleor Commerce Saleor Commerce

I'd choose Saleor over Medusa if you expect:

• Complex catalog modeling
• Multiple sales channels/regions
• Heavy GraphQL usage
• Large-scale international commerce
• A more strongly composable architecture

Saleor also has native multichannel functionality for things like pricing, currencies, inventory, and products. GitHub

The key decision

If you're building a lean dropshipping business and want maximum developer control, I'd go:

Next.js + Medusa + PostgreSQL + Redis/queue + supplier APIs + Stripe

If you're building something closer to a large multi-supplier marketplace/platform, I'd seriously consider:

Next.js + Saleor + PostgreSQL + supplier integration services

One caveat: for dropshipping, the commerce platform is only half the architecture. I'd keep supplier integrations in a separate integration layer rather than tightly coupling every supplier's API to your storefront. That makes replacing suppliers, retrying failed orders, normalizing inventory, and handling supplier-specific quirks much easier.

If you tell me your expected order volume, number of suppliers, and whether suppliers expose REST/GraphQL/CSV APIs, I can recommend the exact architecture between Medusa and Saleor.

For a custom dropshipping site where fast API integrations are the priority, I’d shortlist Medusa, Saleor, and commercetools, with Medusa as my default recommendation.

Why I'd pick Medusa

Medusa documentation

Medusa is particularly attractive for dropshipping because you're likely to need custom integrations with supplier APIs, product feeds, inventory systems, fulfillment providers, payment services, and automation rather than simply running a conventional storefront.

Its V2 Store API is REST-based and it provides a JavaScript SDK, while the framework is explicitly designed around custom modules, workflows, API routes, and event-driven integrations. docs.medusajs.com

That makes an architecture like this fairly natural:

                 ┌───────────────┐
                 │ Next.js Store │
                 └───────┬───────┘
                         │
                    Medusa API
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
     Supplier APIs   Payments       Fulfillment
          │
          ▼
   Inventory / Pricing
     synchronization

You can also put your own integration layer around Medusa:

Supplier A ─┐
Supplier B ─┼─> Integration Service ─> Medusa
Supplier C ─┘          │
                       ├─ inventory sync
                       ├─ price updates
                       ├─ order routing
                       └─ tracking updates

That separation is valuable in dropshipping because supplier APIs tend to change, and you don't want supplier-specific logic scattered throughout your commerce backend.

When I'd choose Saleor instead

Saleor

If your team is strongly GraphQL-first, I'd seriously consider Saleor. Its commerce API is GraphQL-native, it exposes 140+ webhooks, and its architecture is explicitly API-first/headless. saleor.io

I'd favor it over Medusa if you expect:

• complex multi-channel catalogs
• sophisticated internationalization
• lots of custom frontend applications
• GraphQL throughout your stack
• more enterprise-oriented commerce requirements

When commercetools makes sense

commercetools

I'd choose commercetools when you're building something substantially larger than a typical dropshipping operation—multiple markets, complicated pricing, B2B/B2C combinations, large catalogs, multiple warehouses, etc. It's explicitly API-first and designed for composable commerce. commercetools.com

For an early-stage custom dropshipping business, though, I'd generally rather spend that complexity budget on supplier integrations and automation than on the commerce platform itself.

My ranking for your scenario

1. Medusa — 9/10
Best balance of API flexibility, TypeScript ecosystem, customization, and speed.

2. Saleor — 8.5/10
Excellent if you're GraphQL-native and expect a sophisticated commerce model.

3. Shopify Storefront API — 8/10
Great if you value managed infrastructure and Shopify's ecosystem more than backend control.

4. commercetools — 7.5/10 initially
Excellent technology, but I'd reserve it for an enterprise-scale operation.

One important dropshipping consideration: don't choose based solely on the storefront API. The harder problem will likely be supplier synchronization—normalizing product schemas, inventory, prices, variants, orders, cancellations, and tracking across suppliers. I'd design that integration layer independently of whichever commerce engine you choose.

If you're building this with Next.js + TypeScript, I'd personally start with Medusa + PostgreSQL + a separate supplier-integration service + webhooks/queues, and keep the supplier abstraction independent so you can swap commerce platforms later.

For a custom dropshipping site where you care about fast API-driven integrations, I would generally recommend Medusa as the first choice, with a few alternatives depending on your architecture. ossalt.comossalt.com

1. Medusa — Best overall for a developer-built dropshipping platform

Best fit: You want maximum control over supplier APIs, custom workflows, pricing rules, and automation.

Why it fits dropshipping:

• API-first architecture — easy to connect supplier feeds, marketplaces, fulfillment APIs, shipping providers, and custom services.
• Node.js + TypeScript stack — ideal if your storefront is Next.js/React and you want one language across the stack.
• Modular backend — you can replace or extend carts, payments, inventory, fulfillment, and order logic.
• Easier to build custom flows like:
  • supplier routing
  • automatic product importing
  • inventory synchronization
  • dynamic margins
  • AI product enrichment
  • multi-vendor fulfillment

Tradeoff:

• You own more infrastructure and engineering decisions than with SaaS platforms. ossalt.comossalt.com

A typical stack:

Next.js storefront
        |
        v
Medusa commerce API
        |
        +--> Supplier APIs (AliExpress, CJdropshipping, wholesalers)
        +--> Stripe/PayPal
        +--> Shipping APIs
        +--> ERP/analytics
        +--> Email/SMS automation

2. Saleor — Best if you prefer GraphQL and Python

Best fit: Larger catalogs, complex inventory, multi-channel commerce.

Strengths:

• Excellent GraphQL API design.
• Strong support for:
  • multiple warehouses
  • multiple currencies
  • multiple storefronts
  • complex pricing structures

Tradeoff:

• Better suited to teams already comfortable with Python/Django.
• More enterprise-oriented than a lightweight dropshipping MVP. www.wpbundle.com

3. Shopify (headless) — Best for speed to market

Best fit: You want to launch quickly and rely on an established ecosystem.

Advantages:

• Mature checkout.
• Huge app ecosystem.
• Lots of existing dropshipping integrations.
• Less infrastructure to maintain.

Tradeoffs:

• Custom backend workflows can become constrained.
• You may end up fighting Shopify's data model if you build a highly customized system. hunchbite.com

4. commercetools — Best for serious scale

Best fit: Enterprise dropshipping marketplace, multiple regions, complex B2B relationships.

Pros:

• Extremely API-centric.
• Designed for composable commerce.

Cons:

• Usually overkill for a startup or small team.
• Higher implementation complexity. naturaily.com

My recommendation by scenario

For a custom dropshipping platform, I would likely build:

• Frontend: Next.js + React
• Commerce engine: Medusa
• Database: PostgreSQL
• Queue/jobs: Redis + BullMQ
• Search: Meilisearch or Algolia
• Payments: Stripe
• CMS: Sanity or Contentful
• Automation layer: custom Node workers for supplier sync

That gives you a commerce core you can bend around dropshipping rather than adapting your business logic around a traditional store platform. ossalt.comossalt.com

For a custom dropshipping site where API-driven integrations are the priority, I’d recommend Medusa as the default choice.

My ranking

Why I’d pick Medusa

Medusa is particularly well suited to dropshipping because you can treat it as the commerce/orchestration layer rather than forcing your supplier workflow into a conventional ecommerce platform.

Its current V2 Store and Admin APIs are REST-based, and it provides a JS SDK plus OpenAPI specifications, making it straightforward to integrate supplier APIs, inventory systems, shipping services, payment providers, etc. docs.medusajs.com

More importantly, Medusa's framework lets you create custom API routes, workflows, data models, modules, and event subscriptions. That's useful for flows such as:

Customer
   ↓
Your Next.js storefront
   ↓
Medusa
   ├── Product/catalog
   ├── Cart/checkout
   ├── Payments
   ├── Orders
   └── Custom dropship workflow
          ↓
      Supplier API
          ↓
   Inventory / fulfillment
          ↓
      Tracking → Customer

You can also integrate third-party fulfillment, payments, search, ERP, CMS, notifications, etc.; Medusa explicitly supports building your own integrations rather than requiring everything to come from its ecosystem. docs.medusajs.com

The dropshipping-specific advantage

I'd structure your supplier integration as a custom Medusa module/workflow, rather than putting supplier API calls directly in your frontend.

For example:

placeOrder()
  → validate inventory
  → create Medusa order
  → submit supplier order
  → receive supplier order ID
  → update fulfillment status
  → poll/webhook tracking
  → update customer order

That gives you room to support multiple suppliers later:

                  ┌─ Supplier A API
Medusa Workflow ──┼─ Supplier B API
                  ├─ Supplier C API
                  └─ Your own warehouse

Medusa's documentation specifically describes integrations as a way to synchronize data and use the platform as a middleware layer between external systems. docs.medusajs.com

When I'd choose Saleor instead

If your entire stack is GraphQL/TypeScript/React and you strongly prefer GraphQL, I'd seriously consider Saleor.

Saleor is API-only and GraphQL-native, with webhooks, apps, API extensions, and native multi-channel capabilities. saleor.io

I'd choose:

Medusa → REST, Node/TypeScript, maximum backend customization, supplier/fulfillment orchestration.

Saleor → GraphQL-first architecture, sophisticated catalog/multichannel requirements.

commercetools → enterprise-scale composable architecture where budget and operational complexity aren't major concerns. Its integration model includes HTTP/GraphQL APIs, bulk Import APIs, subscriptions, and API extensions. docs.commercetools.com

My recommendation for your project

If you're a developer building the site yourself, I'd go:

Next.js + TypeScript → Medusa → PostgreSQL → supplier APIs → Stripe → shipping/tracking APIs

and keep the supplier integration entirely behind your Medusa backend.

That gives you a very flexible foundation without paying the complexity/enterprise tax of commercetools. powergatesoftware.com

Medusa documentation
Medusa integrations
Saleor documentation

For a custom dropshipping site where fast API-driven integrations are the priority, I would usually shortlist Medusa, Saleor, and Shopify (headless). The best choice depends on whether you optimize for developer control, speed to market, or operational simplicity. vendure.ionaturaily.com

My recommendation:

1. Best fit for a developer-built dropshipping platform: Medusa

I would pick Medusa for most custom dropshipping builds. hunchbite.comnaturaily.com

Why it fits:

• API-first, headless by design
• Built with Node.js/TypeScript, so it fits well with modern stacks like Next.js, React, and serverless functions
• Easy to customize:
  • supplier APIs
  • product ingestion pipelines
  • automated pricing rules
  • inventory sync
  • custom fulfillment workflows
  • AI product enrichment
• You own the backend logic instead of bending a SaaS platform around your workflow

A typical architecture:

Next.js storefront
        |
        |
Medusa commerce API
        |
 -------------------------
 |          |             |
Supplier   Payments     Fulfillment
APIs       Stripe       3PL APIs
AliExpress
CJ Dropshipping
Printful
ERP feeds

Good for:

• building a Shopify competitor/niche marketplace
• multiple suppliers
• custom automation
• rapid experimentation

Tradeoff:

• You own more infrastructure and engineering work. powergatesoftware.com

2. Fastest launch: Shopify Headless + Storefront API

If your priority is launching a profitable store quickly, Shopify is hard to beat. vendure.ionaturaily.com

Pros:

• Mature checkout
• Huge app ecosystem
• Payments, taxes, orders, fraud tooling are already solved
• Easier for non-engineering teams

Good stack:

Next.js / Hydrogen storefront
          |
 Shopify Storefront API
          |
 Shopify Admin + Apps

Best when:

• you are dropshipping normal products
• you need to validate demand
• you don't want to maintain commerce infrastructure

Tradeoff:

• Custom supplier workflows can become awkward.
• You may end up building many Shopify apps/functions to work around platform constraints. www.askantech.com

3. Best GraphQL-first option: Saleor

Consider Saleor if your team prefers Python and GraphQL. hunchbite.comnaturaily.com

Strengths:

• Clean GraphQL API
• Good multi-channel support
• Strong catalog modeling
• Open source

Good for:

• larger catalogs
• international selling
• complex inventory models

Tradeoff:

• More backend complexity than Medusa for a typical JavaScript-heavy team. hunchbite.comnaturaily.com

My ranking for a custom dropshipping startup

naturaily.com

For a developer building a custom dropshipping site, my stack would likely be:

• Frontend: Next.js + React
• Commerce backend: Medusa
• Database: PostgreSQL
• Search: Algolia or Meilisearch
• Payments: Stripe
• Queue/events: Redis + workers
• CMS: Sanity or Contentful
• Supplier layer: custom integration service

That gives you a system where adding a new supplier is just another connector rather than a plugin dependency.

If you expect 10k+ products, multiple suppliers, automated repricing, and marketplace-style features, I would lean even more strongly toward Medusa or a custom commerce engine rather than Shopify.

For a custom dropshipping site where fast API-driven integrations are the priority, I would generally recommend Medusa as the first choice, with a few caveats. The best platform depends on whether you value maximum customization, fastest launch, or operational simplicity. vendure.ionaturaily.com

My shortlist:

powergatesoftware.comhunchbite.com

My recommendation for a developer building a dropshipping engine

Pick Medusa if you are building something like:

• Multiple supplier integrations (AliExpress-style suppliers, wholesalers, private APIs)
• Automated product imports
• Dynamic pricing rules
• Custom order routing
• Supplier-specific fulfillment logic
• AI product enrichment
• Custom admin dashboards
• Marketplace-style workflows

A typical architecture:

Next.js storefront
        |
        |
Medusa commerce backend
        |
        +-- Supplier APIs
        +-- Inventory sync workers
        +-- Payment providers
        +-- Shipping APIs
        +-- Analytics/events

Medusa's Node/TypeScript ecosystem is particularly attractive because your frontend, backend extensions, workers, and integrations can share the same language stack. powergatesoftware.comhunchbite.com

When I would choose Shopify instead

Use Shopify headless if your priority is:

• Launching in weeks rather than months
• Avoiding infrastructure management
• Using existing fulfillment/payment apps
• Having nontechnical operators manage the store

Shopify's ecosystem is hard to beat, especially for standard ecommerce flows. The tradeoff is that your custom business logic must work within Shopify's APIs and extension model. vendure.ionaturaily.com

When I would avoid pure headless

For a small dropshipping MVP (for example, 20–200 products, one supplier, testing ads), a fully custom headless stack may slow you down. A simpler Shopify setup can validate demand faster.

For a developer-led dropshipping platform that you expect to evolve into a proprietary system, my ranking would be:

1. Medusa — best balance of control + developer velocity
2. Shopify Hydrogen — best operationally, fastest commercial launch
3. Saleor — best if you are already a Python/GraphQL team
4. commercetools — best only when enterprise complexity justifies it

For a serious custom dropshipping product, I would likely build Next.js + Medusa + PostgreSQL + Redis + queue workers and treat suppliers/fulfillment providers as replaceable integrations.

For a custom dropshipping site where API-driven integrations are the priority, I’d recommend Medusa as the default choice.

My ranking

🥇 Medusa — my pick

Medusa is particularly attractive for dropshipping because you can treat commerce as an API/backend rather than fighting a prebuilt storefront.

Medusa v2 provides separate Store and Admin REST APIs, with an official JS SDK and OpenAPI reference. That makes it straightforward to build integrations for supplier feeds, inventory synchronization, order routing, fulfillment, pricing, and custom automation. docs.medusajs.com

A typical architecture could be:

Next.js / React storefront
          │
          ▼
      Medusa API
       │      │
       │      ├── Payments
       │      ├── Customers / Orders
       │      └── Pricing / Promotions
       │
       ├── Supplier API A
       ├── Supplier API B
       ├── Inventory sync
       ├── Fulfillment / shipping API
       └── Webhook / event workers

The big advantage is that your supplier integrations don't have to conform to Shopify's model. You can build the commerce data model and workflows around your actual dropshipping operation.

🥈 Saleor — excellent alternative

Saleor is arguably even more API-native: it's GraphQL-only, headless, and open source, with APIs and webhooks designed for composable integrations. It also supports native multi-channel commerce. github.com

I'd choose Saleor over Medusa if your team is particularly comfortable with GraphQL/Python and you're expecting sophisticated multi-region/multi-channel requirements.

When I'd choose Shopify instead

Shopify + Hydrogen is the safer choice if your priority is getting to market extremely quickly and leveraging Shopify's enormous ecosystem rather than owning the commerce backend architecture. Current comparisons consistently put Shopify ahead for speed-to-market and ecosystem breadth. www.askantech.com

For a developer building a genuinely custom dropshipping platform, though, I'd generally prefer Medusa because you have considerably more control over the backend and integration layer.

Bottom line:
Medusa + Next.js + PostgreSQL + Redis + background workers would be my starting stack. If your supplier integrations are unusually complex or you're building a multi-market platform, I'd seriously evaluate Saleor alongside it.

For a custom dropshipping site where fast API-driven integrations are the priority, I’d recommend Medusa.

My ranking

Why I’d pick Medusa

Medusa is particularly well suited if you're going to build your own supplier/order-routing layer rather than simply bolt a custom frontend onto a traditional ecommerce platform.

Its architecture lets you create custom modules, API routes, workflows, and third-party integrations. The current Store API is REST-based, and Medusa provides an official JavaScript SDK, which is convenient if you're building with Next.js/TypeScript. docs.medusajs.com

More importantly for dropshipping, Medusa explicitly supports integrations for things like fulfillment, payments, ERP, CMS, search, notifications, and custom third-party services. Its docs specifically describe using it as a middleware layer between your commerce system and external data sources. docs.medusajs.com

That maps nicely onto a dropshipping architecture:

Your Next.js storefront
        │
        ▼
     Medusa API
        │
   ┌────┴─────────────┐
   ▼                  ▼
Product/Supplier    Order workflow
aggregation         & routing
   │                  │
   ├─ Supplier A      ├─ Supplier API
   ├─ Supplier B      ├─ Supplier C
   └─ Supplier C      └─ 3PL / fulfillment
        │
        ▼
   Stripe / payments

You can build a supplier adapter layer so every supplier exposes a normalized interface such as:

getProducts()
getInventory()
getShippingRates()
createOrder()
getOrderStatus()
cancelOrder()

Then adding supplier #20 doesn't require rewriting your commerce logic.

When I'd choose Saleor instead

If your entire stack is GraphQL-first, I'd seriously consider Saleor. Saleor is API-only and GraphQL-native, with webhooks and an app/extension architecture designed for composable integrations. saleor.io

So:

• REST + TypeScript + maximum backend customization → Medusa
• GraphQL + strongly typed API ecosystem → Saleor
• Enterprise-scale composable commerce → commercetools
• Want the least commerce infrastructure to maintain → Shopify Plus

For a new custom dropshipping business, I'd start with Medusa + Next.js + PostgreSQL + Redis + Stripe + a supplier adapter service. That gives you considerably more control over supplier synchronization, inventory normalization, automated order routing, and margins than trying to force a conventional Shopify-style architecture into the problem.

Medusa documentation
Saleor documentation 

If you’re building a custom dropshipping site where API integrations are the priority, my first choice would be Medusa.

My ranking

Why Medusa: it's built as a headless commerce backend rather than a traditional storefront platform. Its current v2 APIs are REST-based, it has a JavaScript/TypeScript SDK, and you can create your own API routes, workflows, data models, and modules. docs.medusajs.com

That makes it particularly attractive for dropshipping, where you may want a custom pipeline like:

Supplier API → product normalization → Medusa → custom storefront → payment → order → supplier API → tracking webhook

You can implement supplier-specific logic without trying to force everything through a marketplace's plugin architecture.

When I'd choose the others

Saleor would be my #2. It's especially compelling if your team likes GraphQL: Saleor is GraphQL-native, supports custom webhook payloads, has extensive webhook/extension capabilities, and explicitly positions itself as technology-agnostic. docs.saleor.io

Shopify is the pragmatic choice if your priority is getting operational quickly rather than owning the commerce backend. You get a mature hosted backend and enormous integration ecosystem, while still being able to build a custom headless frontend. Current comparisons generally put Shopify ahead for time-to-market, while Medusa/Saleor offer more backend customization. www.askantech.com

commercetools is the technically strongest option I'd consider for a large enterprise operation. It's explicitly API-first and offers hundreds of commerce APIs, but its enterprise/composable architecture is usually more infrastructure than a new dropshipping operation needs. commercetools.com

What I'd build

For a greenfield project today, I'd probably use:

Next.js + Medusa + PostgreSQL + Redis + Stripe + supplier APIs + a queue/workflow system

with Medusa handling products, carts, customers, orders, inventory, fulfillment, and commerce workflows, while your own integration layer handles supplier-specific synchronization and order routing. Medusa's commerce modules already cover core domains such as products, orders, customers, fulfillment, and inventory. docs.medusajs.com

If you tell me which suppliers/APIs you're planning to integrate (AliExpress, CJ Dropshipping, Printful, Shopify suppliers, private wholesalers, etc.), I can recommend the architecture and platform specifically around those integrations.

For a custom dropshipping site where API-driven integrations are the priority, I’d generally shortlist Medusa, Saleor, and Shopify headless. The right choice depends on how much control you need over supplier integrations, order routing, pricing logic, and fulfillment automation.

My default recommendation for a developer-led dropshipping build:

1. Medusa — Best overall for custom dropshipping workflows

Pick this if you want to own the commerce logic.

Why it fits dropshipping:

• Node.js + TypeScript stack (great match with Next.js frontends)
• Modular architecture for custom:
  • supplier APIs
  • product ingestion pipelines
  • inventory synchronization
  • dynamic pricing rules
  • custom fulfillment workflows
  • multi-vendor logic
• REST APIs and SDK tooling make integrations straightforward
• You avoid fighting against a rigid SaaS checkout/order model hunchbite.com

A typical architecture:

Next.js storefront
        |
        v
Medusa commerce backend
        |
        +--> Supplier APIs (AliExpress, CJ, private vendors)
        |
        +--> Inventory sync service
        |
        +--> Pricing engine
        |
        +--> Shipping providers
        |
        +--> Payment providers

Downside: You own more infrastructure and operational complexity.

Best for:

• custom dropshipping platforms
• niche marketplaces
• automation-heavy stores
• engineering teams comfortable with TypeScript

2. Saleor — Best for API-first / GraphQL-heavy systems

Saleor is excellent if your team prefers GraphQL and Python. It is designed around headless commerce, with APIs as the primary interface and support for complex commerce models like channels and multi-region setups. saleor.io

Strengths:

• GraphQL-native
• strong catalog modeling
• good multi-channel support
• clean separation between storefront and commerce engine
• good for complex operations

Weakness:

• Python/Django stack means more backend specialization
• probably slower for a TypeScript-heavy startup team

Best for:

• enterprise-style dropshipping
• multiple storefronts
• international catalogs
• teams already using Python

3. Shopify Headless — Best if speed matters more than flexibility

Shopify's Storefront API lets you build a custom frontend while keeping Shopify's mature backend, checkout, admin, payments, and ecosystem. shopify.dev

Advantages:

• fastest path to production
• excellent admin experience
• huge app ecosystem
• less infrastructure to maintain

Disadvantages for serious dropshipping:

• custom supplier workflows can become awkward
• complex order splitting/routing may require workarounds
• platform constraints appear as your automation grows

Best for:

• validating a product idea
• standard dropshipping flows
• small teams wanting to launch quickly

My ranking for a custom dropshipping startup

For a developer building a dropshipping platform from scratch, I would likely choose:

Frontend: Next.js + TypeScript
Commerce core: Medusa
Database: PostgreSQL
Queue/events: Redis + background workers
CMS: Sanity/Contentful
Search: Algolia/Meilisearch
Supplier integration layer: separate microservice

The key architectural decision is: do not put supplier sync logic directly inside your commerce platform. Keep supplier APIs, inventory syncing, and product normalization as separate services so adding vendors later does not require rewriting your store.

For a custom dropshipping site where API-driven integrations are the priority, I’d usually shortlist Medusa, Shopify (headless), and Saleor. The best choice depends on whether you value maximum control or fastest launch. hunchbite.comvendure.io

My top recommendation: Medusa

Best fit: developer-built dropshipping platforms with custom supplier, fulfillment, and automation workflows.

Why I’d pick it for a custom dropshipping stack:

• API-first architecture — designed to be the commerce backend behind your own frontend.
• Node.js/TypeScript ecosystem — easy fit with Next.js, serverless functions, queues, and modern integrations.
• Great for custom logic, such as:
  • supplier API synchronization
  • dynamic pricing rules
  • automated product imports
  • custom order routing
  • multi-vendor workflows
  • custom checkout experiences
• No forced SaaS constraints — you control the database and backend behavior. hunchbite.com

A typical stack:

Next.js storefront
        |
        |
Medusa commerce API
        |
        +-- Supplier APIs (AliExpress, CJdropshipping, Printful, custom vendors)
        +-- Payment providers
        +-- Shipping APIs
        +-- ERP/inventory systems
        +-- Email/SMS automation

The tradeoff: you own more infrastructure and need to build more pieces yourself compared with Shopify. hunchbite.com

Best for fastest launch: Shopify Headless (Hydrogen + Storefront API)

Choose this if your priority is getting a dropshipping business live quickly.

Advantages:

• Excellent checkout reliability
• Huge app ecosystem
• Many existing dropshipping integrations
• Less backend maintenance
• Strong admin experience

Shopify’s headless approach lets you keep Shopify’s commerce backend while building a custom frontend. pharosproduction.comvendure.io

Downside:

• Custom business logic can become awkward
• You may end up fighting Shopify’s data model for unusual workflows
• More vendor dependency

Good choice if your workflow is:

"Import products → customize storefront → market aggressively → optimize conversions"

Best GraphQL-first option: Saleor

Choose Saleor if you have a Python-heavy team or want a very structured GraphQL commerce API.

Strengths:

• GraphQL-native
• Strong multi-channel support
• Good for complex catalogs and international selling
• Open source

Tradeoff:

• Smaller ecosystem than Shopify
• More backend complexity than a typical dropshipping startup needs hunchbite.comvendure.io

My ranking for a custom dropshipping developer

pharosproduction.comvendure.io

For a developer building a dropshipping platform rather than just a storefront, I would lean Medusa + Next.js + a workflow engine (like Temporal or BullMQ) + supplier adapters. That architecture gives you room to evolve into a marketplace, private supplier network, or automated fulfillment system later.

For a custom dropshipping site where fast API-driven integrations are the priority, I’d usually shortlist Medusa, Shopify headless, and commercetools—but my default recommendation for a developer-led build would be:

1. Medusa — Best fit for a custom dropshipping platform

My top pick for a developer building a bespoke dropshipping system. hunchbite.com

Why it fits:

• API-first architecture (REST + GraphQL options)
• Built with Node.js/TypeScript, so it fits well with modern web stacks
• Easy to customize product, pricing, fulfillment, supplier, and order workflows
• Good foundation for:
  • supplier APIs
  • inventory sync
  • automated product imports
  • custom checkout logic
  • multi-vendor workflows
  • AI-driven merchandising

A typical stack:

Next.js storefront
        |
        ↓
Medusa commerce backend
        |
        ↓
PostgreSQL + Redis
        |
        ↓
Supplier APIs / ERP / fulfillment APIs

Trade-off:

• You own more infrastructure.
• You’ll build more things yourself compared with Shopify (tax rules, some integrations, advanced workflows). www.askantech.com

Choose Medusa if: your competitive advantage is your custom automation layer.

2. Shopify Headless — Best if you want reliability over control

Using Shopify’s Storefront API with a custom frontend (often Hydrogen or Next.js) gives you:

• mature checkout
• payments
• inventory primitives
• huge app ecosystem
• less operational burden vendure.iopharosproduction.com

Architecture:

Next.js / Hydrogen frontend
          |
          ↓
Shopify Storefront API
          |
          ↓
Shopify backend
          |
          ↓
Dropship apps + supplier integrations

Trade-off:

• Backend customization is limited.
• Complex supplier routing or unusual fulfillment logic can become awkward.

Choose Shopify headless if: you want to launch quickly and your dropshipping workflow is fairly standard.

3. commercetools — Enterprise-grade option

Best when you’re building something closer to an Amazon-style marketplace:

• many suppliers
• multiple regions
• complex pricing
• B2B + B2C
• large catalogs

Trade-offs:

• Higher engineering complexity
• More enterprise-oriented cost structure pharosproduction.comhunchbite.com

My ranking for a custom dropshipping developer

pharosproduction.comhunchbite.com

What I would build today

For a serious dropshipping startup:

• Frontend: Next.js + React
• Commerce core: Medusa
• Database: PostgreSQL
• Queue/events: Redis + BullMQ
• Search: Algolia or Meilisearch
• CMS: Sanity or Contentful
• Payments: Stripe
• Automation layer: custom supplier connectors
• Shipping: Shippo/EasyPost-style API abstraction

The key architectural decision is not the storefront—it’s your supplier integration layer. A good dropshipping platform should treat suppliers as plugins/adapters, not hardcoded integrations.

If you expect to integrate with AliExpress, CJdropshipping, Spocket, Printful, private suppliers, or wholesale APIs, I’d lean strongly toward Medusa or a custom commerce engine rather than Shopify.