StacksFree Verdict: 8/10. If you want to know how to get started with Sanity for beginners, the short answer is this: create a free account at sanity.io, scaffold Sanity Studio with one npm command, and start publishing documents — setup guides report no credit card is requested for the Free plan, and Sanity’s pricing page lists it at $0 forever. Sanity earns its 8/10 by being generous where indie hackers feel it: 10,000 documents, free Studio hosting, and real-time collaborative editing at $0 forever. The missing two points come from its most important free-tier rule: the Free plan allows no overages, so when a quota hits 100%, requests fail with HTTP 402 until you delete data or upgrade, per Sanity’s plans and payments documentation [2] — and datasets are public-only on Free.
How This Guide Was Built
This guide was built from the official Sanity pricing page [1] and Sanity’s plans and payments documentation [2], so every limit quoted below traces back to a primary source. We verified the Free-plan quotas, the signup and CLI setup flow, hard-cap behavior at 100% usage, and the Free vs Growth plan comparison.
We did not run Sanity hands-on — this review is based on official documentation, pricing pages, and community reports. Live API latency and long-session editor experience were therefore not evaluated; treat quotas as accurate as of the verification date. Last verified: September 2026.
What is Sanity?
Sanity is a hosted, cloud-based content platform that pairs a real-time content datastore (the Content Lake) with Sanity Studio, a customizable editing workspace, according to Sanity’s documentation. It is not open-source and not self-hosted: your content lives in Sanity’s cloud, and you query it as data from any frontend.
For indie hackers, “headless” means your content and your code stay separate. You edit posts in Studio, and your Next.js or Astro site fetches them as JSON using GROQ or GraphQL — both querying options are included on Free, along with real-time data access. There is no database server to babysit; you spend your time on the frontend, not on ops.
How do I get started with Sanity?
You get started with Sanity by creating a free account at sanity.io, then running the official CLI scaffolding command to create a Studio project locally. Sanity’s pages don’t list a credit-card requirement for the Free plan, and third-party setup guides report none is requested, per the Next.js quickstart. The flow leaves you with a local Studio connected to a cloud dataset.
-
Create a free account at sanity.io. Sign up with Google, GitHub, or email — setup guides report no credit card is requested for the Free plan. Why: your account owns the project and datasets that both Studio and your frontend will talk to.
-
Scaffold a Studio wired to a dataset by running:
npm create sanity@latest -- --dataset production --template clean --typescript --output-path studio-hello-world cd studio-hello-worldWhy: this command creates Sanity Studio — the editing app — configured against a
productiondataset in your project, exactly as the quickstart describes. -
Run the Studio locally with
npm run devinsidestudio-hello-world, then open http://localhost:3333 and log in with the same Google/GitHub/email account you used in the CLI. Why: Studio runs on your machine, but reads and writes straight to your cloud-hosted Content Lake; the shared login is what pairs the two. -
Define a schema and publish your first document. Add a document type (copy-paste code in the next section), reload the Studio, fill in a post, and publish. Why: schemas define what content can exist; publishing writes your first real document into the dataset.
Sanity Free Tier Breakdown (2026)
The Sanity Free plan costs $0 forever and includes up to 20 user seats, two public datasets, 10,000 documents, one million API CDN requests per month, and 100GB of assets, according to the official Sanity pricing page [1]. Usage is hard-capped: the Free plan allows no overages, per Sanity’s plans and payments docs [2].
| Resource | Free plan limit |
|---|---|
| Price | $0 forever |
| User seats | Up to 20 |
| Roles | Administrator + Viewer only |
| Datasets | 2, public only |
| Documents | 10,000 |
| Unique attributes | 2,000 per dataset |
| GROQ-powered webhooks | 2 |
| API CDN requests | 1,000,000 per month |
| API requests | 250,000 per month |
| Assets | 100GB |
| Bandwidth | 100GB per month |
| Live connections | 1,000 per dataset |
| Live retention | 15 minutes |
Also included on Free: Sanity Studio with free hosting; Live Preview, Visual Editing, the Presentation tool, real-time editing, and multiplayer presence; unlimited content types and locales; and GraphQL plus GROQ querying. Not included: Comments, Tasks, Scheduled drafts, and Content releases, and Review Changes drafts are kept only 3 days.
Hard-cap rules to memorize:
- Free allows no overages — resource usage is hard-capped.
- At 100% of the Documents, Assets, API, API CDN, or Bandwidth quota, functionality is blocked and API/CDN requests fail with HTTP 402 and a
{"error":"plan_limit_reached"}body. The Studio stays usable. - Email alerts fire at 80% (warning) and 100% (blocked).
- API, CDN, and bandwidth usage accumulate monthly and reset each month; unused quota cannot roll over.
- Hit the document quota and you cannot create new documents — including drafts. Delete documents or datasets, or upgrade.
- Hit the asset quota and uploads stop, but existing assets keep serving.
Building Your First Content Model
Your first content model in Sanity is a schema type — for example a post document with title, slug, and body fields — defined with defineType and registered in the Studio’s schema, following Sanity’s schema type conventions. You fill it in through the Studio, then read it back with a GROQ query through the JavaScript client.
// schemaTypes/post.ts
import {defineField, defineType} from 'sanity'
export const postType = defineType({
name: 'post',
type: 'document',
title: 'Post',
fields: [
defineField({name: 'title', type: 'string'}),
defineField({name: 'slug', type: 'slug', options: {source: 'title'}}),
defineField({name: 'body', type: 'array', of: [{type: 'block'}]}),
],
})Save the file, add postType to the types array in schemaTypes/index.ts, and the Studio picks up the change — you’ll see a Post editor where you can fill in a title, generate a slug, and publish. Then fetch it from your frontend:
import {createClient} from '@sanity/client'
const client = createClient({
projectId: 'your-project-id', // from sanity.io/manage or the CLI output
dataset: 'production',
apiVersion: '2025-01-01',
useCdn: true,
})
export async function getPosts() {
return client.fetch('*[_type == "post"]')
}useCdn: true serves public content from Sanity’s API CDN at <project>.apicdn.sanity.io instead of the regular API at <project>.api.sanity.io, drawing on the far larger 1M/month CDN quota rather than the 250k/month API quota — see the API CDN docs, the JS client docs, and the GROQ documentation for the query language. When this query powers a deployed frontend, our Vercel free tier guide keeps the hosting side at $0.
Sanity Free Tier vs Growth
Sanity’s Growth plan costs $15 per seat/month and adds private datasets, Editor/Developer/Contributor roles, 50 seats, 25,000 documents, four webhooks, and overage billing instead of hard caps, according to Sanity’s pricing page [1]. Upgrade when you need dataset privacy, granular editor roles, more than 10,000 documents, or pay-as-you-go headroom rather than a hard stop.
| Free | Growth | |
|---|---|---|
| Price | $0 forever | $15 per seat/month |
| Seats | 20 | 50 |
| Roles | Administrator + Viewer | Adds Editor, Developer, Contributor |
| Datasets | 2, public only | Private or public (extra dataset $999/month) |
| Documents | 10,000 | 25,000 ($299/month add-on raises to 50,000 total, plus 5M CDN / 1M API / 500GB bandwidth / 500GB assets) |
| Webhooks | 2 | 4 |
| Quota overruns | Hard-capped, no overages | Billed: $1 per extra 250k CDN requests, $1 per extra 25k API requests, $0.50 per extra 1GB assets, $0.30 per extra 1GB bandwidth |
When must an indie project actually upgrade? Three moments: when a dataset must be private (client work or embargoed content — Free is public-only), when collaborators need to edit rather than just view (Free ships no Editor role), and when a 10,000-document cap or a hard HTTP 402 starts blocking shipping and you’d rather pay overages than delete content. Worth knowing before you upgrade for a client project: downgrading Growth back to Free makes private datasets public, turns non-admin members into viewers, and stops overage billing.
Common Mistakes to Avoid
The most common Sanity Free-plan mistake is ignoring hard caps: with no overages allowed, requests fail with HTTP 402 and a {"error":"plan_limit_reached"} body once any quota hits 100%, per Sanity’s plans and payments docs [2]. The mistakes below all trace back to that behavior, or to quotas that count more than beginners expect.
- Ignoring hard caps until HTTP 402. Your site’s data calls can break in production while the Studio keeps working, so a dead frontend may be your first signal that a quota is spent.
- Forgetting drafts count toward the document quota. At 10,000 documents you cannot create anything new — drafts included. The fix is deleting documents or datasets, or upgrading.
- Assuming datasets can be private on Free. Both Free datasets are public-only; privacy requires the Growth plan.
- Missing the 80% and 100% usage emails. Alerts at 80% (warning) and 100% (blocked) are your early-warning system; treat the 80% email as the cue to prune content or optimize queries.
- Treating the CDN and API quotas as interchangeable. You get 1M API CDN requests but only 250k API requests per month; set
useCdn: truefor public reads so traffic hits<project>.apicdn.sanity.ioinstead of the regular API. - Expecting Growth-grade workflow features. Comments, Tasks, Scheduled drafts, and Content releases are not on Free, and Review Changes drafts are kept only 3 days.
FAQ
This FAQ answers the questions beginners type most often about Sanity’s free tier. Each answer is self-contained and sourced to Sanity’s official pricing page and documentation, so it stands alone without context from the verdict or sections above.
Is Sanity free for beginners?
Yes, Sanity is free for beginners: the Free plan costs $0 forever and includes 10,000 documents, two public datasets, a million API CDN requests per month, and free Studio hosting, according to Sanity’s pricing page [1]. Sanity’s signup does not list a credit-card requirement — third-party guides report none needed — and you only pay if you choose the Growth plan.
Is Sanity better than a traditional CMS like WordPress?
Whether Sanity is better than a traditional CMS like WordPress depends on your stack: Sanity is a hosted headless CMS where you edit in Sanity Studio and query content as data from your own frontend, while WordPress bundles database, admin, and themes into one self-hosted application. Pick Sanity for a JavaScript frontend you control; pick WordPress for turnkey plugins.
Do I need a credit card to use Sanity?
No, you do not need to provide a credit card to use Sanity’s Free plan as far as Sanity’s official pages disclose: signup at sanity.io takes a Google, GitHub, or email account and the plan is $0 forever, per Sanity’s pricing page [1]. Third-party setup guides report no card is requested. A payment method only becomes relevant if you upgrade to the Growth plan at $15 per seat/month.
Where to go next
The fastest next step after setting up Sanity is deploying a frontend that reads your content: Sanity’s Next.js quickstart covers displaying content in Next.js and Astro plus deploying the Studio, and StacksFree’s hosting guides cover putting that frontend on a free plan.
- Render your
postdocuments in a real frontend by following Sanity’s Next.js quickstart end to end. - Deploy that frontend with our Vercel free tier guide, which covers limits and deploy gotchas.
- Prefer a second option? Our Cloudflare Pages free tier guide covers static hosting for both the frontend and the Studio.
- Watch for the 80% usage email, and keep
useCdn: trueon public reads so your million-request CDN quota does the heavy lifting.
Sources
[1] Sanity Pricing — https://www.sanity.io/pricing [2] Sanity Plans and Payments Documentation — https://www.sanity.io/docs/platform-management/plans-and-payments