Je klant geeft groen licht voor Contentful in maart. In augustus chatten je developers over het eruit gooien. Ik heb sinds 2022 productie-builds met Contentful, Sanity en Payload geleverd op 40+ projecten — sommige waren greenfield Next.js apps, anderen reddingen van WordPress-installaties bij elkaar gehouden met tape en gebeden. Elke CMS faalde op een ander, duur moment. Contentful's API-limieten verstikten een productlancering dinsdag om 6 uur 's ochtends. Sanity's GROQ-leercurve verlamde een marketingteam twee sprints lang. Payload's self-hosting rekening verraste een seed-stage founder die dacht dat 'open source' 'gratis' betekende. Eén keuze veroorzaakte consistent minder 2 uur 's nachts Slack-berichten dan de anderen.

Dit artikel splitst Contentful, Sanity en Payload op de dimensies die écht tellen als je iets echts bouwt: prijzen bij schaal, developer experience in de praktijk, content modeling flexibiliteit, API-ontwerp en de dagelijkse redactiewerkflow die je content team óf fantastisch vindt óf haat.

Inhoudsopgave

Contentful vs Sanity vs Payload: Headless CMS vergelijking 2026

Het 30-seconsen overzicht

Contentful is de gevestigde speler. Het bestaat sinds 2013 en drijft enterprise sites op schaal. Het is gepolijst, betrouwbaar en duur.

Sanity is de developer favorite met zijn real-time, gestructureerde content approach en customizable studio. Het is krachtig maar heeft een leercurve en een prijsmodel dat je kan verrassen.

Payload is de opkomeling die stilletjes een serieuze concurrent is geworden. Het is open-source, standaard zelf-gehost (met nu een cloud-optie), geschreven in TypeScript, en vraagt nul licentiekosten. Payload 3.0 werd gelanceerd met een compleet herschrijven bovenop Next.js, en het veranderde de vergelijking helemaal.

Feature Contentful Sanity Payload
Type SaaS SaaS (self-host studio) Open Source / Self-hosted
Taal N/A (alleen API) JavaScript/React TypeScript/Next.js
Licentiekosten Ja Ja (op basis van gebruik) Geen (MIT)
GraphQL Ja Ja (GROQ voorkeur) Ja (auto-gegenereerd)
REST API Ja Ja Ja (auto-gegenereerd)
Realtime samenwerking Beperkt Uitstekend Goed (2.0+)
Self-hosting Nee Alleen studio Volledige stack
Database Eigendom Eigendom MongoDB of Postgres

Prijsafbreking: Wat je echt betaalt

Hier wordt het echt. Prijzen zijn de nummer één reden waarom ik teams CMSsen mid-project heb zien omwisselen, en de nummer één ding die mensen onderschatten tijdens evaluatie.

Contentful Prijzen (2026)

Contentful's gratis laag geeft je 1 space, 5 gebruikers en 25K API-aanroepen. Dat is prima voor een blog.

Het Basic plan start bij €300/maand en geeft je meer environments en rollen. Het Premium plan — wat de meeste serieuze teams nodig hebben — is custom-geprijsd maar begint meestal rond €2.000-€3.000/maand voor middelgrote organisaties. Ik heb enterprise-contracten gezien boven de €80K/jaar.

De kicker: API-call overschrijdingen. Contentful berekent Content Delivery API-aanroepen, Content Management API-aanroepen en asset-bandbreedte apart. Op een site met veel bezoekers die 10M+ paginaweergaven/maand doet, kun je gemakkelijk de inbegrepen quota overschrijden. Een klant waar ik mee werkte zag hun maandelijkse rekening springen van €2.500 naar €4.800 na een viraal productlancering vanwege CDN- en API-overschrijdingen die ze niet zagen aankomen.

Sanity Prijzen (2026)

Sanity gebruikt een model op basis van gebruik dat ze 'pay as you grow' noemen. Het Gratis plan omvat 3 non-admin gebruikers, 500K API-verzoeken, 20GB bandbreedte en 10GB opslag. Royaal om mee te beginnen.

Het Growth plan is €15/gebruiker/maand plus gebruiksoverschrijdingen. Het Enterprise plan is custom-geprijsd.

