Claude Code & Strapi: Headless CMS mit KI-Unterstützung meistern

Strapi ist das meistgenutzte Open-Source-Headless-CMS auf Node.js-Basis — und gleichzeitig eines der Systeme, bei dem die Lernkurve oft steiler ist als erwartet. Content-Types, Dynamic Zones, Lifecycle-Hooks, Berechtigungen, REST- und GraphQL-API: Es gibt viele Konzepte, die zusammenspielen müssen, bevor das erste eigene Projekt sauber läuft.

Claude Code Strapi — das ist der Ansatz, dieses System mit KI-Unterstützung zu erschließen. Nicht als Ersatz für das Verständnis, sondern als Beschleuniger: Schemas generieren lassen, Controller erklärt bekommen, Berechtigungsfehler analysieren, Frontend-Integration planen. Dieser Artikel zeigt, wie das konkret aussieht.

1. Was ist Strapi?

Strapi ist ein Headless CMS — ein Content-Management-System, das den Inhalt von der Darstellung trennt. Während ein klassisches CMS wie WordPress Inhalte und Frontend zusammen ausliefert, stellt Strapi ausschließlich eine API bereit. Das Frontend — ob Next.js, Nuxt, React, Vue, eine mobile App oder ein anderes System — holt die Daten selbst ab und entscheidet, wie sie dargestellt werden.

Technisch basiert Strapi auf Node.js und lässt sich mit npm oder yarn installieren. Die API ist standardmäßig als REST-API verfügbar, wahlweise erweiterbar mit dem GraphQL-Plugin. Die Daten können in SQLite (ideal für die lokale Entwicklung), PostgreSQL, MySQL oder MongoDB gespeichert werden.

Was Strapi von anderen Headless-CMS-Lösungen unterscheidet: alles läuft auf deiner eigenen Infrastruktur. Kein SaaS-Abo, keine API-Limits eines Drittanbieters, vollständige Kontrolle über die Datenhaltung. Das macht es besonders attraktiv für Agenturen, die Projekte für Kunden bauen, und für Unternehmen mit Datenschutzanforderungen.

2. Content-Types: Collection, Single Type, Components, Dynamic Zones

Das Herzstück jedes Strapi-Projekts sind die Content-Types. Hier definierst du, welche Inhaltsstrukturen dein System kennt. Es gibt zwei Grundtypen:

• Collection Type: Mehrere Einträge desselben Schemas — zum Beispiel Artikel, Produkte oder Benutzerprofile. Jeder Eintrag bekommt eine eigene ID und ist über die API einzeln abrufbar.
• Single Type: Genau ein Eintrag pro Schema — typischerweise für Seiteninhalte wie eine “Startseite” oder “Impressum”, die es nur einmal gibt.

Innerhalb dieser Typen kannst du Components verwenden: wiederverwendbare Feldgruppen, die in mehreren Content-Types eingebunden werden können. Ein Beispiel: Eine “SEO”-Component mit Feldern für Title, Description und OG-Image, die du sowohl in Artikeln als auch in Produktseiten nutzt.

Dynamic Zones gehen einen Schritt weiter: Sie erlauben es, verschiedene Components flexibel zu kombinieren — wie ein Seitenbaukasten. Ein Redakteur kann dann im Admin-Panel wählen, ob er einen Text-Block, ein Bild-Block, ein Video-Block oder einen CTA-Block einfügt, und diese in beliebiger Reihenfolge anordnen.

3. Admin-Panel, Content-Type-Builder, Rollen und Berechtigungen

Strapi liefert ein eingebautes Admin-Panel mit, das du unter http://localhost:1337/admin erreichst. Hier erstellt der Content-Type-Builder neue Schemas per Drag & Drop — ohne eine einzige Zeile Code. Felder, Relationen, Components und Dynamic Zones lassen sich über die Oberfläche definieren, Strapi generiert daraus automatisch die entsprechenden Dateien im Verzeichnis src/api/.

