Directus CMS Gids: Database-First Headless CMS voor Developers

De meeste headless CMS-systemen willen dat je je datamodel in hun eigen systeem opbouwt. Directus doet het anders — het wikkelt je bestaande SQL-database in en geeft je meteen REST- en GraphQL-API's zonder dat je iets aan je schema hoeft te veranderen. Met ~34.5k GitHub-sterren en adoptie door bedrijven als Tripadvisor, Adobe en Mercedes-Benz is het een van de krachtigste open-source opties onder de beste headless CMS-opties in 2026.

Wat is Directus CMS?

Directus is een open-source headless CMS dat elke bestaande SQL-database inpakt met directe REST- en GraphQL-API's. Anders dan Strapi of Payload maakt Directus geen eigen databaseschema aan — het spiegelt het jouwe. Het ondersteunt 7 databases waaronder PostgreSQL, MySQL, MariaDB, SQLite, OracleDB, CockroachDB en MS-SQL, en is gratis voor organisaties met minder dan $5M omzet volgens de officiële Directus-documentatie.

Zie het als een slimme laag bovenop je database. Je brengt een bestaande PostgreSQL-database met 50 tabellen, wijst Directus ernaar, en binnen een paar minuten heb je een volledige beheer-UI, rolgebaseerde toegangscontrole en zowel REST- als GraphQL-endpoints. Geen migratiescripts. Geen dataherstructurering.

Dit is wat "database-first" in de praktijk betekent, en dat is fundamenteel anders dan de code-first aanpak van Strapi (waarbij je contenttypes definieert die databasetabellen genereren) of de framework-embedded aanpak van Payload CMS (waarbij de CMS in je Next.js-app leeft).

Database-First Architectuur Uitgelegd

Toen we Directus voor het eerst koppelden aan een bestaande PostgreSQL-database voor een klantproject, was het verrassend hoe weinig setup er nodig was. Directus inspecteert je databaseschema — tabellen worden "collecties", kolommen worden "velden" — en bouwt zijn beheerinterface op basis van wat er al bestaat.

Dat betekent dat je data nooit vastzit in een eigen formaat. Als je morgen stopt met Directus, is je database nog steeds een standaard SQL-database. Probeer dat maar eens met Contentful of Sanity, waar je content op hun servers in hun formaat staat.

Directus is ook niet alleen een CMS. Het team positioneert het als een composable dataplatform — mensen gebruiken het als BaaS (Backend as a Service), interne beheerpanelen en aangepaste dashboards. De CMS-use-case is het populairst, maar de architectuur ondersteunt veel meer.

Kernfuncties van Directus

Directus biedt gelijktijdige REST- en GraphQL-API's, gedetailleerde rolgebaseerde rechten, ingebouwde Flows-automatisering, een drag-and-drop Data Studio, beheer van digitale assets en native i18n-ondersteuning voor 50+ talen. Sinds v11.15 zijn samenwerkend bewerken en een AI-assistent ingebouwde functies — geen plugins van derden.

Dit zijn de dingen die er het meest toe doen als je Directus evalueert voor een project:

Gelijktijdige REST- en GraphQL-API's

Beide API's zijn tegelijk beschikbaar vanuit dezelfde data, zonder configuratie. Je kiest niet de een of de ander — je krijgt allebei. Je mobiele team kan REST gebruiken terwijl je webfrontend GraphQL gebruikt. De REST-API volgt een voorspelbaar patroon (/items/{collectie}) en het GraphQL-eindpunt staat op /graphql.

Flows en Automatisering

Flows is het event-gestuurde automatiseringssysteem van Directus, direct ingebouwd in de Data Studio-UI. Je kunt workflows activeren bij CRUD-events (item aangemaakt, bijgewerkt, verwijderd), schema's (cron-stijl) of webhooks. Bewerkingen omvatten het versturen van e-mails, HTTP-verzoeken doen, aangepaste JavaScript uitvoeren en data transformeren.

Voor teams die met AI bouwen, heeft Directus zelfs een native Model Context Protocol (MCP) gids-server — maar daar meer over in de v11-sectie.

Extensies en Aanpassing

Het extensiesysteem ondersteunt hooks (server-side event handlers), aangepaste endpoints, UI-panelen, volledige modules en bewerkingsknooppunten voor Flows. Extensies worden gebouwd met Vue.js voor de frontend en plain Node.js voor de backend. De v11.0-release herstructureerde extensies van mappengebaseerde typen naar een schoner gebundeld formaat.

Hier is hoe Directus zich verhoudt tot de concurrentie op functies:

Wat is Nieuw in Directus v11 (2025-2026)