Het ding met Sanity-prijzen dat mensen bijt: GROQ-query's en API CDN-verzoeken worden gemeten, en de kosten schalen met je content-complexiteit. Een enkele GROQ-query die diep geneste, gerefereerde content haalt, kan meer van je quota verbruiken dan je verwacht. Sanity heeft de transparantie hier verbeterd, maar ik raad teams toch aan budget-alerts vroeg in te stellen.

Typische kostprijs mid-size project: €200-€800/maand afhankelijk van teamgrootte en traffic.

Payload Prijzen (2026)

Payload is MIT-gelicentieerd. De CMS zelf kost €0. Voor altijd. Er zijn geen per-seat kosten, geen API-call meting, geen bandbreedtekosten van Payload.

Je kosten zijn infrastructuur: hosting van een Node.js-app en een database. Op een dienst zoals Railway, Render of een basis AWS/DigitalOcean-setup ben je voor de meeste projecten op €20-€100/maand uit. Ook een large-scale deployment met beheerde Postgres op AWS RDS, een goed gesized EC2 of ECS setup en CloudFront ervoor overschrijdt zelden €300-€500/maand — en dat is voor serieuze traffic.

Payload Cloud (hun gehoste aanbieding) start bij €50/maand met plannen die schalen op basis van opslag en bandbreedte, maar het is volledig optioneel.

Scenario Contentful Sanity Payload (self-hosted)
Solo developer, kleine site €0 (gratis laag) €0 (gratis laag) €20-40/mnd (hosting)
5-persoonsteam, gemiddelde traffic €300-500/mnd €200-400/mnd €50-100/mnd (hosting)
10-persoonsteam, veel traffic €2.000-4.000/mnd €500-1.500/mnd €150-400/mnd (hosting)
Enterprise, 50+ redacteuren €5.000-10.000+/mnd €2.000-5.000/mnd €300-800/mnd (hosting)

De prijs-story is ondubbelzinnig. Payload wint op kosten op elk niveau.

Developer Experience

Prijzen krijgen mensen in de deur. Developer experience houdt ze daar — of jaagt ze weg.

Contentful DX

Contentful's developer experience is... oké. Hun SDK-ondersteuning is breed (JavaScript, Python, Ruby, Java, Swift etc.), documentatie is volwassen, en REST en GraphQL API's zijn goed gedocumenteerd.

Maar hier is wat me frustreert: alles wordt geconfigureerd via de web UI. Content types, velden, validaties — het is allemaal klik-klik-klik in de browser. Ja, je kunt de Contentful CLI en migration-scripts gebruiken om je schema onder versiebeheer te zetten, maar het voelt aangebakken. Het is niet code-first; het is UI-first met een code-ontsnappingsroute.

De migration-tooling is verbeterd met hun contentful-migration package, maar vergeleken met je schema definiëren in TypeScript en direct type-safety krijgen? Het voelt een generatie achter.

Sanity DX

Sanity's developer experience is echt uitstekend op veel manieren. Het schema wordt gedefinieerd in JavaScript/TypeScript-bestanden. De studio is een React-app die je uitgebreid kunt aanpassen — custom input-componenten, custom views, workflow-plugins.

GROQ, hun query-taal, is krachtig als je het eenmaal leert. Maar 'als je het eenmaal leert' doet veel zwaar werk in die zin. GROQ is niet SQL. Het is niet GraphQL. Het is zijn eigen ding, en elke nieuwe developer op je team moet het leren. Ik heb junior developers GROQ-projecties zien worstelen voor weken.

// GROQ-query - krachtig maar unieke syntaxis
*[_type == "post" && publishedAt < now()] | order(publishedAt desc) [0...10] {
  title,
  slug,
  "author": author->{ name, image },
  "categories": categories[]->{ title, slug },
  body[] {
    ...,
    _type == "image" => {
      "url": asset->url
    }
  }
}

Sanity's real-time features zijn ongelooflijk. Meerdere redacteuren werken aan hetzelfde document met presence-indicatoren en geen save-conflicten — het werkt gewoon. De content lake architectuur maakt dit mogelijk op manieren die concurrenten niet kunnen matchen.

