I used Contentful for years. It was fine. The content model was decent, the API was fast, the editorial experience was good enough. Then on April 30, 2025, Contentful decided that "free" meant 25 content types, 100K API calls, and a $300/month cliff if you go over.
We had 30+ content types. The math was simple. We left.
Why Sanity
I evaluated Strapi, Payload, Storyblok, and Sanity. Here's the honest version of that evaluation:
Strapi is open source and self-hosted. Great for data sovereignty. Terrible if you don't want to maintain a Node.js server, a Postgres database, and all the DevOps that comes with it. I run a software studio. I have engineers. I still didn't want to babysit a CMS server.
Payload is fascinating — a CMS that lives inside your Next.js app. One deployment unit. TypeScript-native. 42K GitHub stars. If we were on Next.js, I'd seriously consider it. We're on Astro. Moving on.
Storyblok has the best visual editing for marketers. Drag-and-drop, WYSIWYG, the whole thing. But our marketers are me, and I type Markdown in a text editor. Visual page builders solve a problem I don't have.
Sanity gave me 20 seats, 10,000 documents, 1 million CDN requests, and 100GB bandwidth. Free. The Studio is React-based — same stack our team uses for client work. The content model is defined in code, not clicked together in a UI. And the query language (GROQ) is genuinely better than GraphQL for content.
That's it. That's the evaluation. Sometimes the right answer is the one that costs nothing and works immediately.
What Sanity actually is
Sanity is a headless CMS with a twist: the editing interface (Sanity Studio) is a React app that you own, customize, and deploy. The content lives in Sanity's cloud (the "Content Lake"). You query it with GROQ or GraphQL. You render it with whatever frontend you want.
The Studio runs at your-project.sanity.studio or on your own domain. You define schemas in TypeScript. You build custom input components in React. You can replace literally any part of the editing interface with your own code. Most CMSes give you a settings panel. Sanity gives you a React app.
This means the setup cost is higher than WordPress. You'll spend developer time configuring the Studio. But the ceiling is also higher — dramatically higher. Our Studio has custom preview components for blog posts, structured case study schemas with stack arrays and metric objects, and an author reference system. Took a few hours to set up. Works exactly how we need it to.
GROQ is weird. GROQ is also better.
GROQ (Graph-Relational Object Queries) is Sanity's query language. It looks like nothing you've seen before. The first time you see *[_type == "post"]{title, "author": author->name} you think "what is this syntax." The second time you think "wait, that just resolved a reference in one character."
The -> operator dereferences a reference. In GraphQL, you'd need a resolver, a type definition, and a separate query. In GROQ, you add two characters.
Where GROQ wins over GraphQL: server-side projections (you shape the exact JSON your component needs in the query), no deployment step (schema changes are queryable instantly), real-time subscriptions work natively, and reference following is trivial.
Where GraphQL still wins: schema introspection, cross-source federation, and the fact that every developer on earth already knows it. GROQ has a learning curve. Not a steep one — maybe two hours to be productive, a week to be fluent — but it's one more thing.
Sanity supports both. If your team has strong GraphQL opinions, use GraphQL. You'll give up real-time subscriptions and mutations (Sanity's GraphQL layer is read-only), but you'll get the tooling you already know.
Portable Text: why it matters more than you think
Most CMSes store rich text as HTML. Sanity stores it as a JSON block array called Portable Text.
"Who cares?" You will, the first time you need to render the same content in a React web app, a React Native mobile app, an email template, and an LLM context window. HTML is designed for browsers. Portable Text is designed for anywhere.
Every rendering layer has a Portable Text renderer: React, Vue, Svelte, native iOS, native Android. You write custom serializers for your own block types. An inline "callout" block in the editor becomes a styled callout in the web app, a plain text block in the email, and structured metadata for the AI agent. Same source content, four different outputs, zero HTML parsing.
The trade-off: pasting from Google Docs into the editor doesn't always do what you expect. Block-level formatting survives. Inline formatting sometimes doesn't. Your editors need 15 minutes of training. After that, it's fine.
A bigger trade-off we learned the hard way: pasting rich text from chat interfaces (like Claude's web UI) can silently rewrite relative URLs to absolute ones with the wrong domain. We discovered 146 links pointing to claude.ai instead of eltexsoft.com because Sanity Studio's rich text editor resolved /blog/... against the page URL. We wrote a script to fix them. It took an hour. But it shouldn't have happened, and it wouldn't have if we'd pasted Markdown instead.
The MCP thing is actually a big deal
Sanity has a Model Context Protocol server. MCP is the protocol that lets AI agents (Claude, Cursor, VS Code agents, etc.) interact with external tools. Sanity's MCP server lets an AI agent query your content, create documents, patch fields, manage releases, and run semantic search — all through natural language.
I use this daily. "Query all posts where the slug contains 'outsourcing'." "Patch the seoTitle on document ID 93299147 to this value." "Publish these 13 documents." Claude does it. I verify. Done.
We created blog posts, patched SEO fields across 31 pages, fixed 146 broken links, and published 36 articles through a combination of MCP operations and Studio editing. The MCP connection turns content management from a point-and-click operation into a programmable one.
No other headless CMS has anything close to this in May 2026. Contentful doesn't. Strapi doesn't. Payload doesn't. Sanity's MCP server is the single biggest competitive advantage in the headless CMS market right now, and almost nobody is talking about it because "CMS has an AI integration" sounds like marketing fluff. It's not fluff. It's the difference between manually editing 31 meta descriptions and telling Claude to do it in one prompt.
Real-time collaboration
Multiple editors on the same document. Google-Docs-style cursors. Keystroke-level presence. Conflict-free because the Content Lake is patch-based — every change is a discrete operation, not a full document overwrite.
Most headless CMSes have "collaboration" that means "optimistic locking" — if two people edit the same document, one of them loses. Sanity's collaboration means two people type in the same field at the same time and both changes survive. Contentful would need a near-total architectural rewrite to match this.
I'm the only editor on our site, so I don't use this feature much. But for agencies managing content for clients, or companies with editorial teams, this is the difference between "don't touch that document, I'm editing it" and "go ahead, we're both editing it."
The money
Sanity Free: 20 seats, 10,000 documents, 1M CDN requests, 250K API requests, 100GB bandwidth, 100GB assets. Real-time collaboration, Media Library, GROQ + GraphQL.
Sanity Growth: $15/seat/month (viewers free). 25,000 documents, 5 roles, AI Assist, Comments, Tasks, Scheduled Drafts, Content Releases.
Contentful Free (post-April 2025): 25 content types, 100K API calls, 50GB bandwidth. No grandfathering. Exceeding limits can result in suspension.
Contentful Paid: Somewhere between $300 and $850/month depending on which source you trust (PricingSaaS, Vendr, and CostBench all report different numbers). Get a sales quote. Don't trust the internet, including me.
For a studio our size, Sanity's free tier covers everything. 36 blog posts, 13 case studies, 10 industry pages, 9 tech pages, 22 course chapters, authors, metadata — all well under 10,000 documents. We'll hit Growth when we need Content Releases or Tasks. That's $15/month for one editor seat. Not $300.
Where Sanity falls apart
The Studio needs configuration. A fresh install is functional but bare. You'll spend developer days making it feel good for editors. Schema definitions, custom previews, desk structure, validation rules — it's all code you write. This is simultaneously Sanity's greatest strength and its highest barrier to entry.
Document limits are real. 10K on Free, 25K on Growth. Reference-heavy schemas inflate document counts because references create separate documents. If you have 5,000 blog posts with 3 author references each, those references count. The Increased Quota add-on is $299/month. That's a cliff.
API vs CDN billing will bite you. Direct API requests to api.sanity.io cost 10x more per unit than CDN requests to apicdn.sanity.io. A misconfigured @sanity/client with useCdn: false will inflate your bill for no reason. Always set useCdn: true for read operations.
No self-hosting. The Content Lake is Sanity's cloud. Period. You can export everything (GROQ + export CLI), so migration is feasible, but you're a SaaS customer. If "I own the server" is a hard requirement, use Strapi or Payload.
No native visual page builder. If your primary editor wants to drag-and-drop sections like Squarespace, Sanity is the wrong tool. It has Visual Editing (click-to-edit overlays on your frontend) and the Presentation tool, but it's not a page builder. It's a structured content editor. Different animal.
GROQ is one more thing. Your team learns React. TypeScript. Your framework. Your deployment platform. GROQ. That's a real cost. It pays off, but don't pretend there's no ramp.
The bottom line
Sanity is a CMS for people who think about content as structured data, not as pages. If that sentence resonates with you, Sanity is probably the right choice. If that sentence sounds like unnecessary complexity, Storyblok or WordPress might serve you better. No judgment.
We migrated from Contentful using the official contentful-to-sanity CLI. One command. The content came over clean. The Studio took a day to configure. The MCP integration took 10 minutes. The blog has been running for two weeks with zero issues.
30,000+ organizations use Sanity. Nike, Sonos, Figma, Linear, National Geographic, Shopify, Spotify. $85M Series C. $40M+ ARR. This isn't a bet on an underdog. This is a bet on the CMS that quietly became the default while everyone was arguing about WordPress vs Contentful.
The free tier is generous. The content model is flexible. The AI integration is years ahead. And the query language is weird in the way that good tools are always weird at first — it feels wrong until you realize it's right, and then you can't go back.
We rebuilt eltexsoft.com on Astro + Sanity. The full teardown: Rebuilding Our Agency Website in 2026. The Astro half of the story: Astro in 2026.