Directus CMS-guide: Databasdriven Headless CMS för Utvecklare

Directus CMS-guide: Databasdriven Headless CMS för Utvecklare

De flesta headless CMSer vill att du bygger din datamodell inuti deras system. Directus vänder på det — det omsluter din befintliga SQL-databas och ger dig direkta REST- och GraphQL-API:er utan att röra ditt schema. Med ~34 500 GitHub-stjärnor och användning hos företag som Tripadvisor, Adobe och Mercedes-Benz är det ett av de mest kapabla alternativen med öppen källkod bland de bästa headless CMS-alternativen 2026.

Vad är Directus CMS?

Directus är ett headless CMS med öppen källkod som omsluter vilken befintlig SQL-databas som helst med direkta REST- och GraphQL-API:er. Till skillnad från Strapi eller Payload skapar inte Directus ett eget databasschema — det speglar ditt. Det stöder sju databaser inklusive PostgreSQL, MySQL, MariaDB, SQLite, OracleDB, CockroachDB och MS-SQL, och är gratis för organisationer med under 5 miljoner dollar i intäkter enligt Directus officiella dokumentation.

Tänk på det som ett smart lager ovanpå din databas. Du tar en befintlig PostgreSQL-databas med 50 tabeller, pekar Directus på den, och inom några minuter har du ett komplett adminsgränssnitt, rollbaserad åtkomstkontroll och både REST- och GraphQL-endpoints. Inga migrationsscript. Ingen omstrukturering av data.

Det här är vad "databasdriven" faktiskt innebär i praktiken, och det skiljer sig fundamentalt från den kodbaserade ansatsen som används av Strapi (där du definierar innehållstyper som genererar databastabeller) eller den framework-inbyggda ansatsen hos Payload CMS (där CMS:et lever inne i din Next.js-app).

Databasdriven arkitektur förklarad

När vi kopplade Directus till en befintlig PostgreSQL-databas för ett kundprojekt var det som förvånade oss mest hur lite konfiguration som behövdes. Directus introspekterar ditt databasschema — tabeller blir "samlingar," kolumner blir "fält" — och bygger sitt adminsgränssnitt från det som redan finns.

Det innebär att dina data aldrig låses in i ett proprietärt format. Om du bestämmer dig för att sluta använda Directus i morgon är din databas fortfarande en standard SQL-databas. Försök göra det med Contentful eller Sanity, där ditt innehåll lever på deras servrar i deras format.

Directus är inte heller bara ett CMS. Teamet positionerar det som en kompositbar dataplattform — folk använder det för BaaS (Backend as a Service), interna adminpaneler och anpassade dashboards. CMS-användningsfallet är det vanligaste, men arkitekturen stöder mycket mer.

Viktigaste funktionerna i Directus

Directus erbjuder dubbla REST- och GraphQL-API:er, detaljerade rollbaserade behörigheter, inbyggd Flows-automatisering, ett dra-och-släpp-Data Studio, hantering av digitala tillgångar och inbyggt i18n-stöd för 50+ språk. Sedan v11.15 inkluderar det samarbetsredigering och en AI-assistent som inbyggda funktioner — inte tredjepartsplugins.

Det här är vad som spelar störst roll om du utvärderar Directus för ett projekt:

Dubbla REST- och GraphQL-API:er

Båda API:erna är tillgängliga samtidigt från samma data, utan konfiguration. Du väljer inte det ena eller det andra — du får båda. Ditt mobilteam kan använda REST medan ditt webbfrontend använder GraphQL. REST-API:t följer ett förutsägbart mönster (/items/{collection}) och GraphQL-endpointen finns på /graphql.

Flows och automatisering

Flows är Directus händelsedrivna automationssystem, inbyggt direkt i Data Studio-gränssnittet. Du kan trigga arbetsflöden vid CRUD-händelser (objekt skapas, uppdateras, tas bort), scheman (cron-stil) eller webhooks. Operationerna inkluderar att skicka e-post, göra HTTP-förfrågningar, köra anpassad JavaScript och transformera data.