Payload DX

Payload 3.0 veranderde alles. Gebouwd op Next.js, volledig geschreven in TypeScript, met je config-bestand als enige bron van waarheid. Je definieert collections, velden, hooks, access control en custom endpoints allemaal in code.

Hier ziet een typische Payload collection eruit:

import { CollectionConfig } from 'payload'

export const Posts: CollectionConfig = {
  slug: 'posts',
  admin: {
    useAsTitle: 'title',
    defaultColumns: ['title', 'status', 'publishedAt'],
  },
  access: {
    read: () => true,
    create: ({ req: { user } }) => Boolean(user),
    update: ({ req: { user } }) => Boolean(user),
    delete: ({ req: { user } }) => user?.role === 'admin',
  },
  fields: [
    {
      name: 'title',
      type: 'text',
      required: true,
    },
    {
      name: 'content',
      type: 'richText',
    },
    {
      name: 'author',
      type: 'relationship',
      relationTo: 'users',
    },
    {
      name: 'status',
      type: 'select',
      options: ['draft', 'published'],
      defaultValue: 'draft',
    },
    {
      name: 'publishedAt',
      type: 'date',
      admin: {
        position: 'sidebar',
      },
    },
  ],
  hooks: {
    beforeChange: [
      ({ data, operation }) => {
        if (operation === 'create') {
          data.publishedAt = new Date()
        }
        return data
      },
    ],
  },
}

Alles is getypeerd. Je IDE vult veldnamen automatisch aan. Hooks geven je lifecycle-controle. Access control wordt gedefinieerd als functies recht naast je velden, niet in een aparte permissions UI. En omdat het gewoon een Next.js-app is, kun je custom pages, API routes of server actions naast je CMS-code toevoegen.

Voor teams die Next.js-development doen, is Payload 3.0 een voor-de-hand-liggende keuze vanuit DX-perspectief. Je CMS en je frontend leven in hetzelfde project. Dezelfde deployment. Dezelfde repo.

Contentful vs Sanity vs Payload: Headless CMS vergelijking 2026 - architectuur

Content Modeling

Content modeling is waar je jezelf instelt voor succes of een nachtmerrie creëert waar je jaren mee leeft.

Contentful's Aanpak

Contentful gebruikt een traditioneel content type → entry model. Je definieert content types met velden, en redacteuren maken entries. References tussen content types zijn expliciet. Het werkt goed voor rechttoe-rechtaan content-structuren.

De beperkingen verschijnen met rich text. Contentful's rich text veld slaat content op als een gestructureerde JSON-boom, wat geweldig is voor render-flexibiliteit, maar het modelleren van complexe page layouts met geneste componenten vereist creatief gebruik van embedded entries en references. Het kan omslachtig worden.

Contentful ondersteunt 50 content types in het Basic plan en 100+ in Premium. Voor grote sites met veel content types kan dit een beperking worden.

Sanity's Aanpak

Sanity's content modeling is waarschijnlijk het meest flexibel van de drie. Hun block content (Portable Text) is een open specificatie voor rich text die content als gestructureerde gegevens opslaat. Je kunt custom block types, inline objecten en annotaties definiëren.

Het schema-systeem ondersteunt diep geneste object types, voorwaardelijke velden en custom validatie. Ik heb enkele echt complexe content models in Sanity gebouwd die pijnlijk zouden zijn in Contentful.

// Sanity schema met Portable Text aanpassing
export default {
  name: 'post',
  type: 'document',
  fields: [
    {
      name: 'body',
      type: 'array',
      of: [
        { type: 'block',
          marks: {
            annotations: [
              { name: 'internalLink', type: 'object',
                fields: [{ name: 'reference', type: 'reference', to: [{ type: 'post' }] }]
              }
            ]
          }
        },
        { type: 'image', options: { hotspot: true } },
        { type: 'codeBlock' },
        { type: 'callout' },
      ]
    }
  ]
}

Payload's Aanpak

Payload's content modeling zit ergens tussen Contentful's gestructureerde eenvoud en Sanity's vormloze flexibiliteit — maar met het voordeel van volledig in TypeScript.

