Sanity
Sanity - Content Operating System
Sanity
Sanity raised $85M Series C May 2025 (total $173M, 284 employees) and relaunched as a Content Operating System. Spring 2025 added Canvas (AI-assisted writing), unified Dashboard, and Media Library. 17%+ headless CMS market share — customers include PUMA, Skims, AT&T, Eurostar, and Morning Brew. GROQ query language fetches precisely what you need without over-fetching. Sanity Studio is fully customizable React — developers own the editing UI, not a locked admin. For teams needing CMS infrastructure with complete editorial experience control, Sanity is the definitive choice.
Build with SanityCMS
Who Should Use Sanity?
Sanity is the headless CMS for teams where developer control over editorial experience is as important as the content delivery API. It rewards teams that invest in customizing the Studio to match their editorial workflow — and delivers outsized productivity when they do. Here's the profile of organizations where Sanity's architecture creates real competitive advantage.
Developer Teams Wanting Editorial UI Control
Teams where the standard field-and-form CMS admin doesn't match the editorial workflow use Sanity Studio's customizability to build exactly what editors need. Custom desk structure, custom field components, custom document actions — the Studio is a React app you own. We've built Sanity Studios where the editing experience was designed specifically for the publication's workflow, not a generic CMS admin.
Content-Rich Digital Products
Digital products where content is a first-class feature — editorial sites, media platforms, content-driven marketplaces, knowledge bases — benefit from Sanity's flexible schema and GROQ's precise content retrieval. We've built Sanity-backed digital products where GROQ queries for complex content relationships replaced multiple API calls with one.
Real-Time Collaborative Publishing Teams
Editorial teams of 5-50+ editors working simultaneously on time-sensitive content — news, e-commerce product catalog, live event coverage — benefit from Sanity's real-time Content Lake. Multiple editors see each other's cursors and changes live, preventing the save-conflict problem that plagues traditional CMS platforms.
AI-Augmented Content Production
Teams adopting AI writing assistance in their editorial workflow use Canvas — Sanity's Spring 2025 addition — for AI-assisted content creation that respects the content model and brand voice. Canvas integrates with the Content Lake, meaning AI-generated content is immediately structured and queryable, not just text in a WYSIWYG editor.
Next.js and Vercel Stack Teams
The Sanity + Next.js + Vercel stack is one of the most commonly deployed headless CMS architectures. Sanity's Next.js integration with Live Preview, ISR revalidation, and Visual Editing (click on a live page element to open it in Studio) is first-class. We've built dozens of Sanity + Next.js production sites where editorial teams loved the Live Preview experience.
Agencies with Multiple Client Projects
Agencies managing Sanity projects for multiple clients benefit from Sanity's organization-level management, project templates, and the ability to share schema code across projects via npm packages. We've built agency Sanity starter kits that give new client projects a consistent foundation and reduce setup time from days to hours.
When Sanity Might Not Be the Best Choice
We believe in honest communication. Here are scenarios where alternative solutions might be more appropriate:
Teams needing enterprise governance features out of the box — Contentful's workflow, approval, and compliance features are more mature
Non-technical teams who need to self-serve CMS setup without developer involvement — Sanity Studio requires code configuration
Organizations with strict data residency requirements in regions Sanity's Content Lake doesn't serve
Simple website projects where WordPress or Wix is cost-effective and appropriate
Still Not Sure?
We're here to help you find the right solution. Let's have an honest conversation about your specific needs and determine if Sanity is the right fit for your business.
Why Choose Sanity for Your Headless CMS?
Sanity's differentiator is editorial UI ownership. Sanity Studio is React code you control — field types, validation logic, custom input components, and desk structure are all code, not config checkboxes. When your editorial team has unusual content workflows, Sanity accommodates them without workarounds. GROQ outperforms GraphQL for complex relational content queries — no N+1 problems, precise result shaping. Canvas's AI writing environment makes Sanity the first CMS where AI assistance is native, not bolted on. The $85M Series C validates the Content Operating System positioning.
$85M
Series C Funding (May 2025)
Sanity, May 2025$173M
Total Funding Raised
Sanity, 202517%+
Headless CMS Market Share
Market analysis, 2025284
Employees (March 2026)
Sanity company dataSanity Studio is fully customizable React — custom field types, custom input components, custom desk structure, and custom workflows are all code you control, not configuration options in a locked admin
$85M Series C funding (May 2025), total $173M raised — Sanity is well-capitalized for its Content Operating System roadmap including AI writing, media management, and collaboration tools
17%+ headless CMS market share with customers including PUMA, Skims (Kim Kardashian), AT&T, Eurostar, Morning Brew, RBI, and Complex Networks — cross-industry validation
GROQ (Graph-Relational Object Queries) is Sanity's purpose-built query language — fetches nested relational content in a single query without over-fetching or multiple API calls
Content Lake stores structured content in a real-time database where multiple editors see each other's changes instantly — real-time collaboration across the entire editorial team
Canvas (Spring 2025) is an AI-assisted free-form writing environment where Sanity AI suggests, rewrites, and generates content within the editorial workflow — not a separate tool
Portable Text (Sanity's rich text format) is a JSON-serialized content structure that any frontend can render — not tied to HTML, enabling true multi-channel content delivery
Generous free tier: 1 project, 2 users, 10K API CDN requests/day, unlimited viewer users — production-viable for small teams without any platform cost
Sanity in Practice
Editorial and Media Platforms
News sites, magazines, and content brands with high editorial velocity — multiple articles per day, multiple authors, real-time publish requirements. Sanity's live collaboration, custom desk structure for editorial workflow (drafts → review → published), and GROQ-driven Next.js fetching. We've built Sanity media platforms where editors work simultaneously without save conflicts and content appears on-site within seconds of publishing.
Example: News platform with Sanity Studio custom desk, live collaboration, GROQ queries, and Next.js ISR
E-commerce Product Content Management
Product descriptions, buying guides, brand stories, and size guides for e-commerce backends where content quality drives conversion. Sanity's structured Portable Text enables rich product descriptions that render consistently across web, mobile app, and email. Custom validation ensures content completeness before publish. We've built Sanity product content systems for fashion and beauty brands with complex editorial standards.
Example: Product content CMS with Sanity, custom validation, Portable Text rich descriptions, and multi-channel delivery
Design-to-Content Production Pipeline
Digital agencies building client sites use Sanity as the handoff layer between design and editorial — developers define the schema, editors populate content during development, and content is ready when the site launches. Sanity's Visual Editing (click page element → open in Studio) closes the designer-editor gap. We've used this workflow on agency projects that cut content launch delays from weeks to days.
Example: Agency site with Sanity structured content, Visual Editing preview, and client-ready editing experience
Knowledge Base and Documentation Sites
Technical documentation, support knowledge bases, and internal wikis with structured content hierarchies — categories, subcategories, articles, code examples — modeled in Sanity's schema. GROQ enables complex content queries for related articles, search indexing via Algolia sync, and multi-version documentation. We've built Sanity knowledge bases for SaaS products with structured article formats and versioned documentation.
Example: Documentation site with Sanity hierarchical schema, Algolia search sync, GROQ queries, and Next.js rendering
Multi-Brand Content Management
Organizations managing content for multiple brands or regions from a single Sanity project using Datasets (separate content stores per brand) or structured workspace organization. Shared content types via npm packages, brand-specific field customization, and workspace-level permission controls. We've built multi-brand Sanity setups for holding companies managing 5-10 brand digital presences centrally.
Example: Multi-brand platform with Sanity workspaces, shared schema npm packages, and brand-specific Studio configuration
AI-Augmented Editorial Workflow
Teams integrating AI into content production use Sanity Canvas for AI-assisted drafting within the content model. AI generates structured content fields (title suggestions, meta descriptions, article summaries, alt text) while editors control the final output. Content remains structured and queryable — not just AI text dumped into a rich text editor. We've implemented Sanity AI editorial workflows that reduced first-draft time for structured content.
Example: AI editorial workflow with Sanity Canvas, structured field generation, editor review, and publish approval
Sanity Pros and Cons
Every technology has its strengths and limitations. Here's an honest assessment to help you make an informed decision.
Advantages
Sanity Studio — Fully Customizable React Editor
Sanity Studio is a React application you configure and extend with code. Custom field types (color picker, date range, image hotspot), custom desk structures (editorial workflow organizing documents by state), custom document actions (publish to social, generate PDF), and custom input components — all JavaScript/TypeScript you control. No other headless CMS gives this level of editorial UI ownership.
GROQ Query Language Precision
GROQ is Sanity's purpose-built content query language. A single GROQ query fetches a document with all its references resolved, in any nesting depth, returning exactly the fields you specify. No N+1 API calls, no over-fetching unnecessary fields, no under-fetching that forces a second request. Compared to REST pagination and even GraphQL's query complexity, GROQ queries for complex content are cleaner and more efficient.
Real-Time Content Lake Collaboration
Sanity's Content Lake stores documents in a real-time database with operational transforms — the same technology behind Google Docs collaboration. Multiple editors see each other's changes live, with cursor positions and active users visible. For time-sensitive editorial teams, the elimination of save conflicts and the ability to collaborate in real time are genuine productivity multipliers.
Canvas AI Writing Environment
Canvas (Spring 2025) brings AI writing assistance into the Sanity editorial workflow — not as a plugin or external tool, but as a native writing environment where AI suggestions are aware of the content model's structure and field requirements. For organizations adopting AI-augmented content production, Sanity's native AI integration is significantly more coherent than bolt-on alternatives.
Well-Funded and Focused
$173M total raised, $85M Series C led by Bullhound Capital in May 2025. Sanity is 'fully capitalized for its growth journey' per the announcement. 284 employees with focused product investment. Unlike some headless CMS vendors acquired by larger platforms, Sanity is independent and singularly focused on content infrastructure for developers.
Generous Free Tier for Evaluation and Small Projects
Sanity's free tier provides 1 project, 2 users, 10K API CDN requests/day, and unlimited viewer access. Many production small-team projects operate on the free tier indefinitely. Growth plan unlocks more users and requests. This pricing model lets teams evaluate Sanity in production without a time limit or credit card — genuinely reducing evaluation friction.
Limitations
Studio Requires Developer Setup
Sanity Studio is code — you define schemas in JavaScript/TypeScript before any content can be entered. Unlike Contentful or Storyblok where you configure content types via a UI, Sanity schemas require a developer. Non-technical teams cannot self-serve a new Sanity project without developer involvement for initial setup.
We provide Sanity project starter kits with common schema patterns pre-configured. For client projects, we set up the Studio, train editors on the resulting interface, and document the schema so clients can request changes. Once the Studio is configured, editors work independently without developer involvement for routine content operations.
GROQ Learning Curve
GROQ is a purpose-built query language that doesn't map to GraphQL or SQL knowledge. Developers familiar with GraphQL or REST need to learn GROQ's syntax, filtering, projection, and joining semantics. The learning curve is typically a few hours to a few days depending on query complexity.
GROQ's documentation is excellent and Sanity provides a GROQ playground for query testing. We maintain a library of common GROQ patterns — pagination, reference resolution, conditional fields — that we apply across projects. Once learned, GROQ's expressiveness for content queries is genuinely superior to GraphQL for typical CMS use cases.
Enterprise Governance Features Less Mature
Contentful's approval workflows, scheduled publishing via Launch, and enterprise SSO/SAML are more mature than Sanity's equivalents. For organizations requiring strict editorial governance with multi-level approval, Sanity requires custom Studio development to implement equivalent workflows.
We implement custom document actions and workflow states in Sanity Studio for approval-based publishing. Custom desk structure organizes documents by workflow state (draft, in-review, approved, published). For enterprise SAML requirements, Sanity's Enterprise plan includes SSO. We scope the governance implementation during discovery to avoid surprises.
Content Lake Data Residency
Sanity's Content Lake hosts data in the US by default. EU data residency is available but requires explicit configuration and enterprise plan. Organizations with strict data residency requirements in specific regions need to verify Sanity's available regions before committing.
We verify data residency requirements during discovery and configure EU hosting for European clients who need it. For organizations with strict data sovereignty requirements not served by Sanity's regions, we recommend self-hosted Strapi where the database runs in any infrastructure.
Sanity Alternatives & Comparisons
We use all of these in production — the right choice depends on your project's constraints, team familiarity, and scale requirements.
Sanity vs Contentful
Learn More About ContentfulContentful Advantages
- •30%+ Fortune 500 adoption — enterprise procurement pre-approved
- •More mature editorial governance — approval workflows, scheduling, audit trail
- •SOC 2/ISO 27001/HIPAA compliance out of the box without custom implementation
- •Contentful Compose visual page building for marketing teams
Contentful Limitations
- •Locked admin UI — content types configured via UI, not code
- •GraphQL and REST only — no GROQ for complex relational content queries
- •Higher pricing — Team plan $300+/month vs Sanity's free tier
- •Less developer-customizable editing experience
Contentful is Best For:
- •Enterprise organizations where procurement requirements and compliance certifications are primary
- •Marketing-led teams needing visual page building with minimal developer involvement
When to Choose Contentful
Contentful for Fortune 500 procurement requirements, multi-level editorial governance, and compliance certifications. Sanity for developer-controlled editorial experience, GROQ querying, and real-time collaborative publishing.
Sanity vs Strapi
Learn More About StrapiStrapi Advantages
- •Self-hosted — full data ownership, no per-month platform cost
- •Free open-source core — no licensing cost for self-hosted deployment
- •REST and GraphQL APIs out of the box with plugin extensibility
Strapi Limitations
- •Infrastructure responsibility — hosting, updates, backups, scaling
- •Less real-time collaboration than Sanity's Content Lake
- •Less customizable editing experience than Sanity Studio
Strapi is Best For:
- •Teams with data sovereignty requirements or open-source mandates
- •Projects where zero platform cost at any scale is the primary requirement
When to Choose Strapi
Strapi for self-hosted data ownership and open-source requirements. Sanity for managed infrastructure with maximum editorial UI customization and real-time collaboration.
Sanity vs Storyblok
Learn More About StoryblokStoryblok Advantages
- •Visual editor with real-time in-context preview — the best editor experience in headless CMS
- •Component-based content architecture maps naturally to React component systems
- •IDC MarketScape Leader for AI-Enabled Headless CMS 2025
Storyblok Limitations
- •Less developer control over editing UI than Sanity Studio
- •Component-centric model requires upfront component design discipline
- •GROQ equivalent not available — uses its own API
Storyblok is Best For:
- •Teams where editor experience drives CMS selection over developer flexibility
- •Marketing-led organizations where visual content composition is the primary workflow
When to Choose Storyblok
Storyblok when visual editor experience and component-based content composition are the primary selection criteria. Sanity when developer control over the editorial UI, GROQ querying, and real-time collaboration are the priorities.
Why Choose Code24x7 for Sanity Development?
Sanity development at Code24x7 means building editorial experiences that teams actually use — not defaulting to generic field forms that frustrate non-technical editors. We design Sanity Studio schemas and desk structures to match editorial workflows specifically, then write the React Studio code that realizes them. We write GROQ queries that fetch exactly what the frontend needs in one call. We integrate Sanity with Next.js using Visual Editing, ISR revalidation, and Live Preview so editors see real-time changes without separate preview builds. We've deployed Sanity for media platforms, e-commerce brands, and agency client sites — and our approach starts with understanding how the editorial team actually works.
Sanity Studio Schema Design
We design Sanity schemas in TypeScript with purpose-built field types, custom validation rules, and document-level business logic. Desk structure organizes the Studio to match the editorial workflow — not alphabetically by document type. We document schemas for client teams and use npm packages to share common schema patterns across projects.
Custom Studio Components
Custom Sanity Studio input components for specialized editorial needs: color palette selectors, drag-and-drop ordering interfaces, embedded preview components, custom rich text annotations, and live API data lookups within field inputs. Built in React with Sanity's UI component library for consistent Studio aesthetics.
GROQ Query Development
We write optimized GROQ queries for complex content structures: deeply nested references with selective field projection, conditional content based on document type, filtered collections with pagination, and full-text search with relevance scoring. Queries are typed with Sanity's TypeScript generation and tested against real content.
Next.js + Sanity Integration
Sanity + Next.js implementations with Visual Editing (click-to-edit in the live preview), Live Preview for draft content, ISR webhook revalidation for targeted cache purging, and Sanity's CDN for optimized content delivery. We configure the full editorial preview workflow so editors never leave Sanity Studio to see their changes.
Sanity Canvas AI Integration
We implement Sanity Canvas for AI-augmented editorial workflows — configuring AI assistance for structured field generation (meta descriptions, article summaries, alt text), Canvas writing environment for long-form content, and custom AI actions within the Studio. AI assistance integrated into content workflows, not bolted on externally.
Content Migration to Sanity
Migration from WordPress, Contentful, Prismic, and legacy CMS platforms to Sanity — schema design mapping, content transformation scripts using the Sanity client CLI, asset migration with Sanity's media pipeline, and reference reconstruction for relational content. We've migrated large content libraries to Sanity without editorial workflow disruption.
Services That Use This Technology
Questions from Developers and Teams
Sanity rebranded from 'headless CMS' to 'Content Operating System' in May 2025 alongside the Spring Release. The distinction: a traditional CMS stores and delivers content; a Content Operating System is the coordinating layer for all content operations — creation (Canvas AI writing), organization (Media Library, unified Dashboard), delivery (Content Lake API), and collaboration (real-time editing). The rebranding reflects Sanity's expansion beyond storage-and-delivery into the full content production workflow.
GROQ (Graph-Relational Object Queries) is Sanity's purpose-built content query language. Key differences from GraphQL: GROQ resolves document references in a single query (no N+1 problem), uses a more compact syntax for projection (selecting specific fields), supports conditional content based on document type within one query, and enables full-text search with filtering. For typical CMS content queries involving nested references and conditional content, GROQ queries are often shorter and more readable than equivalent GraphQL. Both return JSON — the difference is query expressiveness.
Sanity Studio is a React application — fully customizable at every level. You can define custom field types, custom input components (a color picker, an address lookup, an embedded image cropper), custom desk structure (organizing documents by workflow state, publication, or any business logic), custom document actions (Publish to Social, Generate PDF, Send for Review), and custom document badges. The Studio is your code, versioned in Git, deployed to your preferred hosting. No other headless CMS offers this level of editorial UI control.
Portable Text is Sanity's rich text format — JSON-structured content that represents formatted text, embedded images, and custom blocks. Unlike HTML (which is presentation-dependent), Portable Text is a neutral format that any frontend can render. A React frontend renders Portable Text as JSX; a mobile app renders it as native text views; an email template renders it as inline HTML. This makes rich text truly multi-channel — the same editorial content renders correctly on every surface without format conversion.
Development cost depends on schema complexity, Studio customization depth, GROQ query complexity, frontend integration (Next.js/other), and whether migrations from existing CMS platforms are needed. Sanity's platform pricing starts with a free tier (1 project, 2 users) and scales with usage. Share your requirements and we'll provide a project-specific breakdown.
We use Sanity's official Next.js integration with: Visual Editing (editors click live page elements to open them in Studio), Live Preview in Draft mode (real-time content updates in the browser without publishing), ISR revalidation via Sanity webhooks (targeted page cache purging when content changes), and the GROQ-powered client for typed content queries. The editorial experience this enables — where editors see live changes on the actual page — dramatically reduces the publish-preview-adjust cycle.
Canvas is Sanity's AI-assisted writing environment, launched in Spring 2025. It's a free-form writing space where AI assistance is available throughout the composition process — suggesting continuations, rewriting sections, generating structured field content (meta descriptions, summaries), and translating content. Unlike external AI writing tools, Canvas is integrated with Sanity's content model — AI-generated content is immediately structured, stored in the Content Lake, and queryable via GROQ.
Yes — this is one of Sanity's core architectural advantages. Sanity's Content Lake uses operational transforms (the same technology as Google Docs) to enable real-time collaborative editing. Multiple editors see each other's changes live, with cursor positions and active user indicators visible within documents. Save conflicts — the bane of traditional CMS platforms — are structurally eliminated. For editorial teams publishing time-sensitive content, real-time collaboration is a significant operational advantage.
Sanity has a generous free tier: 1 project, 2 users with editor permissions, unlimited viewer users, 10,000 API CDN requests per day, 100GB asset storage, and 500K API requests per month. Many production small-team sites run on the free tier. The Growth plan ($15/user/month) unlocks additional users, more API requests, and advanced features. Enterprise plans include SSO, SLA, and dedicated support.
Our Sanity support packages cover schema evolution (new document types, field additions, schema migration scripts), Studio component updates, GROQ query optimization, Next.js integration updates as Sanity releases new versions, Canvas AI workflow configuration, and editorial team training for new Studio features. We also provide content migration support when client content architectures need restructuring.
Still have questions?
Contact Us
What Makes Code24x7 Different
What distinguishes our Sanity work is the attention we give to the editorial experience — the part clients use every day. We don't configure a generic desk with 15 document types in alphabetical order. We design a Studio that matches how editorial teams actually organize their work: by workflow state, by content category, by publication date. We write GROQ queries that return exactly what the frontend needs — not a superset that wastes bandwidth and processing. We implement Visual Editing so clients point at a live page element and edit it. When we finish a Sanity project, editors tell us it's the best CMS they've ever used — that's the outcome we design for.