Directus v11 introduceerde native MCP-serverondersteuning (v11.13), een AI-assistent die OpenAI, Anthropic en Gemini ondersteunt (v11.14), samenwerkend bewerken met live aanwezigheidsindicatoren (v11.15) en globale conceptversies met rolgebaseerde deploymentrechten (v11.16). Dit zijn allemaal ingebouwde functies, geen communityextensies.

Dit is waar Directus het snelst beweegt, en het is de sectie die de meeste concurrenten volledig missen. Slechts één van de zes best scorende gidsen behandelt hier iets van.

MCP-server en AI-assistent

De v11.13-release maakte Directus een van de eerste CMSen met een native MCP-server. Als je Claude, ChatGPT of een MCP-compatibel AI-tool gebruikt, kan het je Directus-content direct beheren — collecties lezen, items aanmaken, velden bijwerken — terwijl het je RBAC-rechten respecteert. Als je nieuw bent met MCP, legt onze Model Context Protocol (MCP) gids het protocol in detail uit.

De AI-assistent (v11.14) staat los van MCP — het is een ingebouwde chatinterface in de Data Studio die OpenAI, Anthropic, Gemini en zelfs lokale modellen via Ollama ondersteunt. Vanaf v11.16 werd het multimodaal: je kunt afbeeldingen en PDF's rechtstreeks in de AI-chat uploaden voor verwerking.

Samenwerkend Bewerken en Conceptversies

Samenwerkend bewerken werd geleverd in v11.15 met live aanwezigheidsindicatoren (je kunt zien wie hetzelfde item ook aan het bewerken is) en veldniveauvergrendeling om conflicten te voorkomen. Dezelfde release voegde een Vercel-deploymentmodule toe met rolgebaseerde deploymentrechten.

v11.16 nam content-staging verder met globale conceptversies. Elk geversioneerd item krijgt automatisch een conceptkopie. Redacteuren kunnen wijzigingen bekijken ten opzichte van de live versie en concepten promoveren als ze klaar zijn. Rolgebaseerde deploymentrechten betekenen dat je contentteam wijzigingen kan klaarzetten zonder ze per ongeluk naar productie te pushen.

Aan de Slag met Directus (Docker-setup)

Je kunt Directus lokaal draaien met Docker in minder dan 2 minuten. Maak een docker-compose.yml-bestand aan met de directus/directus-image, stel je databaseverbinding en beheerdersgegevens in als omgevingsvariabelen en voer docker compose up uit. Directus start op localhost:8055.

De Docker-setup kostte ons minder dan 2 minuten vanaf nul. Hier is een complete docker-compose.yml met PostgreSQL inbegrepen — niet alleen de Directus-container, maar de volledige stack:

# docker-compose.yml
version: "3"
services:
  database:
    image: postgis/postgis:16-3.4-alpine
    environment:
      POSTGRES_USER: directus
      POSTGRES_PASSWORD: directus
      POSTGRES_DB: directus
    volumes:
      - directus_data:/var/lib/postgresql/data

  directus:
    image: directus/directus:11.16
    ports:
      - "8055:8055"
    depends_on:
      - database
    environment:
      KEY: "your-random-key-here"
      SECRET: "your-random-secret-here"
      ADMIN_EMAIL: "[email protected]"
      ADMIN_PASSWORD: "change-me-please"
      DB_CLIENT: "pg"
      DB_HOST: "database"
      DB_PORT: "5432"
      DB_DATABASE: "directus"
      DB_USER: "directus"
      DB_PASSWORD: "directus"
    volumes:
      - directus_uploads:/directus/uploads

volumes:
  directus_data:
  directus_uploads:

Start het op:

docker compose up -d

Open http://localhost:8055, log in met de beheerdersgegevens die je hebt ingesteld en je bent in de Data Studio. Van hieruit kun je collecties (tabellen) aanmaken, velden (kolommen) definiëren en direct content beheren. De omgevingsvariabelen KEY en SECRET worden gebruikt voor JWT-tokengeneratie — gebruik willekeurige strings in productie, niet de tijdelijke aanduidingen hierboven.

Data Opvragen met de Directus SDK

De Directus JavaScript SDK biedt type-veilige toegang tot je data via zowel REST als GraphQL. Installeer @directus/sdk, maak een client aan met createDirectus() en gebruik readItems() om collecties op te halen met ingebouwde filtering, sortering en veldselectie.

Het composable patroon van de SDK voelde intuïtief aan na het werken met bibliotheken zoals de Supabase-client. Je begint met een basisclient en voegt mogelijkheden toe door functies samen te stellen:

// lib/directus.ts
import { createDirectus, rest, readItems, createItem } from '@directus/sdk';

const client = createDirectus('http://localhost:8055').with(rest());

// Gepubliceerde artikelen ophalen met specifieke velden
const articles = await client.request(
  readItems('articles', {
    fields: ['id', 'title', 'slug', 'content', 'author.name'],
    filter: {
      status: { _eq: 'published' }
    },
    sort: ['-date_published'],
    limit: 10
  })
);

Items aanmaken volgt hetzelfde patroon:

// Een nieuw artikel aanmaken
const newArticle = await client.request(
  createItem('articles', {
    title: 'Mijn Nieuwe Post',
    slug: 'mijn-nieuwe-post',
    content: '<p>Hallo vanuit Directus.</p>',
    status: 'draft'
  })
);

Voor authenticatie kies je tussen staticToken() (voor server-naar-server-communicatie) en authentication() (voor gebruikersgerichte apps met inlogflows):

import { createDirectus, rest, staticToken } from '@directus/sdk';

// Server-side met statisch token
const client = createDirectus('http://localhost:8055')
  .with(staticToken('your-api-token'))
  .with(rest());

REST API-voorbeelden

Elke SDK-methode heeft een equivalent REST-eindpunt. Als je liever rechtstreeks met curl of fetch werkt:

# Gepubliceerde artikelen ophalen
curl "http://localhost:8055/items/articles?filter[status][_eq]=published&sort=-date_published&limit=10&fields=id,title,slug"

# Een nieuw item aanmaken
curl -X POST "http://localhost:8055/items/articles" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title": "Mijn Post", "status": "draft"}'

GraphQL-queries

Dezelfde data is beschikbaar via GraphQL op /graphql:

query {
  articles(
    filter: { status: { _eq: "published" } }
    sort: ["-date_published"]
    limit: 10
  ) {
    id
    title
    slug
    content
    author {
      name
    }
  }
}

Je hoeft GraphQL niet apart te configureren of in te schakelen — het is altijd beschikbaar naast REST.

Directus met Next.js (Framework-integratie)

Directus koppelen aan Next.js duurt drie stappen: installeer @directus/sdk, maak een lib/directus.ts-client aan en haal data op in je Server Components met readItems(). Directus geeft gewone JSON terug, dus je hebt volledige controle over rendering zonder leverancierspecifieke componenten.

Dit is het schoonste deel van werken met Directus. Er is geen speciale framework-adapter, geen Directus-specifieke React-componenten, geen build-plugin. Het is gewoon data ophalen. Als je ooit met een REST-API in Next.js hebt gewerkt, weet je al hoe dit werkt. Voor context over frameworkkeuzes, zie onze vergelijking van Next.js vs Remix.

Maak eerst de gedeelde client aan (dit is hetzelfde bestand uit de SDK-sectie, maar geconfigureerd voor je gedeployde instantie):

// lib/directus.ts
import { createDirectus, rest, staticToken, readItems } from '@directus/sdk';

const directus = createDirectus(process.env.DIRECTUS_URL!)
  .with(staticToken(process.env.DIRECTUS_TOKEN!))
  .with(rest());

export default directus;
export { readItems };

Gebruik het dan in een Server Component — geen useEffect, geen laadstatussen, gewoon async/await:

// app/blog/page.tsx
import directus, { readItems } from '@/lib/directus';

export default async function BlogPage() {
  const posts = await directus.request(
    readItems('posts', {
      fields: ['id', 'title', 'slug', 'excerpt', 'date_published'],
      filter: { status: { _eq: 'published' } },
      sort: ['-date_published'],
    })
  );

  return (
    <main>
      <h1>Blog</h1>
      {posts.map((post) => (
        <article key={post.id}>
          <h2><a href={`/blog/${post.slug}`}>{post.title}</a></h2>
          <p>{post.excerpt}</p>
          <time>{post.date_published}</time>
        </article>
      ))}
    </main>
  );
}

Dat is alles. Geen vendor lock-in. Dezelfde aanpak werkt met Astro, Nuxt, SvelteKit of elk framework dat HTTP-verzoeken kan doen. De officiële Directus-documentatie bevat framework-specifieke gidsen voor Astro en Nuxt als je die wilt, maar het patroon is identiek: client aanmaken, readItems() aanroepen, renderen.

Directus CMS Prijzen en Licenties (2026)

Directus is gratis te self-hosten onder een MIT-licentie voor organisaties met minder dan $5M jaaromzet of financiering. Boven de $5M is een commerciële licentie vereist voor productiegebruik. Directus Cloud begint bij $25/maand (Starter) met Professional-plannen van $49-$499/maand, volgens hun prijspagina.