Payload's blocks veld is bijzonder krachtig voor page building. Je definieert block types, elk met hun eigen velden, en redacteuren kunnen pages uit deze blocks samenstellen. Gecombineerd met het layout veld type en voorwaardelijke logica, kun je bijna alles modelleren.

Payload 3.0's Lexical rich text editor is een echte sterkhouder. Het verving Slate (wat oké was maar verouderd) met een moderne editor die custom nodes, inline blocks en server-side rendering ondersteunt. Je kunt React-componenten direct in rich text content insluiten.

Het versioning-systeem verdient vermelding. Payload geeft je draft/publish workflows en volledige document-versiegeschiedenis met diffing. Dit is ingebouwd, niet een betaalde add-on.

API's: REST, GraphQL en alles ertussenin

Contentful API's

Contentful biedt aparte API's voor delivery (CDN-cached, alleen lezen), preview (niet-cached, draft content), management (CRUD) en images. De scheiding is logisch maar betekent dat je jongleert met meerdere API-tokens en basis-URL's.

Hun GraphQL API is solide maar heeft dieptebeperkingen en rate limits die frustrerend kunnen zijn bij het modelleren van diep gerefereerde content. Complexe query's kunnen meerdere round trips vereisen.

Sanity API's

Sanity's primaire query-taal is GROQ, geserveerd over HTTP. Ze bieden ook een GraphQL API, maar die voelt als een tweedeklas burger. GROQ is krachtiger voor de meeste Sanity-use cases toch.

De echte magie is Sanity's real-time listener API. Je kunt je abonneren op veranderingen in elke query en onmiddellijk updates krijgen. Dit maakt live preview-ervaringen mogelijk die echt indrukwekkend zijn.

Payload API's

Payload auto-genereert zowel REST als GraphQL API's vanuit je collection configs. Geen extra setup. Definieer een collection, krijg volledige CRUD endpoints voor zowel REST als GraphQL onmiddellijk.

# Auto-gegenereerde GraphQL query
query {
  Posts(where: { status: { equals: published } }, sort: "-publishedAt", limit: 10) {
    docs {
      id
      title
      content
      author {
        name
      }
      publishedAt
    }
    totalDocs
    hasNextPage
  }
}

Maar hier is waar Payload een uniek voordeel heeft: omdat het in hetzelfde proces als je Next.js-app draait, kun je de API volledig overslaan en Payload's Local API gebruiken voor server-side data-ophaling. Rechtstreekse databasequery's met dezelfde access control, hooks en validatie — maar met nul HTTP-overhead.

// Local API - geen HTTP, geen serialisatie-overhead
const posts = await payload.find({
  collection: 'posts',
  where: { status: { equals: 'published' } },
  sort: '-publishedAt',
  limit: 10,
})

Dit is een enorme performance-winst voor server-gerenderde pages. Geen netwerkrondtrip naar een CMS API. Gewoon een functie-aanroep.

Redactie-ervaring

Ontwikkelaars kiezen de CMS, maar redacteuren leven erin dagelijks. Negeer hun ervaring op je risico.

Contentful heeft de meest volwassen redactie-UI. Het is schoon, voorspelbaar, en je non-technische team pikt het snel op. De planning, workflows en approval chains in het Premium plan zijn solide. Het kan zich echter rigid voelen — het aanpassen van de redactie-interface vereist het bouwen van een Contentful App, wat een hele aparte React-app is.

Sanity Studio is het meest aanpasbaar. Je kunt volledig op maat gemaakte redactie-ervaringen bouwen. Maar die aanpassing kost wat: uit de doos kan Sanity Studio overweldigend voelen voor non-technische redacteuren. De structure builder vereist ontwikkelaarstijd om goed te configureren.

Payload's admin panel is spectaculair verbeterd in 3.0. Het is schoon, snel (het is een Next.js-app) en ondersteunt custom componenten, voorwaardelijke field rendering en live preview. Het is niet zo gepolijst als Contentful's UI, maar het is meer aanpasbaar met minder moeite dan Contentful en begrijpelijker uit de doos dan Sanity.