Das Rollen- und Berechtigungssystem unterscheidet zwischen zwei Bereichen: Administratoren (die das Admin-Panel bedienen) und öffentliche API-Nutzer (die auf die REST- oder GraphQL-Endpunkte zugreifen). Für die API-Nutzer definierst du unter “Settings → Roles” genau, welche Endpunkte für welche Rolle zugänglich sind — zum Beispiel “Public: find und findOne für Artikel, keine weiteren”.

Ein häufiger Anflängerfehler: Der Endpunkt ist korrekt, aber die API antwortet mit 403 Forbidden. Ursache ist fast immer, dass die Berechtigung für die jeweilige Route in den Role-Settings nicht aktiviert wurde. Claude Code erkennt dieses Muster sofort, wenn du den Fehler mit dem entsprechenden Kontext übergibst.

4. Die Strapi-API: REST, Filtering, Population, GraphQL

Die REST-API folgt einem einheitlichen Muster. Ein Collection Type namens “article” ist automatisch über folgende Endpunkte erreichbar:

GET    /api/articles          # alle Artikel
GET    /api/articles/:id      # ein Artikel per ID
POST   /api/articles          # neuen Artikel anlegen
PUT    /api/articles/:id      # Artikel aktualisieren
DELETE /api/articles/:id      # Artikel löschen

Filtering erfolgt über Query-Parameter. Strapi verwendet eine verschachtelte Syntax:

# Alle Artikel mit Status "published"
GET /api/articles?filters[status][$eq]=published

# Artikel aus einer bestimmten Kategorie, sortiert nach Datum
GET /api/articles?filters[category][name][$eq]=Tech&sort=publishedAt:desc

# Pagination
GET /api/articles?pagination[page]=1&pagination[pageSize]=10

Population ist wichtig: Standardmäßig liefert Strapi keine verknüpften Relationen aus. Um zum Beispiel die Kategorie und den Autor eines Artikels mitzuladen, muss man populate angeben:

GET /api/articles?populate=category,author,cover

Das GraphQL-Plugin aktivierst du über npm run strapi install graphql. Danach steht unter /graphql ein vollständiges GraphQL-Schema bereit, das alle Content-Types abdeckt — inklusive Filtering, Sorting und Pagination in der GraphQL-Syntax.

5. Customization: Controllers, Services, Middlewares, Lifecycle-Hooks und Plugins

Strapi wurde für Erweiterbarkeit gebaut. Die vier wichtigsten Angriffspunkte:

Controllers steuern, was passiert, wenn ein API-Endpunkt aufgerufen wird. Du kannst einen Controller überschreiben, um zum Beispiel die Rückgabe zu transformieren oder zusätzliche Validierungen einzubauen. Strapi stellt Basis-Controller bereit, die du gezielt erweiterst:

// src/api/article/controllers/article.js
const { createCoreController } = require('@strapi/strapi').factories;

module.exports = createCoreController('api::article.article', ({ strapi }) => ({
  async find(ctx) {
    // Nur veröffentlichte Artikel zurückgeben, unabhängig vom Query
    ctx.query.filters = { ...ctx.query.filters, publishedAt: { $notNull: true } };
    return super.find(ctx);
  },
}));

Services enthalten die Geschäftslogik — alles, was nicht direkt mit dem HTTP-Request zusammenhängt. Ein Service kann von mehreren Controllern genutzt werden und ist der richtige Ort für Datenbankabfragen, externe API-Calls oder Berechnungen.

Middlewares laufen vor oder nach dem Controller. Nützlich für Authentifizierung, Logging, Rate-Limiting oder das Hinzufügen von Response-Headern.

Lifecycle-Hooks reagieren auf Datenbankoperationen. Ein beforeCreate-Hook kann zum Beispiel einen Slug aus dem Titel generieren, ein afterCreate-Hook kann eine Benachrichtigung versenden:

// src/api/article/content-types/article/lifecycles.js
module.exports = {
  async beforeCreate(event) {
    const { data } = event.params;
    if (data.title && !data.slug) {
      data.slug = data.title
        .toLowerCase()
        .replace(/\s+/g, '-')
        .replace(/[^\w-]/g, '');
    }
  },
};

