Headless CMS in Hungary: Sanity vs Strapi vs Contentful in 2026

A headless CMS is no longer an alternative — it's the default choice for a modern stack. WordPress hasn't gone anywhere either — it's still a solid fit for plenty of use cases. But if you're running a Next.js, Nuxt or SvelteKit frontend, the backend CMS question tends to circle around three names: Sanity, Strapi and Contentful. Plus the "markdown files in git" approach, which is often underrated.

This article is a deep dive into all three platforms — pricing, real-time preview capabilities, GDPR considerations, and five recommendations for Hungarian-market use cases. It reflects the state of play as of Q1 2026.

Headless CMS in 2026 — what you need to know

"Headless" means the CMS focuses purely on content storage and the content-management UI — there's no presentation layer built in. A separate frontend technology (Next.js, Nuxt, SvelteKit, a mobile app) fetches the data over a REST or GraphQL API.

The 2026 market

Three major players (Sanity, Strapi, Contentful) plus a range of niche solutions (Storyblok, Hygraph, Payload, Directus). And then there's the markdown-in-git approach (as used on Corevanix's own blog).

What changed between 2024 and 2026?

1. Real-time collaboration is now standard. Both Sanity and Strapi V5 support live multi-editor editing, similar to Figma.
2. Visual editing. The Sanity Visual Editing API, Storyblok Live Preview — the marketing team edits directly on a live frontend preview.
3. AI integration. Built-in AI assistance for content drafting (Sanity AI Assist, Contentful Plus).
4. A self-hosting trend. GDPR concerns are driving more adoption of Strapi and Directus.
5. Rising prices. Contentful significantly raised its Lite tier pricing in 2024 — many customers moved to Sanity as a result.

Sanity — the developer favourite

Sanity launched in 2017 and has since become one of developers' favourite platforms. Schema-as-code, real-time editing, a fully custom Studio UI.

Architecture

Sanity consists of two main components:

• Content Lake — Sanity's managed cloud storage. Globally replicated, with EU-region storage available as an opt-in.
• Sanity Studio — the content-management UI. It's a React app that you host yourself (on Vercel, Netlify, or your own infrastructure). The Studio is fully customisable.

The schema is declared in TypeScript or JavaScript and can be committed to git.

// schemas/post.ts
import { defineType, defineField } from 'sanity';

export const postType = defineType({
  name: 'post',
  title: 'Blog Post',
  type: 'document',
  fields: [
    defineField({
      name: 'title',
      title: 'Title',
      type: 'string',
      validation: (Rule) => Rule.required().max(120),
    }),
    defineField({
      name: 'slug',
      type: 'slug',
      options: { source: 'title' },
    }),
    defineField({
      name: 'body',
      type: 'array',
      of: [{ type: 'block' }, { type: 'image' }, { type: 'code' }],
    }),
    defineField({
      name: 'publishedAt',
      type: 'datetime',
    }),
  ],
});

Strengths