Self-hosting vs SaaS: De echte afwegingen

Dit is de filosofische scheiding. Contentful en Sanity zijn SaaS-platforms. Je beheert geen infrastructuur; je betaalt hen om het te doen. Payload is standaard zelf-gehost.

Het SaaS-argument: minder ops-overhead, ingebouwde CDN, beheerde uptime. Dit zijn echte voordelen, vooral voor kleine teams zonder DevOps-ervaring.

Het self-hosting argument: dataeigendom, geen vendor lock-in, voorspelbare kosten, regelgeving compliance (GDPR, HIPAA, data residency) en vrijheid om alles aan te passen.

Voor bureaus zoals ons die headless CMS development doen, is zelf-hosting de aanbeveling geworden voor de meeste klanten in 2026. De infrastructure tooling is volwassen geworden tot het punt waar het deployen van een Payload-app op Railway, Vercel of AWS eenvoudig is. Docker maakt het reproduceerbaar. En de kostenbesparingen op een SaaS CMS stapelen zich jaar na jaar op.

Als je bezorgd bent over de ops-last, verwerkt Payload Cloud hosting voor je terwijl je de open-source voordelen behoudt.

Performance en schaalbaarheid

Contentful's CDN-ondersteunde delivery API is snel. Typische response-tijden zijn 50-100ms van edge nodes. Het is tien jaar lang op schaal uitgetest.

Sanity's CDN API levert vergelijkbare performance voor cached content, met hun real-time layer voegend misschien 20-30ms toe voor live queries.

Payload's performance hangt van je infrastructuur af, maar hier is het ding — als je de Local API met Next.js server-componenten gebruikt, maak je een functie-aanroep naar een lokale database. Response-tijden kunnen onder de 10ms liggen. Voeg een CDN voor je Next.js output toe (Vercel, CloudFront enz.) en je matcht of verslaat de SaaS-opties.

Voor Astro-gebaseerde projecten werken alle drie goed als API-bronnen, maar Payload's REST en GraphQL API's zijn bijzonder eenvoudig te consumeren in Astro's data-fetching laag.

Ecosysteem en community

Contentful heeft het grootste enterprise-ecosysteem. Tonnen integraties, een marktplaats van apps en wijdverbreide bureau-ondersteuning.

Sanity heeft een gepassioneerde developer-community, uitstekende documentatie en een groeiend plugin-ecosysteem. Hun community Slack is echt nuttig.

Payload heeft de snelst groeiende community van de drie. Hun Discord is extreem actief, met het core team die regelmatig vragen beantwoordt. Het plugin-ecosysteem is kleiner maar groeit snel — en omdat Payload gewoon Node.js/TypeScript is, kun je alles npm install dat je nodig hebt.

Payload's GitHub heeft meer dan 30K stars vanaf begin 2026 en het traject is steil.

Het oordeel

Ik zal direct zijn: Payload is de beste headless CMS voor de meeste projecten in 2026.

Hier is waarom:

  1. Nul licentiekosten op elke schaal. Je 50-editor enterprise team betaalt Payload geen cent.
  2. TypeScript-native config betekent dat je content model code is, versiebeheerd, type-veilig en reviewable in PR's.
  3. Local API + Next.js integratie geeft je performance die SaaS CMSsen fysiek niet kunnen matchen.
  4. Dataeigendom — je content leeft in jouw database, niet in iemand anders eigendoms-opslag.
  5. Geen vendor lock-in — als je weg wilt schakelen, je gegevens zijn in Postgres of MongoDB. Gewoon query naar.

Er zijn scenario's waar de anderen winnen:

  • Kies Contentful als je een groot enterprise bent met een gevestigd content team dat een gepolijste, zero-ops redactie-ervaring nodig heeft en het budget heeft.
  • Kies Sanity als real-time samenwerking essentieel is voor je workflow, je Portable Text's ongeëvenaard gestructureerde rich text nodig hebt, of je een zeer aangepaste studio-ervaring bouwt.
  • Kies Payload voor al het rest. Startups, bureaus, mid-market bedrijven, developer-led teams, gereglementeerde industrieën die datakontrol nodig hebben, en iedereen die niet wakker wil worden met een verrassing-rekening.