För team som bygger med AI har Directus till och med en inbyggd Model Context Protocol (MCP)-server — men mer om det i v11-avsnittet.

Extensions och anpassning

Extensionssystemet stöder hooks (serverside-händelsehanterare), anpassade endpoints, UI-paneler, fullständiga moduler och operationsnoder för Flows. Extensions byggs med Vue.js för frontend och vanlig Node.js för backend. V11.0-versionen omstrukturerade extensions från typbaserade mappar till ett renare paketerat format.

Så här klarar sig Directus mot konkurrenterna vad gäller funktioner:

Nyheter i Directus v11 (2025–2026)

Directus v11 introducerade inbyggt MCP-serverstöd (v11.13), en AI-assistent som stöder OpenAI, Anthropic och Gemini (v11.14), samarbetsredigering med live-närvaro-indikatorer (v11.15) och globala utkastversioner med rollbaserade driftsättningsbehörigheter (v11.16). Allt detta är inbyggda funktioner, inte community-extensions.

Det är här Directus rört sig snabbast, och det är det avsnitt de flesta konkurrenter missar helt. Bara en av de sex bäst rankade guiderna täcker något av detta.

MCP-server och AI-assistent

V11.13-versionen gjorde Directus till ett av de första CMSerna med en inbyggd MCP-server. Om du använder Claude, ChatGPT eller något MCP-kompatibelt AI-verktyg kan det hantera ditt Directus-innehåll direkt — läsa samlingar, skapa objekt, uppdatera fält — allt medan dina RBAC-behörigheter respekteras. Är du ny på MCP förklarar vår guide till Model Context Protocol (MCP) protokollet i detalj.

AI-assistenten (v11.14) är separat från MCP — det är ett inbyggt chattgränssnitt inne i Data Studio som stöder OpenAI, Anthropic, Gemini och till och med lokala modeller via Ollama. I v11.16 blev den multimodal: du kan ladda upp bilder och PDF:er direkt i AI-chatten för bearbetning.

Samarbetsredigering och utkastversioner

Samarbetsredigering lanserades i v11.15 med live-närvaro-indikatorer (du kan se vem som annars redigerar samma objekt) och fältnivålåsning för att förhindra konflikter. Samma version lade till en Vercel-driftsättningsmodul med rollbaserade driftsättningsbehörigheter.

V11.16 tog innehållsstaging ett steg längre med globala utkastversioner. Varje versionerat objekt får automatiskt en utkastkopia. Redaktörer kan förhandsgranska ändringar mot liveversionen och befordra utkast när de är redo. Rollbaserade driftsättningsbehörigheter innebär att ditt innehållsteam kan iscensätta ändringar utan att råka publicera till produktion.

Kom igång med Directus (Docker-setup)

Du kan köra Directus lokalt med Docker på under 2 minuter. Skapa en docker-compose.yml-fil med directus/directus-imagen, sätt din databasanslutning och admins-inloggningsuppgifter som miljövariabler och kör sedan docker compose up. Directus startar på localhost:8055.

Docker-setupen tog oss under 2 minuter från ett kallt start. Här är en komplett docker-compose.yml med PostgreSQL inkluderat — inte bara Directus-containern, utan hela stacken:

# 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:

Kör det:

docker compose up -d

Öppna http://localhost:8055, logga in med admins-inloggningsuppgifterna du satte, och du är inne i Data Studio. Härifrån kan du skapa samlingar (tabeller), definiera fält (kolumner) och börja hantera innehåll direkt. Miljövariablerna KEY och SECRET används för JWT-tokengenerering — använd slumpmässiga strängar i produktion, inte platshållarna ovan.

Hämta data med Directus SDK

Directus JavaScript SDK ger typsäker åtkomst till dina data via både REST och GraphQL. Installera @directus/sdk, skapa en klient med createDirectus() och använd readItems() för att hämta samlingar med filtrering, sortering och fältval inbyggt.