Plugins ermöglichen es, eigene Admin-Panel-Seiten, API-Endpunkte und Hooks als eigenständige Module zu entwickeln und wiederzuverwenden — entweder nur für dein Projekt oder als öffentlich veröffentlichtes npm-Paket.

6. Claude Code Strapi: So setzt du es konkret ein

Wo hilft Claude Code im Strapi-Alltag am meisten? Vier konkrete Anwendungsfälle:

Content-Types und Schemas generieren

Statt den Content-Type-Builder manuell zu bedienen, kannst du Claude Code bitten, das Schema direkt zu generieren — besonders nützlich bei komplexen Strukturen mit mehreren Relationen und Dynamic Zones:

claude "Erstelle ein Strapi v5 Content-Type-Schema für einen Blog-Artikel
mit den Feldern: title (Text), slug (UID aus title), content (RichText),
cover (Media), publishedAt (DateTime), author (Relation zu User),
tags (Relation zu Tag, many-to-many), seo (Component: seo.seo-fields),
sections (Dynamic Zone aus text-block, image-block, cta-block)"

Claude Code generiert daraus eine vollständige schema.json, die du direkt in src/api/article/content-types/article/ ablegen kannst. Das spart das manuelle Klicken im Builder und ist besonders wertvoll, wenn du eine Struktur auf mehrere Umgebungen übertragen willst.

Custom-Controller schreiben

Wenn die Standard-Controller von Strapi nicht ausreichen, erklärt Claude Code genau, wie ein Custom-Controller für deinen Anwendungsfall aussehen muss:

claude "Schreib einen Strapi v5 Controller für den Article-Content-Type,
der beim GET /api/articles automatisch die verwandten Artikel auf Basis
gemeinsamer Tags zurückgibt und die Gesamtanzahl der Aufrufe erhöht"

API-Berechtigungen verstehen und debuggen

403-Fehler in Strapi haben fast immer dieselbe Ursache, sind aber schwer zu finden, wenn man die Struktur nicht kennt. Claude Code analysiert den Fehler, liest die Rollenkonfiguration und zeigt genau, welche Berechtigung fehlt — und wo in den Settings sie aktiviert werden muss.

claude "Mein GET /api/articles gibt 403 zurück, obwohl ich keinen
Authorization-Header brauche. Was fehlt in der Strapi-Konfiguration?"

Frontend-Integration planen

Claude Code hilft dabei, die Strapi-API von einem Frontend aus korrekt anzusprechen — inklusive der korrekten Populate-Syntax, Fehlerbehandlung und TypeScript-Typen für die API-Responses:

claude "Schreib eine TypeScript-Funktion für Next.js, die Artikel von
der Strapi v5 API lädt, dabei Kategorie, Autor und Cover populiert,
und bei Fehlern einen sinnvollen Fallback liefert"

Das Ergebnis ist ein vollständiger, typisierter API-Client, der die Eigenheiten der Strapi-Response-Struktur (mit dem verschachtelten data- und attributes-Objekt in v4 bzw. dem direkten Objekt in v5) korrekt behandelt.

Strapi ist ein mächtiges System — aber es hat viele Stellschrauben. Claude Code macht es möglich, diese Stellschrauben zu verstehen und zu bedienen, ohne jedes Mal die gesamte Dokumentation zu durchsuchen. Content-Types generieren, Controller schreiben, Berechtigungsprobleme lösen, Frontend-Integration planen: Das sind genau die Aufgaben, bei denen ein informierter Assistent im Terminal den Unterschied macht.

Zwei verwandte Artikel, die auf diesem Thema aufbauen:

• Claude Code Debugging — wie du Fehler in Strapi und anderen Node.js-Projekten systematisch findest
• Claude Code für Unternehmen — Deployment, Zugriffskontrolle und Team-Workflows auf Unternehmensebene