De $5M Omzetdrempel

Dit is het belangrijkste zakelijke feit over Directus, en de meeste gidsen begraven het of slaan het helemaal over. Zo werkt het:

• Onder $5M jaaromzet of totale financiering: Voor altijd gratis. MIT-licentie. Zelf hosten waar je maar wilt. Geen functiebeperkingen.
• Boven $5M in productie: Je hebt een commerciële licentie nodig. Neem contact op met Directus-verkoop voor prijzen.
• Ontwikkeling en testen: Altijd gratis, ongeacht bedrijfsomvang. De drempel geldt alleen voor productie-deployments.

Het $5M-getal omvat durfkapitaalfinanciering, niet alleen omzet. Een seed-stage startup met $6M aan financiering valt dus technisch boven de drempel. In de praktijk is Directus niet agressief geweest in handhaving voor vroegfase bedrijven, maar je zou dit in je planning moeten meenemen.

Cloud-plannen

Als je de infrastructuur niet zelf wilt beheren, regelt Directus Cloud hosting, back-ups en updates:

• Starter: $25/maand — goed voor kleine projecten en persoonlijke sites
• Professional: $49-$499/maand — schaalt met opslag, bandbreedte en assettransformaties
• Enterprise: Aangepaste prijzen — SLA, dedicated infrastructuur, prioriteitsondersteuning

Geen per-seat-licenties. Je hele team gebruikt hetzelfde plan. Vergelijk dat met Contentful, dat per gebruiker rekent (zie onze Contentful-prijsanalyse), of Sanity, dat rekent op basis van API-gebruik en dataset-bandbreedte.

Directus vs Strapi vs Payload: Vergelijking

Directus wikkelt bestaande databases in zonder migratie, Strapi genereert zijn eigen schema op basis van contenttypes, en Payload integreert rechtstreeks in je Next.js-app. Directus ondersteunt 7 databases, Strapi ondersteunt er 2, en Payload ondersteunt er 2. Alle drie zijn open-source, maar hun filosofieën zijn behoorlijk verschillend.

Na het bouwen van projecten met zowel Strapi als Directus is het grootste verschil hoe ze over je database denken. Met Strapi definieer je contenttypes in de beheer-UI of code, en Strapi maakt en beheert de databasetabellen voor je. Met Directus is de database de bron van waarheid — Directus leest hem en past zich aan.

Wanneer Directus kiezen: Je hebt een bestaande database, je wilt gelijktijdige REST+GraphQL out of the box, of je moet minder gangbare databases ondersteunen zoals OracleDB of CockroachDB.

Wanneer Strapi kiezen: Je wilt het grootste ecosysteem en de grootste community, je definieert liever contenttypes via een UI, of je begint van nul zonder bestaande database. Lees onze volledige Strapi-gids voor details.

Wanneer Payload kiezen: Je wilt de CMS direct in je Next.js-applicatie ingebouwd, je geeft de voorkeur aan TypeScript-first configuratie, of je hebt een Local API nodig die HTTP volledig overslaat. Zie onze Payload CMS-diepgaande analyse voor het volledige verhaal.

Wanneer Directus NIET te Gebruiken

Directus is niet de juiste keuze als je een visuele paginabouwer nodig hebt, een nauw geïntegreerd Next.js-framework, of een NoSQL-backend. Het voegt ook overhead toe voor eenvoudige projecten waarvoor een flat-file CMS of WordPress voldoende zou zijn.

We hebben teams gezien die Directus kozen terwijl dat niet de juiste keuze was, en het patroon is meestal een van de volgende:

• Je hebt een visuele paginabouwer nodig. Directus's Data Studio is uitstekend voor gestructureerd databeheer, maar het is geen drag-and-drop sitebouwer. Als visueel bewerken je prioriteit is, kijk dan naar Storyblok — zie onze Storyblok-gids voor hoe dat zich verhoudt.
• Je bent committed aan NoSQL. Directus is ontworpen voor SQL. Als je data in MongoDB staat, is Payload CMS de natuurlijke keuze.
• Je project is een eenvoudige blog. Docker, PostgreSQL en Directus opstarten voor een persoonlijke blog is serieus overkill. WordPress, Astro met Markdown-bestanden of zelfs Ghost laten je in een fractie van de tijd publiceren.
• Je wilt CMS-in-framework. Als je wilt dat je CMS als een volwaardig onderdeel in je Next.js-codebase leeft, doet Payload dit native. Directus is altijd een aparte service.
• Je bent een grote organisatie. Als je bedrijf de $5M-omzetdrempel overschrijdt, heb je een commerciële licentie nodig voor productie. Weeg die kosten af tegen volledig open-source alternatieven zoals Strapi of Payload, waarbij self-hosting gratis is ongeacht omzet.

