Sanity review
Best for structured content at scale

Sanity is not really a CMS in the WordPress sense. It is a hosted document store called the Content Lake, a query language called GROQ, and an editing interface called Studio that you build yourself out of React components and keep in your own repository. That last part is the whole design: the schema is TypeScript in your codebase, it is reviewed in pull requests, and it deploys with your app rather than being clicked together in someone else's admin panel.
That makes it a developer-first tool with an unusually good editor experience on the other side, which is a rare combination. Real-time collaborative editing works the way Google Docs does, the image pipeline handles cropping and transforms so nobody has to open Photoshop, and the Presentation tool gives editors click-to-edit visual editing against a live Next.js preview.
The cost of that flexibility is that Studio is a codebase you own and maintain. Nobody is going to install Sanity over a weekend without a developer, and the free tier's generosity hides a pricing model that gets expensive in a specific direction, which is seats rather than traffic.
Our scorecard
An editorial read across the six dimensions that actually decide whether a platform survives contact with a real content team. Scored against the rest of this directory, not against an abstract ideal.
- Developer experience5/5
Schema as code, typed GROQ queries, and a Studio you extend like any other React app.
- Editor experience4/5
Real-time collaboration and visual editing are excellent. Portable Text takes editors a week to stop fighting.
- Content modelling5/5
References, arrays of blocks and portable rich text handle genuinely complex models without escape hatches.
- Pricing clarity3/5
The rate card is published and readable, but per-seat billing punishes exactly the teams that get value from collaboration.
- Lock-in risk3/5
Content exports cleanly as NDJSON, but GROQ queries and Portable Text do not port anywhere else.
- SEO and AEO fit5/5
Nothing about the delivery layer constrains rendering, so metadata, canonicals and schema stay entirely yours.
An editorial read, not an aggregate of user reviews, and deliberately kept out of this page's structured data.
Sanity in their own words
From Sanity's own YouTube channel. Vendor marketing rather than an independent review, included because it is the quickest way to see the product before you sign up.
What you can query
Query API (GROQ)
HTTP GET or POST, or the typed @sanity/client
Arbitrary shaped JSON from a single query, including joins across references and projections that return exactly the fields a page needs.
API CDN
1m requests/mo on Free and Growth
The same queries served from cache. Separate, larger quota than the uncached API, and the endpoint you should be hitting in production.
GraphQL API
One deployment per dataset
A generated, typed GraphQL schema per dataset. Deployed with a CLI command rather than being on by default.
Mutation API
Counts against the uncached API quota
Create, patch, delete and transactional document operations, used by Studio and by any import or migration script.
Asset pipeline
100GB assets on Free and Growth
Images and files with on-the-fly resizing, format negotiation, hotspot cropping and focal-point aware crops via URL parameters.
Remote MCP server
Vendor-operated, replaced the local server
Model Context Protocol access at mcp.sanity.io, so an AI client can read and write content directly without a bespoke integration.
Who Sanity is for
Teams with a developer who will own the content model, publishing more than a handful of pages, where editors and engineers both have to be happy with the result. It is the strongest option in this directory for a marketing site that needs to be fast, structured and genuinely pleasant to write in.
It is the wrong pick if nobody on the team writes code, if you need to run the content store on your own infrastructure, or if the site is small enough that a git-based editor over Markdown would do the same job for nothing.
Strengths and limits
What it does well
- Schema lives in your repository as TypeScript, so content-model changes go through code review and deploy with the app rather than being changed silently in a UI.
- GROQ returns exactly the shape a page needs from one request, including joins across references, which removes most of the over-fetching that makes REST-based CMS integrations slow.
- Real-time collaborative editing and a genuinely good image pipeline, both of which usually cost extra elsewhere.
- The free tier is unusually generous at 20 seats and 250,000 API requests a month, and it does not expire, so a proof of concept can run for months before anyone signs anything.
- Visual editing through the Presentation tool gives editors click-to-edit against a live preview without giving up a code-defined front end.
Where it falls short
- Per-seat billing at $15 a month means cost scales with the number of people who collaborate, which is the opposite of how most content teams want to grow. Twenty editors is $300 a month before any usage.
- Not self-hostable. Studio is MIT licensed and lives in your repo, but the Content Lake behind it is a hosted service with no on-premise option below an enterprise contract, so a lot of people who believe Sanity is open source are only half right.
- Portable Text is the right data structure and the wrong first impression. Editors coming from a WYSIWYG expect a document and get a block array, and that takes onboarding.
- GROQ is excellent and proprietary. Queries written against it do not port to another platform, so a migration away is a rewrite of the data layer rather than a swap of the endpoint.
- The document limit bites before the request limit on content-heavy sites: 10,000 on Free and 25,000 on Growth, with more sold as a $299 add-on rather than metered.
Sanity pricing
Three tiers. Free is $0 forever and carries 20 seats, 2 public datasets, 10,000 documents, 100GB of assets and bandwidth, 1,000,000 API CDN requests and 250,000 API requests a month. It cannot go over: there is no overage billing, requests simply stop.
Growth is $15 per seat per month up to 50 seats, and adds private datasets, 25,000 documents, five roles, comments and tasks, scheduled publishing and 90-day draft history. Usage above the included allowances is metered at $1 per 25,000 API requests, $1 per 250,000 API CDN requests, $0.50 per GB of assets and $0.30 per GB of bandwidth.
The add-ons are where the bill moves unexpectedly. More documents is $299 for 50,000 in total rather than a per-unit rate, an extra dataset is $999, dedicated support is $799 a month and a general quota increase is $299 a month. Enterprise is quote-only and is where SSO, custom roles and an SLA live.
The practical read: usage is cheap and seats are not. Model your cost on headcount, not traffic.
Free
$0
Forever, no card
- 20 seats, 2 roles
- 10k documents, 2 public datasets
- 250k API + 1m API CDN requests/mo
- 100GB assets and bandwidth
- 3-day draft history
- Overages blocked, never billed
Growth
$15 / seat / mo
Up to 50 seats
- 5 roles, private datasets
- 25k documents
- Comments, tasks, scheduled publishing
- 90-day draft history
- Metered overage on requests and bandwidth
- $299 add-on for 50k documents
Enterprise
Quote only
Annual contract
- Custom seats, roles and datasets
- SSO and custom credentials
- Support SLA
- Dedicated support from $799/mo
Query example
A minimal fetch against the live API, with credentials read from the environment rather than pasted inline.
import { createClient } from "@sanity/client"
const client = createClient({
projectId: process.env.SANITY_PROJECT_ID!,
dataset: "production",
apiVersion: "2026-08-01",
useCdn: true, // hits the API CDN quota, not the smaller uncached one
})
// GROQ projects the exact shape the page needs, and follows the
// author reference in the same request. No second call, no over-fetch.
const post = await client.fetch(
`*[_type == "post" && slug.current == $slug][0]{
title,
"slug": slug.current,
publishedAt,
"author": author->{name, "image": image.asset->url},
body
}`,
{ slug: "headless-cms-platforms" },
)Limits and quotas
- Free: 10,000 documents, 250,000 API requests and 1,000,000 API CDN requests per month, 100GB assets, 100GB bandwidth. Overages are not billed, they are blocked.
- Growth: 25,000 documents and the same request and bandwidth allowances, with overage at $1 per 25,000 API requests and $1 per 250,000 API CDN requests.
- Assets and bandwidth overage on Growth run $0.50 per GB and $0.30 per GB respectively.
- Two datasets on both Free and Growth. Additional datasets are a $999 add-on, which makes per-environment or per-brand separation an expensive habit.
- Draft history is 3 days on Free and 90 days on Growth.
- Free is capped at 2 roles (Administrator and Viewer). Growth adds Editor, Developer and Contributor for 5 total.
What developers say on Reddit
Developers recommend it freely and with one recurring correction attached. In r/nextjs and r/webdev threads asking which CMS to use, Sanity is named more often than anything except Payload and Strapi, usually alongside a note that the free tier is large enough to ship on and that editors take to the interface quickly.
The correction is about self-hosting. Because the Studio lives in your repository and deploys from your machine, people assume the whole thing is self-hosted. It is not, and the community corrects that misconception often enough that it is worth stating plainly before you commit.
“Yeah Sanity and Prismic aren't actually self-hosted, your content still lives on their servers. the whole "create a project locally and deploy" thing is just so your schema is code you can version in git instead of clicking it together in some dashboard. sanity will even host the studio UI for you if you run sanity deploy.”
r/webdev on Reddit“look at Contentful, Sanity, or Strapi Cloud. Contentful and Sanity have very polished UIs that editors pick up quickly, strong editorial workflows, and good Next.js support.”
r/nextjs on Reddit“If the client only needs to manage public content (products, text, images) and there's no authentication or private data involved, Sanity on the free tier is probably all you need. Choosing Headless WordPress here feels like adding complexity without solving any real problem.”
r/nextjs on Reddit“Sanity or Payload CMS are worth looking into, both give you full control over the structure while the client gets clean interface for editing content”
r/webdev on Reddit
Verdict
The best pick in this directory for a content-led site that has a developer attached, needs no infrastructure of its own, and expects to still be running in five years. The content model is the strongest here, the delivery layer imposes nothing on how you render, and the free tier is large enough to prove all of that before you spend anything.
Two things should send you elsewhere. If you need to own the infrastructure, Sanity is a hosted service and no amount of MIT-licensed Studio code changes that, so look at Payload or Strapi. If your team is large and mostly writers, per-seat pricing will make Storyblok or Contentful cheaper at the same headcount.
Worth being clear about the ordering here: Payload is our featured pick because it is what we run ourselves. Sanity is the platform we recommend to clients most often, because most of them do not want a database to look after. If that describes you, start here rather than with the badge.
Sanity FAQ
Is Sanity free?
There is a genuinely free tier, and it is one of the largest here: 20 seats, 10,000 documents, 250,000 API requests and 1,000,000 cached requests a month, forever, with no card. It cannot overspend, because overages are blocked rather than billed. Paid Growth starts at $15 per seat per month.Is Sanity open source?
Half of it. Sanity Studio, the editing interface, is MIT licensed and lives in your own repository. The Content Lake that stores and serves the content is a proprietary hosted service and cannot be self-hosted. If self-hosting is a requirement, that answer is a no rather than a partial yes.What is GROQ and do I need it?
GROQ is Sanity's query language. It lets one request return exactly the shape a page needs, including data followed across references, which is why Sanity-backed pages tend to make one API call instead of four. You can use the generated GraphQL API instead, but you give up the projections that make GROQ worth learning. Budget an afternoon.How much does Sanity cost for a team of ten?
Ten seats on Growth is $150 a month before usage, and usage is unlikely to add anything for a normal marketing site inside the included 250,000 API requests and 100GB of bandwidth. The costs that surprise people are the $999 additional dataset and the $299 document add-on, not the request meter.Sanity or Contentful?
Sanity if developers own the content model and you want it version-controlled. Contentful if content operations, governance and a large non-technical team matter more, or if per-seat billing does not suit your headcount. Contentful's paid entry point is $300 a month against Sanity's $15 a seat, so the crossover is around twenty people.Does Sanity work with Next.js?
It is the pairing the platform is effectively designed around. The client is framework agnostic, but the Next.js toolkit covers draft mode, tag-based revalidation and the Presentation tool for click-to-edit visual editing against a live preview. Nothing about Sanity constrains how you render, so static, streamed and dynamic all stay available.Can I migrate off Sanity later?
Content exports cleanly as NDJSON including assets, so the data is portable. The work is everything around it: GROQ queries, Portable Text serialisers and the Studio itself do not transfer, so plan a rewrite of the data layer rather than a swap of the endpoint.
This is an independent review. We have no affiliate relationship with Sanity, earn nothing if you sign up, and no vendor pays for placement in the directory. Prices were read from the vendor's own pages in August 2026 and change without notice.