SDK:ts kompositionsmönster kändes intuitivt efter att ha arbetat med bibliotek som Supabases klient. Du börjar med en basklient och lägger till funktioner genom att komponera:

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

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

// Hämta publicerade artiklar med specifika fält
const articles = await client.request(
  readItems('articles', {
    fields: ['id', 'title', 'slug', 'content', 'author.name'],
    filter: {
      status: { _eq: 'published' }
    },
    sort: ['-date_published'],
    limit: 10
  })
);

Att skapa objekt följer samma mönster:

// Skapa en ny artikel
const newArticle = await client.request(
  createItem('articles', {
    title: 'My New Post',
    slug: 'my-new-post',
    content: '<p>Hello from Directus.</p>',
    status: 'draft'
  })
);

För autentisering väljer du mellan staticToken() (för server-till-server-kommunikation) och authentication() (för användarinriktade appar med inloggningsflöden):

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

// Serverside med statisk token
const client = createDirectus('http://localhost:8055')
  .with(staticToken('your-api-token'))
  .with(rest());

REST API-exempel

Varje SDK-metod har en motsvarande REST-endpoint. Om du föredrar att arbeta med curl eller fetch direkt:

# Hämta publicerade artiklar
curl "http://localhost:8055/items/articles?filter[status][_eq]=published&sort=-date_published&limit=10&fields=id,title,slug"

# Skapa ett nytt objekt
curl -X POST "http://localhost:8055/items/articles" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title": "My Post", "status": "draft"}'

GraphQL-frågor

Samma data är tillgänglig via GraphQL på /graphql:

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

Du behöver inte konfigurera eller aktivera GraphQL separat — det är alltid tillgängligt bredvid REST.

Directus med Next.js (Framework-integration)

Att koppla Directus till Next.js tar tre steg: installera @directus/sdk, skapa en lib/directus.ts-klient och hämta data i dina Server Components med readItems(). Directus returnerar ren JSON, så du har full kontroll över rendering utan leverantörsspecifika komponenter.

Det här är den renaste delen av att arbeta med Directus. Ingen speciell framework-adapter, inga Directus-specifika React-komponenter, inget build-plugin. Det är bara datahämtning. Om du har arbetat med något REST API i Next.js vet du redan hur det fungerar. För sammanhang om val av framework, se vår Next.js vs Remix-jämförelse.

Börja med att skapa den delade klienten (det här är samma fil som i SDK-avsnittet, men konfigurerad för din driftsatta instans):

// 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 };

Använd det sedan i en Server Component — ingen useEffect, inga laddningstillstånd, bara 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>
  );
}

Det är allt. Inget leverantörsberoende. Samma ansats fungerar med Astro, Nuxt, SvelteKit eller vilket framework som helst som kan göra HTTP-förfrågningar. Directus officiella dokumentation inkluderar framework-specifika guider för Astro och Nuxt om du vill ha de, men mönstret är identiskt: skapa klient, anropa readItems(), rendera.

Directus CMS-prissättning och licensiering (2026)

Directus är gratis att egenosta under MIT-licens för organisationer med under 5 miljoner dollar i årliga intäkter eller finansiering. Över 5 miljoner dollar krävs en kommersiell licens för produktionsanvändning. Directus Cloud börjar på $25/månad (Starter) med Professional-planer från $49–$499/månad, enligt deras prissida.

Intäktsgränsen på 5 miljoner dollar

Det här är det viktigaste affärsfaktumet om Directus, och de flesta guider begravs det eller hoppar över det helt. Så här fungerar det:

• Under 5 miljoner dollar i årliga intäkter eller total finansiering: Gratis för alltid. MIT-licens. Egenhosta var som helst. Inga funktionsbegränsningar.
• Över 5 miljoner dollar i produktion: Du behöver en kommersiell licens. Kontakta Directus-sälj för prissättning.
• Utveckling och testning: Alltid gratis, oavsett företagsstorlek. Gränsen gäller bara produktionsdriftsättningar.