Geen van deze punten zijn gebreken — het zijn ontwerpbeslissingen. Directus is een dataplatform, geen websitebouwer. Dat verschil kennen bespaart je maanden frustratie.

FAQ

Wat is Directus CMS?

Directus is een open-source headless CMS dat elke bestaande SQL-database inpakt met directe REST- en GraphQL-API's. Het ondersteunt PostgreSQL, MySQL, MariaDB, SQLite, OracleDB, CockroachDB en MS-SQL. Anders dan traditionele CMSen maakt Directus geen eigen schema aan — het leest en spiegelt automatisch je bestaande databasestructuur.

Is Directus echt gratis?

Directus is gratis te self-hosten onder een MIT-licentie voor organisaties met minder dan $5M jaaromzet of totale financiering. Boven die drempel heb je een commerciële licentie nodig voor productiegebruik. Ontwikkel- en testomgevingen zijn altijd gratis. Directus Cloud, hun beheerde hosting, begint bij $25 per maand.

Hoe verschilt Directus van Strapi?

Directus is database-first — het wikkelt je bestaande SQL-database in zonder het schema te wijzigen. Strapi is code-first — je definieert contenttypes en Strapi genereert databasetabellen. Directus ondersteunt 7 databases terwijl Strapi er 2 ondersteunt. Beide bieden REST-API's, maar Directus bevat native GraphQL terwijl Strapi een plugin vereist.

Welke databases ondersteunt Directus?

Directus ondersteunt zeven SQL-databases: PostgreSQL, MySQL, MariaDB, SQLite, OracleDB, CockroachDB en MS-SQL. Het verbindt met je bestaande database en inspecteert het schema automatisch. Deze ondersteuning voor meerdere databases is uniek onder headless CMSen — de meeste concurrenten ondersteunen slechts één of twee database-engines.

Kan Directus WordPress vervangen?

Directus kan WordPress vervangen voor contentbeheer, vooral voor headless of API-gestuurde projecten. Directus heeft echter geen ingebouwde frontend, thema's of paginabouwer. Je moet je eigen frontend bouwen met een framework zoals Next.js of Astro. Voor eenvoudige blogs of sites die visueel bewerken nodig hebben, blijft WordPress praktischer.

Heeft Directus een visuele editor?

Directus bevat een Data Studio — een krachtige beheer-UI voor het beheren van gestructureerde data, het bouwen van dashboards en het configureren van rechten. Het heeft echter geen visuele paginabouwer of WYSIWYG-sitebewerker zoals Storyblok of WordPress. Directus is ontworpen voor databeheer, niet voor drag-and-drop paginasamenstelling.

Is Directus goed voor e-commerce?

Directus werkt goed als een Product Information Management-systeem — je kunt productcatalogi modelleren, attributen beheren en data via API's serveren. Het is echter geen e-commerceplatform. Je krijgt geen winkelwagen, afrekenproces of betalingsverwerking. Combineer het met Shopify, Saleor of Medusa voor de transactionele laag.

Kan ik Directus gebruiken met Next.js?

Ja. Installeer het @directus/sdk-pakket, maak een client aan die naar je Directus-instantie wijst en haal data op in Server Components met readItems(). Directus geeft gewone JSON terug, dus er zijn geen leverancierspecifieke React-componenten vereist. Dezelfde aanpak werkt met elk JavaScript-framework inclusief Astro, Nuxt en SvelteKit.

Ondersteunt Directus samenwerkend bewerken?

Ja, sinds versie 11.15 (februari 2026). Directus heeft native samenwerkend bewerken met live aanwezigheidsindicatoren die tonen wie wat aan het bewerken is, en veldniveauvergrendeling om conflicten te voorkomen. Dit is een ingebouwde functie, geen plugin. In combinatie met globale conceptversies in v11.16 kunnen teams wijzigingen klaarzetten en bekijken voordat ze publiceren.

Wat is de Directus MCP-server?

Directus introduceerde een native Model Context Protocol-server in v11.13 (november 2025). MCP stelt AI-tools zoals Claude en ChatGPT in staat om direct met je Directus-content te communiceren — items lezen, aanmaken en bijwerken via natuurlijke taal. De MCP-server respecteert je bestaande RBAC-rechten, zodat AI-toegang dezelfde regels volgt als menselijke gebruikers.