Als je een headless CMS voor een nieuw project evalueert en de specifieke situatie wilt doorlopen, helpen we je graag. We hebben production Payload, Sanity en Contentful projecten geleverd en kunnen je eerlijk advies geven op basis van je werkelijke eisen en budget.

Veelgestelde vragen

Is Payload CMS echt gratis? Ja. Payload is MIT-gelicentieerd open-source software. Er zijn geen licentiekosten, geen per-user lasten en geen API-call limieten van Payload zelf. Je enige kosten zijn infrastructure-hosting (server en database), wat meestal €20-€500/maand draait afhankelijk van schaal. Payload Cloud is beschikbaar als betaalde gehoste optie als je infrastructuur liever niet zelf beheert.

Kan Sanity zelf gehost worden? Gedeeltelijk. Sanity Studio (de admin UI) is een React-app die je overal kunt deployen. De content lake — waar je werkelijke gegevens leven — is echter een gehoste service beheerd door Sanity. Je kunt de gegevenslaag niet zelf hosten. Dit betekent dat je content altijd op Sanity's infrastructuur leeft, wat een zorg kan zijn voor data residency of compliance eisen.

Welke headless CMS heeft de beste GraphQL-ondersteuning? Contentful en Payload beide bieden sterke GraphQL API's. Payload auto-genereert zijn GraphQL schema rechtstreeks vanuit je collection configs, wat betekent nul handmatig schema-onderhoud. Contentful's GraphQL API is volwassen en goed gedocumenteerd. Sanity biedt GraphQL maar geeft GROQ als voorkeur van zijn primaire query-taal, en hun GraphQL-implementatie ondersteunt niet alle GROQ-functies.

Is Contentful de prijs waard in 2026? Voor grote enterprises met complexe content operaties, bestaande Contentful workflows en teams die waarde stellen op een hands-off SaaS-aanpak — ja, het kan de moeite waard zijn. Voor kleine-tot-middelgrote teams is de kosten steeds moeilijker te rechtvaardigen als Payload vergelijkbare (en in sommige opzichten superieure) functionaliteit biedt voor een fractie van de prijs. We hebben meerdere klanten zien migreren weg van Contentful specifiek vanwege kosten.

Hoe verwerkt Payload CMS afbeeldingsoptimalisatie? Payload heeft ingebouwde afbeeldingsgrootte en focal point cropping. Als je een afbeelding uploadt, kan Payload automatisch meerdere grootten genereren op basis van je config. In Payload 3.0 met Next.js kun je dit combineren met Next.js Image optimalisatie voor responsive, WebP/AVIF serving. Het is niet zo feature-rich als Contentful's image API (die URL-gebaseerde transformaties biedt), maar het dekt 90% van use cases zonder een externe service.

Kan ik van Contentful naar Payload migreren? Ja. Omdat Payload standaard databases gebruikt (Postgres of MongoDB), impliceert migratie het exporteren van je Contentful content via hun Management API en het importeren in Payload collections. De content modeling vertaling van Contentful content types naar Payload collections is meestal rechttoe-rechtaan. We hebben meerdere van deze migraties afgehandeld — het lastigste deel is meestal rich text conversie, niet de gestructureerde gegevens.

Welke CMS is het best voor non-technische redacteuren? Contentful heeft de meest intuïtieve out-of-the-box redactie-ervaring voor non-technische gebruikers. Payload's admin panel is een dicht tweede en verbetert snel. Sanity Studio kan het best van alle drie zijn als een developer tijd investeert om het aan te passen, maar de standaardervaring heeft een steilere leercurve voor redacteuren.

Werkt Payload CMS met frameworks behalve Next.js? Absoluut. Terwijl Payload 3.0 Next.js gebruikt als het admin UI framework, werken REST en GraphQL API's met elk frontend — Astro, Nuxt, SvelteKit, Remix, of zelfs mobiele apps. De Local API is Next.js-specifiek, maar externe API's hebben geen framework-afhankelijkheden. We koppelen Payload regelmatig aan zowel Next.js als Astro afhankelijk van project-eisen.