Most headless CMS comparisons read like the vendor wrote them. Every platform is "flexible," every API is "blazing fast," and somehow every tool is perfect for every use case. That's not useful when you're trying to ship a storefront that actually converts.
I've run two stores past $1M ARR, and the CMS choice bit me both times — once because I over-engineered it, once because I under-invested. Finding the best headless CMS for ecommerce is less about checking feature boxes and more about understanding where each tool breaks under real operating conditions.
This post covers the four headless CMS options I'd actually consider for an SMB ecommerce build in 2024, how they price at scale, and the one thing each gets wrong that the vendor won't tell you.
Why Headless CMS Matters More Than Your Cart Choice
Your cart handles transactions. Your CMS handles everything else — product descriptions, landing pages, blog posts, size guides, campaign banners, localized content. That's 80% of what a customer reads before they buy.
A slow or inflexible CMS creates a content bottleneck that no amount of checkout optimization fixes. I've seen stores spending $5,000/month on paid acquisition while their merchandising team waits 3 days for a developer to update a homepage banner. That's a CMS problem, not a marketing problem.
Headless architecture separates content management from content delivery. Your editors work in a clean UI; your frontend fetches content via API and renders it however you want — Next.js, Nuxt, Astro, whatever. The tradeoff is real though: you're taking on more infrastructure responsibility in exchange for that flexibility.
The Four Contenders Worth Your Time
I'm not listing ten tools. I'm listing the four that survive contact with actual ecommerce requirements: high content volume, structured product data, multi-channel delivery, and editors who aren't developers.
Contentful
Contentful is the 800-pound gorilla. It's been around since 2013, has a mature API, and the content modeling is genuinely powerful. The free tier gives you 5 users and 25,000 API calls/month — enough to prototype but not enough to run a real store.
Where it gets painful: pricing. The Team plan starts at $300/month (as of early 2024) and the Enterprise tier is custom-quoted, which usually means $2,000+/month once you need SSO, custom roles, or serious API rate limits. For a $500K/year store, that's a meaningful overhead percentage.
The content modeling UI is excellent. Editors can create and manage structured content without developer help after initial setup. The Delivery API is fast — Contentful's CDN typically serves responses under 100ms globally.
What the pitch deck skips: the GraphQL API (called the Content API) has a complexity limit that will bite you once your content model gets intricate. Deeply nested queries get rejected. You'll end up writing multiple shallow queries and stitching them client-side, which adds latency and developer frustration.
Best for: Stores with $50K+/month revenue that need serious content operations and have a developer to manage the integration.
Sanity
Sanity is my personal preference for mid-market ecommerce. The Studio (their editor UI) is React-based and fully customizable — you can build custom input components that match exactly how your merchandising team thinks about products. That matters more than it sounds.
Pricing is consumption-based. The free tier includes 3 users and 500K API requests/month. The Growth plan is $15/user/month plus API usage overages. A 5-person content team with moderate traffic runs roughly $75–$150/month. That's dramatically cheaper than Contentful at comparable scale.
Sanity uses GROQ (their own query language) instead of GraphQL. GROQ is genuinely more expressive for content queries — projections, joins, filtering all feel natural once you're past the 2-hour learning curve. Here's a basic product query:
*[_type == "product" && slug.current == $slug]{
title,
price,
"categoryName": category->name,
images[]{
asset->{
url,
metadata{
dimensions
}
}
}
}[0]
That single query fetches a product with its category name (via reference resolution) and image metadata. No N+1 problem, no stitching.
What Sanity gets wrong: real-time collaboration is still not as polished as Google Docs-style tools. Two editors hitting the same document can create merge conflicts that confuse non-technical users. It's improving, but if your team edits content simultaneously at high frequency, expect occasional friction.
Best for: Stores doing $10K–$500K/month that want flexibility without Contentful's price tag, and have at least one developer comfortable with JavaScript.
Storyblok
Storyblok occupies a different position: it's the most editor-friendly option in this list. The visual editor lets content managers see a live preview of the page while editing components. For marketing teams that live in fear of breaking things, this is genuinely reassuring.
Pricing: the Community plan is free up to 1 user and 25K monthly visits. The Entry plan is $99/month for 5 users. The Business plan jumps to $599/month. That middle tier is awkwardly priced for small teams.
The component-based content model maps well to ecommerce landing pages and campaign pages. You can build a page from reusable blocks — hero, product carousel, testimonials, CTA — and editors assemble pages without writing a line of HTML.
The catch: Storyblok is optimized for pages, not for large structured datasets. If you have 50,000 SKUs with complex variant data, Storyblok's content model gets unwieldy fast. It's better as a companion CMS (managing editorial content alongside a dedicated PIM or your commerce platform's product catalog) than as your single source of truth for product data.
Best for: Stores where the marketing team outnumbers the developers and campaign landing pages are a primary growth lever.
Hygraph (formerly GraphCMS)
Hygraph is the GraphQL-native option. If your frontend team is already deep in GraphQL and you want schema federation — connecting your CMS content graph to your commerce API graph — Hygraph is worth a serious look.
The free tier is generous: 2 users, 1M API operations/month, 100GB asset bandwidth. The Professional plan is $199/month. Enterprise is custom.
Content federation is the headline feature: you can extend your Hygraph schema to pull in data from external APIs (your Shopify product data, your ERP inventory) and expose it all through a single GraphQL endpoint. That's architecturally elegant and reduces frontend complexity significantly.
Where it falls short: the editor UI is the weakest in this group. Non-technical content managers find it less intuitive than Sanity Studio or Storyblok's visual editor. If your content team is small and technical, that's fine. If you have five editors who need to work independently, expect a training overhead.
Best for: Developer-led teams building federated data architectures who want one GraphQL endpoint for everything.
Side-by-Side Comparison
| Contentful | Sanity | Storyblok | Hygraph | |
|---|---|---|---|---|
| Starting paid price | $300/month | ~$75/month | $99/month | $199/month |
| Free tier API calls | 25K/month | 500K/month | 25K visits | 1M ops/month |
| Query language | REST + GraphQL | GROQ | REST | GraphQL |
| Editor experience | Good | Customizable | Best-in-class | Weakest |
| Large product catalogs | Good | Excellent | Poor | Good |
| Content federation | No | No | No | Yes |
| Self-hostable | No | Studio only | No | No |
How to Pick Without Overthinking It
Here's the decision tree I'd actually use:
Is your content team non-technical and do they manage lots of campaign pages? → Storyblok.
Are you building a federated data layer or going all-in on GraphQL? → Hygraph.
Do you have serious content operations needs and budget to match? → Contentful.
Everything else? → Sanity.
Sanity wins the default case because the pricing is honest, the query language is genuinely better for content graphs, and the Studio customizability means you can adapt the editing experience as your catalog grows. I've used it in production for a store with 12,000 SKUs and a 4-person content team. It held up.
One thing I'd add: don't let the CMS decision delay your launch. All four tools have solid Next.js starter kits. You can migrate CMS content later — it's painful but it's been done. You cannot easily migrate a poorly structured content model, though. Spend your first week on content modeling, not on comparing pricing tiers.
If you're pairing your headless CMS with a commerce backend, the integration approach matters as much as the CMS itself. I covered how to connect a headless CMS to a Shopify storefront in this post on headless Shopify architecture, and there's a practical walkthrough of Next.js + Sanity for product pages in the headless commerce starter guide.
What the Benchmarks Don't Tell You
Every vendor publishes sub-100ms API response times. That's the CDN talking, not the CMS. What matters in production:
- Webhook reliability. When you publish content, does your frontend rebuild within 30 seconds or 5 minutes? Sanity and Contentful are both solid here. Hygraph has had occasional webhook delays in my testing.
- Rate limit behavior. Does the API queue excess requests or drop them? Contentful drops. Sanity queues. That's a meaningful difference at traffic spikes.
- Asset transformation. All four tools offer image transformation via URL parameters (resizing, format conversion). Sanity's asset pipeline via Sanity Image URLs is the most flexible — you can request WebP at any dimension without pre-generating variants.
These are the things you discover at 2 AM during a flash sale, not during a demo call.
The Bottom Line
The best headless CMS for ecommerce isn't the one with the most features — it's the one your team will actually use correctly at 11 PM before a product launch. For most SMB stores, that's Sanity: honest pricing, expressive querying, and a customizable editor that grows with your catalog.
Start with Sanity's free tier tomorrow. Model two content types — product and landing page — and wire up a basic Next.js fetch. You'll know within a week whether it fits your team's workflow. If it doesn't, the migration cost at prototype stage is two hours, not two weeks.