5-miljoners-gränsen inkluderar riskkapitalfinansiering, inte bara intäkter. Så ett seed-stage-startup med 6 miljoner dollar i finansiering är tekniskt sett över gränsen. I praktiken har Directus inte varit aggressiva med enforcement för tidiga bolag, men du bör räkna med detta i din planering.

Molnplaner

Om du inte vill hantera infrastruktur hanterar Directus Cloud hosting, säkerhetskopior och uppdateringar:

• Starter: $25/månad — bra för små projekt och personliga sajter
• Professional: $49–$499/månad — skalas med lagring, bandbredd och tillgångstransformationer
• Enterprise: Anpassad prissättning — SLA, dedikerad infrastruktur, prioriterad support

Ingen per-platsbaserad licensiering. Hela ditt team använder samma plan. Jämför det med Contentful, som tar betalt per användare (se vår Contentful-prisjämförelse), eller Sanity, som tar betalt baserat på API-användning och dataset-bandbredd.

Directus vs Strapi vs Payload: Hur de jämförs

Directus omsluter befintliga databaser utan migration, Strapi genererar sitt eget schema från innehållstyper, och Payload bäddas in direkt i din Next.js-app. Directus stöder 7 databaser, Strapi stöder 2 och Payload stöder 2. Alla tre är öppen källkod, men deras filosofier skiljer sig ganska markant.

Att ha byggt projekt med både Strapi och Directus är den största skillnaden hur de tänker på din databas. Med Strapi definierar du innehållstyper i admingränssnittet eller koden, och Strapi skapar och hanterar databastabellerna åt dig. Med Directus är databasen sanningskällan — Directus läser den och anpassar sig.

När du ska välja Directus: Du har en befintlig databas, du vill ha dubbla REST+GraphQL direkt ur lådan, eller du behöver stöd för mer ovanliga databaser som OracleDB eller CockroachDB.

När du ska välja Strapi: Du vill ha det största ekosystemet och communityt, du föredrar att definiera innehållstyper via ett gränssnitt, eller du börjar från scratch utan en befintlig databas. Läs vår fullständiga Strapi-guide för detaljer.

När du ska välja Payload: Du vill ha CMS:et inbäddat direkt i din Next.js-applikation, du föredrar TypeScript-first-konfiguration, eller du behöver ett Local API som hoppar över HTTP helt. Se vår Payload CMS-djupdykning för hela bilden.

När du INTE ska använda Directus

Directus är inte rätt val om du behöver en visuell sidbyggare, ett tätt integrerat Next.js-framework eller en NoSQL-backend. Det tillför också overhead för enkla projekt där ett flat-file-CMS eller WordPress skulle räcka.

Vi har sett team välja Directus när de inte borde ha gjort det, och mönstret är vanligtvis ett av dessa:

• Du behöver en visuell sidbyggare. Directus Data Studio är utmärkt för strukturerad datahantering, men det är ingen dra-och-släpp-sidbyggare. Om visuell redigering är din prioritet, titta på Storyblok — se vår Storyblok-guide för hur det jämförs.
• Du är fast i NoSQL. Directus är utformat enbart för SQL. Om dina data finns i MongoDB passar Payload CMS naturligt.
• Ditt projekt är en enkel blogg. Att dra igång Docker, PostgreSQL och Directus för en personlig blogg är allvarligt överdrivet. WordPress, Astro med Markdown-filer eller till och med Ghost gör att du publicerar på en bråkdel av tiden.
• Du vill ha CMS-i-framework. Om du vill att ditt CMS ska leva inne i din Next.js-kodbas som en förstklassig medborgare gör Payload det inbyggt. Directus är alltid en separat tjänst.
• Du är en stor organisation. Om ditt företag överstiger intäktsgränsen på 5 miljoner dollar behöver du en kommersiell licens för produktion. Väg den kostnaden mot helt öppen källkod-alternativ som Strapi eller Payload, där egenhostning är gratis oavsett intäkter.

Inget av detta är brister — det är designbeslut. Directus är en dataplattform, inte en webbplatsbyggare. Att känna till skillnaden sparar dig månader av frustration.

FAQ