• A fully customisable Studio (Sanity Studio is itself a React app)
• The GROQ query language — flexible, efficient, and faster than GraphQL for complex queries
• Real-time collaboration (multiple users can edit simultaneously, similar to Figma)
• A generous free tier (3 users, 10k documents, 100k API requests/month)
• Image API (resize, crop, and format on the fly — on Sanity's own CDN, no separate image service needed)
• Visual Editing — on Vercel, content can be edited live directly on the Next.js app's pages
• Schema-as-code — the content model can be version-controlled in git

Weaknesses

• Sanity Studio needs to be self-hosted (or run on Sanity's cloud, which is paid)
• Pricing scales with content volume and bandwidth
• A GROQ learning curve — it's different from both SQL and GraphQL
• Vendor lock-in: the Content Lake lives on Sanity's cloud (data export exists, but migration is complex)

A GROQ example

// All posts published in the last 30 days, with author info
*[_type == "post" && publishedAt > dateTime(now()) - 60*60*24*30]
  | order(publishedAt desc)
  | [0..9]
{
  _id,
  title,
  slug,
  "authorName": author->name,
  "imageUrl": mainImage.asset->url,
  "readingTime": pt::text(body)
}

GROQ does exactly this in a single query — the SQL equivalent would need 3-4 JOINs.

Pricing 2026

Tier	Monthly cost	Limits
Free	$0	3 users, 10k docs, 100k API requests, 5GB bandwidth
Growth	$99	20 users, 100k docs, 1M API calls, 100GB bandwidth
Enterprise	Custom (~$1k+)	Unlimited

Strapi — open-source and self-hosted

Strapi is a self-hosted, open-source CMS with its own Postgres, MySQL or SQLite backend. Since the v5 release in 2024, the codebase has improved significantly — TypeScript-first and modular.

Architecture

• Strapi backend — Node.js, which you host yourself (Docker, Heroku, AWS)
• DB: Postgres (recommended), MySQL, SQLite (dev only)
• Admin UI: auto-generated from the schema, a React app
• REST + GraphQL APIs are auto-generated

Strengths

• Self-hosted (data residency, GDPR — full control)
• Open source (the code is visible and forkable, no vendor lock-in)
• Plugin ecosystem (auth, i18n, GraphQL, email, SEO)
• Admin UI generated from the schema — fast to build
• Strapi Cloud is an alternative if you don't want to self-host
• TypeScript-first since v5

Weaknesses

• Requires your own operations/DevOps work (Docker, reverse proxy, backups, monitoring)
• Strapi Cloud is new and pricier than the alternatives
• Major version migrations (v3 → v4 → v5) are breaking changes
• The schema workflow is more rigid than Sanity's — schema changes require writing migrations
• Real-time collaboration is limited — one editor at a time per collection

A schema example

// src/api/post/content-types/post/schema.json
{
  "kind": "collectionType",
  "collectionName": "posts",
  "info": { "singularName": "post", "pluralName": "posts" },
  "attributes": {
    "title": { "type": "string", "required": true },
    "slug": { "type": "uid", "targetField": "title" },
    "body": { "type": "richtext" },
    "publishedAt": { "type": "datetime" },
    "author": { "type": "relation", "relation": "manyToOne", "target": "api::author.author" }
  }
}

Pricing 2026

Option	Cost
Self-hosted	$0 licence + your own infrastructure (~$20-50/month VPS)
Strapi Cloud Pro	$99/month
Strapi Cloud Team	$499/month
Strapi Enterprise	Custom

Self-hosting stack

# docker-compose.yml
version: '3'
services:
  strapi:
    image: strapi/strapi:5
    environment:
      DATABASE_CLIENT: postgres
      DATABASE_HOST: db
      DATABASE_NAME: strapi
      DATABASE_USERNAME: strapi
      DATABASE_PASSWORD: ${DB_PASSWORD}
    volumes:
      - ./public/uploads:/srv/app/public/uploads
    ports:
      - "1337:1337"
    depends_on:
      - db
  
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: strapi
      POSTGRES_USER: strapi
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

Contentful — the enterprise headless CMS

The "enterprise" headless CMS. Large customers (Spotify, BMW, Lyft), a mature platform, backed by an SLA.

Architecture

• Cloud-only — no self-hosting option
• EU-region storage is opt-in on the Premium tier
• CDA (Content Delivery API) — public read
• CMA (Content Management API) — write access, at editor level

Strengths

• SLA, support, and enterprise-grade compliance
• A strong CDN with global content delivery
• A content-modelling UI (no-code, built for marketing teams)
• Webhooks, custom apps
• Multi-environment (dev / staging / prod) — built-in
• Audit log, role-based access

Weaknesses

• Expensive at the enterprise tier (typically $1,000+/month)
• A narrow free tier (5 users, 25 content types)
• Vendor lock-in (proprietary API)
• EU residency is available only on the Premium tier (Frankfurt)
• Visual editing is more limited than Sanity's

Pricing 2026

Tier	Monthly cost	Limits
Free	$0	5 users, 25 content types, 100k API calls
Lite	$300	Standard team
Premium	$1,000+	Multi-environment, EU residency
Enterprise	Custom	Unlimited, dedicated support

Comparison table

Aspect	Sanity	Strapi	Contentful
Self-hosting	Studio yes, content in the cloud	Yes, fully	No
Entry-level pricing	$99/month	$0 self-hosted + $20-50 VPS	$300/month
Free-tier usefulness	High	High (self-hosted)	Low
Real-time preview	Excellent	Good	Good
Custom UI	Excellent (Studio)	Good	Limited
Localisation	Built-in, good	Built-in plugin	Built-in, good
Image transformation	Built-in CDN	Plugin / self	Built-in CDN
GDPR / EU hosting	EU-region option	Self-hosted in the EU	EU region (Premium)
Team onboarding	Moderate	Moderate	Easy
Migration/export	JSON export	DB export	JSON export
Multi-environment	Yes (datasets)	Plugin	Built-in
API style	GROQ / GraphQL	REST + GraphQL	REST + GraphQL
Vendor lock-in	Moderate	Low	High
Visual Editing	Excellent (Vercel integration)	Plugin	Limited
AI Assist	Built-in	Plugin	Built-in (Premium)

Five recommendations for Hungarian-market use cases

Use case 1: B2C marketing site (SME, 5-15 pages)

Setup: Simple content (articles, FAQ, landing pages). Hungarian and English. An editorial workflow for a 1-2 person marketing team. 2-5 new articles a week.

Recommendation: Sanity.

Rationale: The free tier is plenty here (10k documents max). The Studio can be tailored to the marketing team's workflow. Visual Editing gives a live preview on the Vercel frontend — marketing colleagues see changes instantly.

Setup time: 1-2 weeks.

Use case 2: E-commerce and product catalogue (mid-size)

Setup: 500+ products, frequent updates, edited by the marketing team. Image-asset management matters.

Recommendation: Sanity or Strapi.

• Sanity, if real-time preview matters and the marketing team likes the Sanity Studio UX.
• Strapi, if self-hosting and GDPR are priorities (image assets on your own server), or if the content model needs complex business logic alongside it.

Setup time: 2-4 weeks.

Use case 3: Multi-brand enterprise (multiple domains, shared brand assets)

Setup: 3+ brand domains, a shared image catalogue, centralised marketing. Role-based access is mandatory (a brand-A user can't edit brand B).

Recommendation: Contentful.

Rationale: The enterprise tier's multi-environment management is hard to replicate elsewhere. Its role-based access and audit log are production-grade.

Setup time: 3-6 weeks.

Use case 4: Internal documentation / wiki

Setup: Team-level content, technical writers, internal-only. SSO integration (MS Entra ID, Google Workspace).

Recommendation: Self-hosted Strapi (or the Notion API — Notion is often a better fit here if you don't want a custom UI).

Rationale: For internal use cases, the self-hosted GDPR advantage dominates. That said, Notion's native collaboration is good enough in 2026 that a custom build often isn't worth it.

Use case 5: Blog and landing site (like the Corevanix site)

Setup: 15-50 articles, a category structure, an SEO focus. An in-house developer team.

Recommendation: Sanity or Strapi. Or: markdown files in git (which is what we do).

Rationale:

• Sanity, if the marketing team's IT affinity is low.
• Markdown-in-git, if the tech team is the content editor (as it is for us).

In the markdown-git approach, markdown processing (remark, gray-matter) happens automatically during the build, content is committed to git, and the frontend reads it at build time. For a detailed implementation pattern, see Corevanix's own blog system.

Markdown files vs. headless CMS — which one, when?

There's a third path: skip the CMS altogether and store markdown files in the git repo. Advantages:

• Free — no hosting, no licence
• Native version control — git history for every change
• Portable anywhere — markdown is a standard, any frontend can read it
• Developer-friendly — code review, branch deploys, PRs
• CI-friendly — build-time content generation, fast
• Performance — static, zero runtime database calls

Disadvantages:

• The marketing team can't edit directly — needs a GitHub UI or a Tina CMS layer
• Image upload and optimisation are a separate process — public folder plus manual upload
• Schema validation is manual — solvable with TypeScript types, but not automatic
• Real-time preview is limited — only via a local dev server or a preview deploy

When does markdown-in-git make sense?

• A tech blog (where the content editors are IT-savvy)
• Personal blog, portfolio
• Documentation site
• Low marketing-content volume (< 50 articles)

When does a headless CMS make sense?

• The marketing team publishes 5+ pieces of new content a week
• Multi-user editorial workflow
• Image-asset library management
• Real-time collaboration is needed

Migration scenarios

WordPress → Sanity / Strapi

The most common migration. Reasons: WordPress is slow, carries security risks, or the frontend is moving to Next.js.

Migration tools:

• Sanity WordPress importer — community-supported
• Strapi WordPress migrator — custom script

Migration time: 2-4 weeks for a blog with 100-500 posts. Image-asset migration is the slowest part (~80% of the effort).

Contentful → Sanity (cost optimisation)

Common after Contentful's 2024 price increase. Achievable via schema export plus a custom mapping script.

Sanity → Strapi (data residency)

Rare, but it happens. The GROQ-to-REST/GraphQL conversion is the main work involved.

Tip: Before migrating, always try running the two systems in parallel for 2 weeks. The frontend reads from the old system while also writing to the new one (shadow mode). Only cut over once the two systems are in sync.

The "don't use" calls — what to avoid

Don't choose Contentful for a small project

The $300/month entry tier is too expensive for many SMEs. The free tier is limited (25 content types). Sanity or Strapi is a better fit.

Don't choose Strapi without DevOps capacity

Maintaining a self-hosted Strapi instance (upgrades, backups, security patches) is an ongoing commitment. Without the capacity for that, go with Sanity or Strapi Cloud.

Don't choose Sanity if the frontend isn't Next.js / Nuxt

Sanity integrates well with modern JS frameworks, but pairing it with WordPress or Drupal "on the side" isn't a good fit — a mismatch of use case.

Don't go headless for 1-2 articles a month

WordPress or a static-site generator (Astro, Hugo, Eleventy) is a better fit for many use cases here. The headless overhead isn't worth it.

Official docs and further reading

• Sanity documentation — official guide
• Strapi documentation — official guide
• Contentful documentation — official guide
• GROQ language reference — Sanity query language
• Storyblok — an alternative Sanity competitor
• Payload CMS — alternative TypeScript-first option

Related articles from us: Next.js 16 production-ready checklist — frontend production setup. Improving webshop conversion rate — e-commerce CMS-selection context. Mobile app GDPR compliance — data-residency principles.

Closing thoughts

There's no single right CMS — it depends on the project and the team. In the Hungarian SME market, Sanity is the default choice for most new projects in 2026. In the enterprise segment, Contentful; where GDPR is the priority, Strapi or markdown-in-git.

Choosing a CMS is roughly a 1-week scope within the discovery phase: interviews with the editorial team, content-volume estimation, mapping multi-locale requirements, and an IT-team skill audit. Setup then takes 2-4 weeks.

If you're planning a web development project, let's talk through the CMS choice during discovery. A 1-week audit (200,000-300,000 HUF) often saves the 5-10 million HUF downstream cost of a wrong CMS choice made 6-12 months earlier.