Vad är Directus CMS?

Directus är ett headless CMS med öppen källkod som omsluter vilken befintlig SQL-databas som helst med direkta REST- och GraphQL-API:er. Det stöder PostgreSQL, MySQL, MariaDB, SQLite, OracleDB, CockroachDB och MS-SQL. Till skillnad från traditionella CMSer skapar inte Directus ett eget schema — det läser och speglar din befintliga databasstruktur automatiskt.

Är Directus verkligen gratis?

Directus är gratis att egenosta under en MIT-licens för organisationer med under 5 miljoner dollar i årliga intäkter eller total finansiering. Över den gränsen behöver du en kommersiell licens för produktionsanvändning. Utvecklings- och testmiljöer är alltid gratis. Directus Cloud, deras hanterade hosting, börjar på $25 per månad.

Hur skiljer sig Directus från Strapi?

Directus är databasdriven — det omsluter din befintliga SQL-databas utan att ändra schemat. Strapi är kodbaserat — du definierar innehållstyper och Strapi genererar databastabeller. Directus stöder 7 databaser medan Strapi stöder 2. Båda erbjuder REST-API:er, men Directus inkluderar inbyggd GraphQL medan Strapi kräver ett plugin.

Vilka databaser stöder Directus?

Directus stöder sju SQL-databaser: PostgreSQL, MySQL, MariaDB, SQLite, OracleDB, CockroachDB och MS-SQL. Det ansluter till din befintliga databas och introspekterar schemat automatiskt. Det här stödet för flera databaser är unikt bland headless CMSer — de flesta konkurrenter stöder bara en eller två databasmotorer.

Kan Directus ersätta WordPress?

Directus kan ersätta WordPress för innehållshantering, särskilt för headless- eller API-drivna projekt. Directus har dock inget inbyggt frontend, inga teman och ingen sidbyggare. Du behöver bygga ditt eget frontend med ett framework som Next.js eller Astro. För enkla bloggar eller sajter som behöver visuell redigering förblir WordPress mer praktiskt.

Har Directus en visuell editor?

Directus inkluderar ett Data Studio — ett kraftfullt admingränssnitt för hantering av strukturerade data, byggande av dashboards och konfigurering av behörigheter. Det har dock ingen visuell sidbyggare eller WYSIWYG-siteredigerings-verktyg som Storyblok eller WordPress. Directus är designat för datahantering, inte dra-och-släpp-sidkomposition.

Är Directus bra för e-handel?

Directus fungerar bra som ett produktinformationshanteringssystem — du kan modellera produktkataloger, hantera attribut och leverera data via API:er. Det är dock ingen e-handelsplattform. Du får ingen kundvagn, inget kassaflöde och ingen betalningsbehandling. Para ihop det med Shopify, Saleor eller Medusa för transaktionslagret.

Kan jag använda Directus med Next.js?

Ja. Installera paketet @directus/sdk, skapa en klient som pekar på din Directus-instans och hämta data i Server Components med readItems(). Directus returnerar ren JSON, så inga leverantörsspecifika React-komponenter krävs. Samma ansats fungerar med vilket JavaScript-framework som helst inklusive Astro, Nuxt och SvelteKit.

Stöder Directus samarbetsredigering?

Ja, sedan version 11.15 (februari 2026). Directus har inbyggd samarbetsredigering med live-närvaro-indikatorer som visar vem som redigerar vad, och fältnivålåsning för att förhindra konflikter. Det här är en inbyggd funktion, inte ett plugin. Kombinerat med globala utkastversioner i v11.16 kan team iscensätta och förhandsgranska ändringar innan publicering.

Vad är Directus MCP-server?

Directus introducerade en inbyggd Model Context Protocol-server i v11.13 (november 2025). MCP gör att AI-verktyg som Claude och ChatGPT kan interagera med ditt Directus-innehåll direkt — läsa, skapa och uppdatera objekt via naturligt språk. MCP-servern respekterar dina befintliga RBAC-behörigheter, så AI-åtkomst följer samma regler som mänskliga användare.