Das ist kein Problem – es ist ein lösbares Problem. Mit Polylang, einem kostenlosen WordPress-Plugin, bekommt deine Seite eine zweite Sprache. Kein teures Upgrade, keine Agentur, kein Neustart. Nur ein Plugin, ein paar Einstellungen – und am Ende ein kleiner DE | EN Schalter im Header, der die aktive Sprache fett und in deiner Akzentfarbe hervorhebt.

Dieser Guide dokumentiert die Live-Einrichtung auf foundic.org im März 2026 – mit allem, was dabei schiefgegangen ist, wie es repariert wurde, und was du daraus nicht selbst lernen musst.

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen.
Tanja ist die IT-Expertin. Sie weiß, wie es funktioniert, erklärt geduldig und strukturiert – und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.
Bernd ist der selbsternannte „Experte“, der alles besser weiß – und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.
Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung, dafür ist Tanja da. 

„Und… Action!“

Es ist Montagmorgen. Bernd steht am Whiteboard. Auf dem Board steht in großen Buchstaben: „ZWEISPRACHIG – easy peasy.“

Bernd: „Ich hab das am Wochenende einfach gemacht. Zwei Sprachen, zehn Minuten, fertig. Was soll da groß schiefgehen?“
Ulf: „Und? Hat’s geklappt?“
Bernd: „Naja… die Seite war kurz offline. Aber das war der Server.“
Tanja: „Das war nicht der Server, Bernd. Das war functions.php. Aber fangen wir von vorne an.“

Welchen Weg nimmst du?

Aufbau dieses Guides: Teil 1–3 beschreiben die universelle Polylang-Standardeinrichtung – das funktioniert auf jeder WordPress-Installation. Ab Teil 4 folgt eine projektspezifische Lösung für das Astra-Free-Theme. Wähle vorab, welche Variante zu deinem Setup passt:

Empfehlung: Für die meisten Leser ist Variante A der richtige Einstieg, wartungsarm, dynamisch, funktioniert auf jedem Theme. Variante B ist sinnvoll, wenn du Astra Free verwendest und DE|EN dauerhaft sichtbar im Header-Zentrum haben möchtest. Variante C empfiehlt sich für produktive Sites mit Entwicklerzugriff und langfristiger Wartung.
Dieser Guide dokumentiert Variante B vollständig. Variante A ist nach Teil 3 abgeschlossen. Variante C wird am Ende kurz skizziert.

Ausgangssituation

Stell dir vor, deine Website ist ein gut eingerichtetes Büro – alles auf Deutsch beschriftet, alle Ordner, alle Schilder, alle Dokumente. Jetzt kommen internationale Gäste, und du möchtest, dass sie sich genauso gut zurechtfinden wie die deutschen Besucher.

Genau das macht Polylang: Es gibt deiner Website eine zweite Etage – auf Englisch. Gleiche Struktur, gleiche Navigation, aber alles übersetzt. Und ein kleiner Aufzugsknopf im Header – DE | EN – bringt Besucher in die richtige Etage.

In diesem Guide arbeiten wir mit foundic.org als Beispiel. Die Seite läuft auf WordPress 6.9.4 mit dem Astra-Theme und ist bisher komplett auf Deutsch. 53 Beiträge, 4 Seiten – und kein einziges englisches Wort in der Navigation.

Das ändert sich jetzt.

Was du am Ende haben wirst

• Einen funktionierenden DE | EN Sprachumschalter im Header
• Getrennte Navigationsmenüs für Deutsch und Englisch
• Korrekte URL-Struktur: foundic.org/ für Deutsch, foundic.org/en/ für Englisch
• Automatische Browsersprache-Erkennung für neue Besucher
• Ein solides Fundament, auf dem du Schritt für Schritt englische Inhalte ergänzen kannst

Voraussetzungen

Bevor es losgeht: Hast du das alles?

• WordPress-Installation mit Admin-Zugang
• Ein Theme, das Menüpositionen unterstützt (z.B. Astra)
• Zugriff auf den WordPress Customizer
• Optional, aber dringend empfohlen: Ein Hosting-Backup – dazu mehr im Fehlerbehebungs-Kapitel

Ulf: „Backup? Wofür? Ich mach das einfach rückgängig wenn was schiefgeht.“
Tanja: „Ulf, WordPress hat keinen Rückgängig-Knopf für kaputte PHP-Dateien.“
Bernd: „Ich brauch keine Backups. Ich mach keine Fehler.“
Tanja: „Bernd, du hast letzten Monat die halbe Datenbank überschrieben.“
Bernd: „Das war ein Experiment.“

Mach das Backup. Es dauert zwei Minuten und rettet dich möglicherweise vor einer sehr unschönen Stunde.

Teil 1: Polylang installieren

Ulf: „Polylang – klingt nach nem Fußballverein aus Polen.“
Tanja: „Es ist das meistgenutzte Mehrsprachigkeits-Plugin für WordPress. 800.000 aktive Installationen, 4,5 Sterne. Kostenlos.“
Bernd: „Ich hätte einfach die Texte auf der Seite manuell auf Englisch geändert. Viel simpler.“
Tanja: „Dann hättest du keine deutschen Texte mehr.“
Bernd: „Stimmt. Schlechte Idee.“

Polylang ist wie ein Dolmetscher, der dauerhaft im Hintergrund sitzt. Du schreibst deine Inhalte einmal auf Deutsch, einmal auf Englisch – und Polylang sorgt dafür, dass der richtige Besucher die richtige Version sieht. Es verwaltet separate URLs, getrennte Menüs und die SEO-Tags, die Google braucht, um die Versionen auseinanderzuhalten.

So installierst du es:
Im WordPress-Backend: Plugins → Plugin hinzufügen → Suchfeld: „polylang“
Polylang erscheint als erstes Ergebnis. Auf „Jetzt installieren“ klicken, danach auf „Aktivieren“.

Nach dem Klick auf „Aktivieren“ startet Polylang automatisch den Einrichtungsassistenten. Nicht wegklicken – der führt dich durch die ersten wichtigen Einstellungen.

Teil 2: Einrichtungsassistent durchlaufen

Der Assistent führt durch vier Schritte: Sprachen → Medien → Inhalt → Bereit!
Stell dir das vor wie das Ausfüllen eines Einstellungsformulars beim neuen Job – vier Seiten, und dann kannst du loslegen. Die Fragen sind einfacher als bei der Steuer.

Schritt 1: Sprachen hinzufügen

Im Dropdown zuerst „de_DE – Deutsch“ auswählen, auf „+ Neue Sprache hinzufügen“ klicken. Dann „en_US – English“ auswählen, wieder auf „+ Neue Sprache hinzufügen“ klicken. Beide Sprachen erscheinen in der Liste. Auf „Fortfahren“ klicken.

Ulf: „Warum de_DE und nicht einfach nur Deutsch?“
Tanja: „Weil es verschiedene Varianten gibt – Deutsch aus Deutschland, aus Österreich, aus der Schweiz. Das Kürzel sagt dem System genau, welches gemeint ist. So wie beim Fußball: FC Bayern ist nicht dasselbe wie FC Bayern Amateure.“
Ulf: „Ah. Okay. Das ergibt Sinn.“

Schritt 2: Medien-Einstellungen

Polylang fragt, ob Bilder und Dateien ebenfalls übersetzt werden sollen. Klingt nett, ist aber für die meisten Websites unnötig.

Toggle deaktiviert lassen. Auf „Fortfahren“ klicken.

Was bedeutet das konkret? Deine Bilder bleiben wie sie sind – ein Bild in der Mediathek, das in beiden Sprachversionen verwendet wird. Du müsstest nur dann aktivieren, wenn du für EN andere Bilder mit englischem Text einblenden möchtest.

Schritt 3: Bestehende Inhalte als Deutsch markieren

Polylang entdeckt jetzt, dass du bereits 53 Beiträge und 4 Seiten hast – und keiner davon ist bisher einer Sprache zugeordnet. Das ist wie ein Büro voller unbeschrifteter Ordner: Es gibt sie, aber niemand weiß, in welche Abteilung sie gehören.

„Deutsch – de_DE“ auswählen (bereits vorausgewählt) und auf „Fortfahren“ klicken. Polylang weist allen bestehenden Beiträgen und Seiten automatisch Deutsch zu – die Grundlage dafür, dass du später englische Übersetzungen anlegen und mit den deutschen Originalen verknüpfen kannst.

Bernd: „Kann ich da auch einfach alle auf Englisch setzen? Dann muss ich nichts übersetzen.“
Tanja: „Dann würden deine deutschen Artikel als englische Inhalte geführt. Google würde das bemerken und du bekommst SEO-Probleme.“
Bernd: „Ach so.“
Tanja: „Immer Deutsch. Du kannst danach englische Versionen anlegen.“

Schritt 4: Assistent abschließen

Der Assistent ist fertig. Polylang zeigt eine Bestätigungsseite und schlägt die nächsten Schritte vor.

Polylang ist jetzt aktiv. Was noch fehlt: Der Sprachumschalter, den Besucher tatsächlich sehen und klicken können. Den bauen wir in Teil 3.

Teil 3: Sprachumschalter im Menü einrichten

Jetzt wird es sichtbar. Bis hier hat Polylang still im Hintergrund gearbeitet. Jetzt bekommt deine Website ihren ersten öffentlichen Hinweis: „Hey, hier gibt’s zwei Sprachen.“
Der Sprachumschalter ist wie das Schildchen neben dem Aufzugsknopf. Klein, unscheinbar – aber ohne ihn findet niemand in die zweite Etage.

Schritt 5: Menü-Editor öffnen

Im Backend: Design → Menüs
Der Menü-Editor öffnet sich. Links sieht man jetzt einen neuen Block „Sprachumschalter“ – den hat Polylang automatisch hinzugefügt.

Schritt 6: Sprachumschalter zum Menü hinzufügen

Links unter „Sprachumschalter“ das Häkchen bei „Sprachen“ setzen und auf „Zum Menü hinzufügen“ klicken.
Im Menü erscheint ein neuer Eintrag „Sprachen“ als letzter Punkt.

Schritt 7: Sprachumschalter konfigurieren

Den Eintrag „Sprachen“ aufklappen (Pfeil rechts klicken). Polylang zeigt dir mehrere Einstellungsoptionen. Lass sie alle deaktiviert:

Ulf: „Warum keine Flaggen? Flaggen sind doch cool. Beim Stadion gibt’s auch Flaggen.“
Tanja: „Weil Flaggen für Länder stehen, nicht für Sprachen. Englisch ist nicht nur UK. Österreicher sprechen Deutsch und mögen vielleicht kein deutsches Flaggchen.“
Bernd: „Ich hätte einfach Flaggen genommen und geschaut, ob sich jemand beschwert.“
Tanja: „Das ist kein Ansatz, Bernd.“

Auf „Menü speichern“ klicken.

Wichtig: WordPress bestätigt mit „Hauptmenü wurde aktualisiert.“ im grünen Banner oben auf der Seite.

Schritt 8: CSS für den Sprachumschalter einrichten

Jetzt kommt die Kosmetik. Polylang zeigt den Sprachumschalter standardmäßig mit dem vollen Sprachnamen – „Deutsch“ und „English“. Das ist zu lang und zu unelegant. Wir wollen: DE | EN. Kompakt, klar, modern.

Das geht über CSS – die Gestaltungssprache des Webs. Keine Angst: Du musst hier nichts erfinden. Kopiere einfach den fertigen Code.

Im Backend: Design → Customizer → Zusätzliches CSS

Der Customizer öffnet sich mit dem CSS-Editor links und einer Live-Vorschau rechts. Folgenden Code ans Ende des bestehenden CSS anfügen:

/* ===== Sprachumschalter DE | EN ===== */

/* Originaltext ausblenden */
.lang-item a {
    font-size: 0 !important;
    color: #666;
    text-decoration: none;
    padding: 0 3px;
}

/* Sprachkürzel per Pseudo-Element einblenden */
.lang-item.lang-item-de a::after { content: "DE"; font-size: 13px; }
.lang-item.lang-item-en a::after { content: "EN"; font-size: 13px; }

/* Trennstrich | zwischen den Sprachen */
.lang-item + .lang-item::before {
    content: "|";
    color: #ccc;
    font-size: 13px;
    margin-right: 2px;
}

/* Aktive Sprache: fett + Akzentfarbe */
.lang-item.current-lang a::after {
    font-weight: bold;
    color: #e8691e;
}

Was macht das genau? Der Code blendet zunächst den Originaltext komplett aus (font-size: 0) und blendet dann per ::after die Kürzel „DE“ und „EN“ wieder ein. Der aktiven Sprache gibt er fette Schrift und die Akzentfarbe. Der senkrechte Strich | erscheint automatisch zwischen den beiden Einträgen – kein extra HTML nötig.

Auf „Veröffentlichen“ klicken.

Farbe anpassen: #e8691e ist die Akzentfarbe von foundic.org. Ersetze diesen Wert durch den Hex-Code deiner Website-Farbe. Den findest du meistens in den Theme-Einstellungen unter „Primärfarbe“.

Schritt 9: Ergebnis im Frontend prüfen

Website aufrufen: https://deine-domain.de

Im Header ist jetzt der Sprachumschalter sichtbar – DE erscheint rechts im Menü, in Orange und fett. EN ist noch grau und inaktiv, weil noch keine englischen Inhalte vorhanden sind.

Das ist der erste funktionierende Zwischenstand. Variante-A-Nutzer sind hier fertig – herzlichen Glückwunsch. In Teil 4 gehen wir für Variante B weiter: Der Umschalter wandert in die Mitte des Headers, und EN ist dauerhaft sichtbar.

Bis hierhin: Standard-Polylang-Einrichtung abgeschlossen.
Was du jetzt hast: einen funktionierenden Sprachumschalter im Menü (rechts in der Navigation), der EN automatisch einblendet, sobald eine englische Übersetzung für die aktuelle Seite vorhanden ist. Das ist der offizielle Polylang-Weg – und für viele Websites ausreichend.

Wann reicht das?

• Du willst nur einen funktionierenden Sprachumschalter: → fertig, Teil 4 überspringen
• Du willst EN immer sichtbar, auch ohne Übersetzungen: → Teil 4 nötig
• Du willst den Umschalter exakt in der Header-Mitte bei Astra Free: → Teil 4 nötig
  Die folgenden Schritte sind projektspezifisch für das Ziel: DE | EN dauerhaft sichtbar und zentriert im Astra-Free-Header.

Teil 4: Sprachumschalter dauerhaft sichtbar und zentriert (Astra Free)

Variante B löst ein konkretes Layout-Problem elegant: DE | EN ist dauerhaft im Header sichtbar – unabhängig davon, ob für die aktuelle Seite schon eine Übersetzung existiert. Das gibt der Website von Anfang an ein zweisprachiges Erscheinungsbild, auch wenn die Inhalte noch im Aufbau sind.

Für wen passt Variante B am besten? Für Corporate- oder Marken-Websites, bei denen das visuelle Erscheinungsbild Priorität hat und der Sprachumschalter von Tag 1 sichtbar sein soll. Für redaktionelle Websites mit vielen Artikeln, bei denen Leser per Klick direkt zur übersetzten Version des aktuellen Artikels gelangen sollen, ist Variante A oder C die robustere Wahl.

Bernd betritt den Raum mit einem frischen Kaffee und dem Gesicht eines Mannes, der gerade eine Idee gehabt hat.

Bernd: „Ich würde jetzt einfach das Menü umbauen. Drag and Drop. Fünf Minuten.“
Tanja: „Astra Free hat kein freies Drag-and-Drop im Header Builder. Die Mittelspalte existiert zwar, ist aber standardmäßig null Pixel breit.“
Ulf: „Null Pixel? Das ist wie eine Auswechselbank ohne Spieler.“
Tanja: „Genau. Wir bauen die Bank trotzdem auf – per CSS.“

Problem 1: EN-Link fehlt im Sprachumschalter

Im Menü erscheint zunächst nur „Deutsch“ – der EN-Link fehlt komplett.

Das ist kein Fehler, sondern korrektes Polylang-Verhalten. Polylang zeigt eine Sprache im Switcher nur an, wenn für die aktuell angezeigte Seite eine Übersetzung in dieser Sprache existiert. Da bisher noch keine englischen Inhalte angelegt wurden, bleibt EN unsichtbar.

Die Lösung: Den Polylang-Menü-Switcher durch ein eigenes HTML-Widget im Astra Header Builder ersetzen, das DE und EN immer zeigt – unabhängig davon, ob Übersetzungen vorhanden sind.

Abwägung: Polylang-Switcher vs. eigenes HTML-Widget

Wir entscheiden uns hier für das HTML-Widget, weil DE|EN dauerhaft sichtbar sein soll. Denk daran: Bei einem Domainwechsel oder beim Einrichten einer Staging-Umgebung musst du die Links im Widget manuell aktualisieren.

Problem 2: Sprachumschalter soll in der Header-Mitte stehen

Der Polylang-Menüeintrag erscheint ganz rechts in der Navigation. Gewünscht ist eine Platzierung in der Mitte des Headers – zwischen Logo links und Menü rechts.

Stell dir den Header vor wie ein Fußballfeld: Links steht der Torwart (Logo), rechts stürmt die Mannschaft (Menü). Der Sprachumschalter soll der Libero in der Mitte sein – immer präsent, elegant positioniert.

Da Astra Free keine freie Positionierung im Header Builder erlaubt, greifen wir zu einem CSS-Trick: position: absolute. Das klingt gefährlicher als es ist.

Schritt 10: Astra Header Builder öffnen

Im Backend: Design → Customizer → Header → Header Builder

Der Header Builder zeigt den visuellen Aufbau mit drei Zonen: Links (Logo), Mitte (leer), Rechts (Primäres Menü).

Hinweis bei Astra Free: Das HTML-2-Widget kann nur in die linke Zone gezogen werden – die Mittelzone ist in der kostenlosen Version gesperrt. Die visuelle Zentrierung erreichen wir über CSS.

Schritt 11: HTML 2 Widget einfügen

Im Header Builder das „HTML 2″-Element aus dem Bereich „Verfügbare Widgets“ in den Header ziehen (linke Zone). Durch Klick auf das Widget öffnet sich ein WYSIWYG-Editor – ein einfaches Textfeld mit Formatierungsknöpfen.

Schritt 12: Sprachumschalter-HTML einfügen

Im Editor folgenden Code eingeben:

<nav class="pll-switcher-center">
  <a href="https://www.deine-domain.de/" class="pll-link-de" hreflang="de">DE</a>
  <span class="pll-sep">|</span>
  <a href="https://www.deine-domain.de/en/" class="pll-link-en" hreflang="en">EN</a>
</nav>

URLs anpassen: Ersetze deine-domain.de durch deine echte Domain.

Technische Besonderheit: Der WYSIWYG-Editor fügt nach jedem Element automatisch <br>-Tags ein. Das sieht zunächst seltsam aus – ist aber kein Problem. Das CSS im nächsten Schritt unterdrückt diese Zeilenumbrüche wieder.

Wichtig – Verhalten auf Unterseiten: Dieser HTML-Switcher ist ein statisches Widget. Die Links zeigen immer auf die Startseiten (/ bzw. /en/) – unabhängig davon, auf welchem Artikel der Besucher gerade ist. Das bedeutet: Wer auf einem deutschen Artikel auf EN klickt, landet zunächst auf der englischen Startseite, nicht auf der englischen Übersetzung des Artikels.

Für die Startseite und einfache Navigationszwecke ist das ausreichend. Wer artikelgenaues Umschalten benötigt (Klick auf EN → direkt zur englischen Version des gleichen Artikels), sollte stattdessen den nativen Polylang-Menü-Switcher verwenden (Variante A) oder eine dynamische Lösung per Theme-Hook einsetzen (Variante C). Der native Polylang-Switcher ist wartungsärmer und löst diesen Fall automatisch.

Auf „Veröffentlichen“ klicken.

Schritt 13: CSS vollständig überarbeiten

Jetzt kommt der entscheidende Schritt: Das CSS aus Schritt 13 muss vollständig ersetzt werden. Das bisherige CSS hat den Polylang-Switcher im Menü gestylt – der ist jetzt nicht mehr zuständig. Das neue CSS stylt das HTML-Widget und positioniert es in der Mitte des Headers.

Im Backend: Design → Customizer → Zusätzliches CSS

Das bisherige CSS für .lang-item vollständig durch folgenden Code ersetzen:

/* ===== Sprachumschalter DE | EN (zentriert) ===== */

/* DE|EN als flex-Zeile, br-Tags unterdrücken */
.pll-switcher-center {
    display: flex !important;
    flex-direction: row !important;
    align-items: center;
    gap: 6px;
    margin: 0; padding: 0;
}
.pll-switcher-center br { display: none !important; }

/* Sprachlinks */
.pll-switcher-center a,
.pll-switcher-center .pll-sep {
    font-size: 13px;
    font-weight: normal;
    color: #888;
    text-decoration: none;
    line-height: 1;
}

/* Aktive Sprache fett + orange */
html[lang="de-DE"] .pll-link-de,
html[lang="de"] .pll-link-de { font-weight: bold; color: #e8691e !important; }
html[lang="en-US"] .pll-link-en,
html[lang="en"] .pll-link-en { font-weight: bold; color: #e8691e !important; }

/* HTML 2 Widget absolut zentriert im Header */
.ast-header-html-2 {
    position: absolute !important;
    left: 50% !important;
    top: 50% !important;
    transform: translate(-50%, -50%) !important;
    z-index: 5;
    white-space: nowrap;
}
.site-primary-header-wrap { position: relative !important; }

/* Polylang-Menüeintrag ausblenden (ersetzt durch HTML 2) */
.lang-item { display: none !important; }

Was diese CSS-Regeln bewirken – im Klartext:

• .pll-switcher-center { display: flex } – verhindert, dass die br-Tags DE und EN untereinander stapeln. Flex macht aus einer vertikalen Stapel eine horizontale Zeile.
• html[lang="de-DE"] .pll-link-de – erkennt die aktive Sprache anhand des lang-Attributs, das WordPress automatisch in den <html>-Tag schreibt. Kein JavaScript nötig.
• .ast-header-html-2 { position: absolute } – entnimmt das Widget seinem normalen Platz in der linken Zone und positioniert es exakt in der horizontalen und vertikalen Mitte des Headers. translate(-50%, -50%) korrigiert den Versatz durch den eigenen Elementabstand.
• .lang-item { display: none } – blendet den alten Polylang-Menüeintrag aus, der sonst noch „Deutsch“ im rechten Menü anzeigen würde.

Bernd: „Position absolute? Das ist doch Hacks. Richtige Entwickler machen das nicht so.“
Tanja: „Richtige Entwickler nehmen die Lösung, die funktioniert. Bei Astra Free ist das die einzige Option ohne kostenpflichtiges Upgrade.“
Ulf: „Ist das wie wenn der Trainer taktisch improvisiert, weil der Mittelstürmer verletzt ist?“
Tanja: „Perfekter Vergleich.“

Auf „Veröffentlichen“ klicken.

Schritt 14: Ergebnis prüfen

Website aufrufen. Im Header sind jetzt drei Bereiche sichtbar:

• Links: Logo
• Mitte: DE | EN (zentriert)
• Rechts: Hauptnavigation

Das ist Variante B – dauerhaft sichtbar, sauber zentriert, optisch klar.

Responsive prüfen – vollständige Lösung: Die absolute Positionierung funktioniert auf Desktop sehr gut, kann aber auf schmalen Viewports zu Überlappungen mit Logo oder Menü führen. Die empfohlene Lösung für Mobile:

Desktop: HTML-Widget zentriert im Header (wie eingerichtet)
Mobile: HTML-Widget ausblenden, nativen Polylang-Switcher im Off-Canvas-Menü verwenden

Dazu den Polylang-Menü-Switcher im Hauptmenü nicht entfernen, sondern nur auf Desktop ausblenden. CSS anpassen:

/* Desktop: Polylang-Menüeintrag ausblenden, HTML-Widget sichtbar */
.lang-item { display: none !important; }

/* Mobile: HTML-Widget ausblenden, Polylang-Menüeintrag wieder sichtbar */
@media (max-width: 768px) {
    .ast-header-html-2 { display: none !important; }
    /* Theme-Standarddarstellung des Menüeintrags wiederherstellen –
       je nach Theme kann hier list-item, block oder inherit passender sein */
    .lang-item { display: list-item !important; }
}

So hat der Nutzer auf jedem Gerät einen funktionierenden Sprachumschalter – auf Desktop zentriert und immer sichtbar, auf Mobile im Burger-Menü integriert. Die konkrete display-Eigenschaft kann je nach Theme-Menüstruktur variieren; im Zweifel mit den Browser-Entwicklertools prüfen, welcher Wert der Theme-Standard ist.

Teil 5: Englisches Menü einrichten

Der Sprachumschalter ist da. Aber wenn jemand auf EN klickt und zur englischen Startseite wechselt, sieht er noch immer „KI-News“, „Themen“, „Projekte“, „Schulungen“. Das ist wie ein internationales Hotel, das englische Gäste empfängt – und ihnen dann die Speisekarte auf Deutsch gibt.

Das ändern wir jetzt.

Ulf: „Warte, muss ich jetzt alle meine Artikel auf Englisch schreiben?“
Tanja: „Nein. Erst kommt die technische Struktur – Kategorien, Menüs. Die Artikel kommen danach Schritt für Schritt.“
Bernd: „Ich würde Google Translate drüber laufen lassen. Fertig.“
Tanja: „Bernd, das hat Stiftung Warentest schon für Websites gemacht. Das Ergebnis war erschreckend.“

Schritt 15: Kategorien übersetzen

Im Backend: Beiträge → Kategorien
Polylang hat jetzt neben jeder Kategorie ein kleines Flaggen-Symbol hinzugefügt. Für jede Kategorie die englische Übersetzung anlegen:

Auf das 🇺🇸-Symbol neben einer Kategorie klicken → Editor öffnet sich → englischen Namen eingeben → speichern.

Schritt 16: Permalinks neu speichern

Das ist einer der Schritte, die aussehen als würden sie nichts tun – und trotzdem unverzichtbar sind.

Wichtig: Nach der Kategorien-Übersetzung müssen die Permalinks neu gespeichert werden, damit Polylang die Rewrite-Regeln für /en/ korrekt registriert.

Im Backend: Einstellungen → Permalinks → „Änderungen speichern“ klicken.

Kein Wert muss geändert werden – der Klick alleine reicht. Was passiert im Hintergrund? WordPress schreibt die URL-Muster neu – jetzt weiß der Server, dass Anfragen auf /en/ zu Polylang weitergeleitet werden sollen und nicht als 404-Fehler enden.

Nach dem Speichern ist die englische Startseite unter deine-domain.de/en/ erreichbar. Der Inhalt ist zunächst leer – das ist normal, da noch keine englischen Beiträge vorhanden sind:

Schritt 17: Englisches Menü „Main Menu“ erstellen

Im Backend: Design → Menüs → Link „erstelle ein neues Menü“ klicken.

• Name: Main Menu
• Position im Theme: ☑ Primäres Menü English, ☑ Off-Canvas-Menü English
• Gleichzeitig diese Positionen beim deutschen Hauptmenü abhaken – sonst erscheint das englische Menü auch auf der deutschen Seite
  Auf „Menü erstellen“ klicken.

Schritt 23: Englische Kategorien zum Main Menu hinzufügen

Im Bereich „Menüeinträge hinzufügen“ → Kategorien → Tab „Alle anzeigen“.

Folgende vier englischen Kategorien anhaken:

• ☑ AI News
• ☑ Projects
• ☑ Topics
• ☑ Training

Auf „Zum Menü hinzufügen“ → „Menü speichern“ klicken.

Schritt 24: Ergebnis – beide Sprachen mit eigenen Menüs

Jetzt hat die Website zwei vollständig getrennte Navigationsbereiche.
Englische Seite (deine-domain.de/en/): DE | EN · AI News · Projects · Topics · Training

Teil 6: Browsersprache-Erkennung einrichten

Bisher muss der Besucher selbst auf DE oder EN klicken. Das ist okay. Aber noch besser wäre es, wenn die Website schon beim ersten Besuch automatisch die richtige Sprache zeigt – basierend auf der Browsersprache des Nutzers.

Ulf: „Wie weiß die Website, welche Sprache mein Browser hat?“
Tanja: „Jeder Browser schickt beim Seitenaufruf einen sogenannten Header mit – darin steht die bevorzugte Sprache. Polylang liest das aus und leitet entsprechend weiter.“
Bernd: „Ich hab das einfach über JavaScript gemacht. Hat nicht funktioniert.“
Tanja: „Weil du dann einen gecachten Redirect hattest. Das ist ein Klassiker.“

Schritt 18: Polylang-Einstellung aktivieren

Im Backend: Polylang → Einstellungen → Funktion „Browsersprache erkennen“ aktivieren.
Was passiert: Polylang liest beim ersten Besuch der Startseite den Accept-Language-Header des Browsers und leitet auf die passende Sprachversion weiter. Nur beim ersten Besuch – danach merkt sich ein Cookie die Wahl des Nutzers.

Schritt 19: WP Fastest Cache – Startseite ausschließen

Hier lauert eine unsichtbare Falle – Bernd ist direkt reingetappt.
Problem: WP Fastest Cache speichert die Startseite als statische HTML-Datei. Wird diese gecachte Datei direkt ausgeliefert, läuft kein PHP mehr. Die Polylang-Umleitung ist aber PHP-Code – sie wird also nie ausgeführt. Alle Besucher sehen immer die Standardsprache.
Lösung: Im Plugin WP Fastest Cache → Tab „Ausschließen“ eine Regel für die Startseite anlegen:

• Regel: „Homepage“ → „The homepage has been excluded“
  Anschließend alle Caches leeren: WP Fastest Cache → Alle Caches löschen.
  Gilt auch für andere Caching-Plugins: Jedes Caching-Plugin, das statische HTML-Dateien erzeugt, muss für die Startseite deaktiviert werden. Andernfalls funktioniert die Browsersprache-Erkennung nicht.

Schritt 20: Fallback für nicht-deutsche Sprachen (PHP-Snippet)

Noch ein Feinschliff: Polylang leitet standardmäßig nur dann weiter, wenn die Browser-Sprache exakt einer Website-Sprache entspricht. Ein Besucher mit französischem Browser würde daher auf Deutsch (= Standardsprache) landen – nicht auf Englisch.
Für die meisten internationalen Websites ist Englisch aber der sinnvolle Fallback für alle Nicht-DE-Sprachen. Dafür gibt es ein kleines PHP-Snippet.
Einrichtung über das Plugin „Code Snippets“ (sicherer als functions.php – dazu mehr in Teil 8):

1. Plugin installieren: Plugins → Plugin hinzufügen → „Code Snippets“ suchen und installieren
2. Im Backend: Snippets → Neu hinzufügen
3. Einstellungen:
   • Titel: Polylang: Nicht erkannte Browsersprachen auf Englisch umleiten
   • Typ: PHP
   • Location: Nur im Frontend ausführen
4. Folgenden Code einfügen:

add_filter( 'pll_preferred_language', 'foundic_language_fallback' );
function foundic_language_fallback( $slug ) {
    if ( false === $slug ) {
        return 'en';
    }
    return $slug;
}

5. Snippet aktivieren und speichern

Was macht dieser Code? Polylang übergibt der Filterfunktion die erkannte Browsersprache. Wenn keine passende Sprache gefunden wurde, liefert Polylang false. Das Snippet fängt genau diesen Fall ab und gibt stattdessen 'en' zurück – Englisch also.
Ergebnis:

Hinweis: Gilt nur für Erstbesucher ohne gesetztes pll_language-Cookie. Rückkehrer behalten ihre zuletzt gewählte Sprache. Eingeloggte Admins werden nie umgeleitet.

Das solltest du bedenken: Der Fallback auf Englisch für alle Nicht-DE-Sprachen ist eine Produktentscheidung, keine technische Notwendigkeit. Überleg dir, ob das für deine Zielgruppe sinnvoll ist – für eine deutschsprachige Community-Seite z.B. könnte Deutsch als Fallback besser passen. Außerdem: Browser-Sprache und Nutzerpräferenz sind nicht immer gleich. Wer einen deutschen Browser hat, aber Englisch bevorzugt, landet trotzdem auf Deutsch. Und bei aggressiven Redirect-Setups können Suchmaschinen-Crawler und CDN-Systeme unerwartetes Verhalten zeigen – prüfe nach der Aktivierung, ob Google Search Console keine Crawling-Fehler meldet.

Empfehlung: Für den Anfang lieber ohne Browsersprache-Redirect live gehen. Baue erst Inhalte in beiden Sprachen auf, teste den Switcher manuell und aktiviere die automatische Erkennung erst danach. Für kleine Blogs oder Community-Seiten mit klarer deutschsprachiger Zielgruppe ist die Browserweiterleitung oft gar nicht nötig. Für internationale SEO-Setups mit Google-Traffic aus mehreren Ländern kann sie sinnvoll sein – dann aber unbedingt mit curl-Test und Search-Console-Monitoring einrichten.

Teil 7: Inhalte auf Englisch übersetzen

Die technische Einrichtung ist jetzt vollständig abgeschlossen. Tanja lehnt sich zurück. Ulf sieht aus als hätte er gerade ein Tor geschossen. Bernd hat still seinen Kaffee getrunken.

Ulf: „Und jetzt?“
Tanja: „Jetzt kommt die Arbeit.“
Bernd: „Kann man das nicht automatisch übersetzen lassen?“
Tanja: „Kann man. Sollte man bei Fachtexten nicht. Aber das ist deine Entscheidung.“

Artikel übersetzen

1. Einen Beitrag im Backend öffnen: Beiträge → Alle Beiträge
2. Rechts in der Sidebar erscheint das Polylang-Feld „Sprachen“
3. Neben dem 🇺🇸-Symbol auf „+“ klicken
4. Es öffnet sich ein neuer Editor für die englische Version
5. Den Artikel auf Englisch verfassen und veröffentlichen

Polylang verknüpft beide Versionen automatisch und setzt die korrekten hreflang-Tags für Google – das sind Hinweise im Seitenquelltext, die Google sagen: „Diese Seite existiert auch auf Englisch, und hier ist der Link.“ Wichtig für internationale SEO.

Seiten übersetzen

Für Seiten (Impressum, Datenschutz, etc.) funktioniert es genauso: Seiten → Alle Seiten → gewünschte Seite öffnen → 🇺🇸 → „+“.

Tipp: Übersetze zuerst die rechtlich relevanten Seiten (Impressum, Datenschutz, Cookie-Richtlinie), bevor du die eigentlichen Artikel angehst.

Rechtlicher Hinweis: Eine sprachliche Übersetzung dieser Seiten ersetzt keine rechtliche Prüfung für andere Zielmärkte. Je nach Land können abweichende Anforderungen gelten – etwa andere Pflichtangaben im Impressum oder zusätzliche Datenschutzregelungen. Im Zweifel rechtlichen Rat einholen.

Teil 8: Fehlerbehebung

Tanja stellt eine Tasse Kaffee auf den Tisch. „Jetzt kommen die Dinge, die ich schon erlebt habe. Und Bernd auch.“

In diesem Kapitel sind die häufigsten Probleme bei der Polylang-Einrichtung und ihre Lösungen dokumentiert. Die Fehler sind nach Häufigkeit und Schwere gegliedert.

Häufige Fehler

Fehler 1: EN-Link im Sprachumschalter fehlt

Symptom: Im Menü erscheint nur Deutsch, der EN-Link ist unsichtbar.
Ursache: Polylang-Standardverhalten – EN wird nur angezeigt, wenn für die aktuelle Seite eine englische Übersetzung existiert.
Lösung: HTML-2-Widget im Astra Header Builder verwenden (→ Schritt 15–18).

Fehler 2: 404-Fehler auf /en/

Symptom: Die englische Startseite deine-domain.de/en/ zeigt eine 404-Fehlerseite.
Ursache: Polylang hat die Rewrite-Regeln noch nicht registriert.
Lösung: Im Backend Einstellungen → Permalinks → „Änderungen speichern“ klicken. Kein Inhalt muss geändert werden – der Klick alleine reicht, um die Rewrite-Regeln neu zu schreiben.

Fehler 3: Englische Seite hat kein Menü

Symptom: Auf der /en/-Startseite fehlt die Navigationsleiste komplett.
Ursache: Das englische Menü wurde noch nicht den richtigen Theme-Positionen zugewiesen.
Lösung: Im Backend Design → Menüs → Tab „Positionen verwalten“:

• Primäres Menü English → Main Menu zuweisen
• Off-Canvas-Menü English → Main Menu zuweisen

Layout-Fehler

Fehler 4: Sprachumschalter im Header nicht sichtbar (Astra Grid-Problem)

Symptom: Der Sprachumschalter ist im Header-Builder eingebaut, aber im Frontend unsichtbar.
Ursache: Astra berechnet die Spaltenbreiten dynamisch. Die Mittelspalte kann dabei 0px Breite bekommen – alles darin ist unsichtbar. Das passiert, wenn Astra erkennt, dass die Mittelspalte leer ist, und ihr schlicht keinen Platz zuweist.
Diagnose: In der Browser-Konsole (F12) prüfen:

const header = document.querySelector('.ast-primary-header-bar .ast-builder-grid-row-has-sides');
getComputedStyle(header).gridTemplateColumns;
// Falls Ergebnis: "639.5px 0px 639.5px" → Problem bestätigt

Lösung: CSS-Override im Customizer → Zusätzliches CSS hinzufügen:

/* Sprachumschalter: Center-Spalte sichtbar machen */
.ast-primary-header-bar .ast-builder-grid-row-has-sides.ast-grid-center-col-layout {
  grid-template-columns: 1fr auto 1fr !important;
}
.ast-primary-header-bar .site-header-primary-section-center {
  min-width: 80px !important;
  overflow: visible !important;
}

Fehler 5: Polylang blendet Sprachumschalter per CSS aus

Symptom: Der Sprachumschalter ist im Quellcode vorhanden, aber im Browser nicht sichtbar.
Ursache: Polylang fügt standardmäßig die CSS-Regel .lang-item { display: none } ein und macht die Items normalerweise per JavaScript wieder sichtbar. In manchen Theme-Setups greift dieses JavaScript nicht – und alles bleibt ausgeblendet.
Diagnose: In der Browser-Konsole prüfen:

// Sucht nach der problematischen Regel in allen Stylesheets
[...document.styleSheets].forEach(s => {
  try { [...s.cssRules].forEach(r => {
    if (r.selectorText && r.selectorText.includes('lang-item')) console.log(r.cssText);
  }); } catch(e) {}
});

Lösung: Das CSS im Customizer (Schritt 18) setzt .lang-item { display: none !important; } und verwendet stattdessen das eigene HTML-2-Widget, das nicht von Polylang-CSS beeinflusst wird.

Kritische Fehler

Fehler 6: PHP-Syntaxfehler / Website offline

Das ist Bernds Spezialität.

Bernd: „Ich hab mal schnell was in die functions.php geschrieben. Dann war die Seite weg.“
Tanja: „Wie lange?“
Bernd: „…eine Stunde.“
Ulf: „Eine Stunde! Das ist ein kompletter Halbzeitausfall.“

Symptom: Nach einer Änderung in functions.php zeigt die Website nur einen weißen Bildschirm oder einen HTTP 500-Fehler. Das WordPress-Backend ist nicht mehr erreichbar.
Ursache: Ein PHP-Syntaxfehler in functions.php bringt WordPress komplett zum Absturz. WordPress prüft den Code nicht vor dem Speichern – es speichert einfach, auch wenn der Code kaputt ist.
Lösung A: Über das Hosting-Backup wiederherstellen (empfohlen)

Die meisten Hosting-Anbieter haben eine Backup-Funktion. Bei Strato z.B.:

1. Strato Kundencenter → BackupControl
2. Letztes Backup vor der Änderung auswählen
3. Zu /wp-content/themes/dein-theme/ navigieren
4. functions.php mit dem Symbol ≠ (= Unterschied zum Backup) markieren
5. „Auswahl wiederherstellen“ → Bestätigen
   Nach der Wiederherstellung ist die Website sofort wieder online:

Und die functions.php ist wieder im sauberen Ausgangszustand:

Lösung B: Über FTP/SFTP manuell wiederherstellen

1. Mit einem FTP-Programm (z.B. FileZilla) verbinden
2. Datei /wp-content/themes/dein-theme/functions.php herunterladen
3. In einem Text-Editor öffnen und den fehlerhaften Code entfernen
4. Datei wieder hochladen und überschreiben
   Prävention: Niemals functions.php direkt im WordPress-Theme-Editor bearbeiten. Stattdessen das Plugin „Code Snippets“ verwenden (→ Schritt 27) – es validiert Code vor der Aktivierung und kann einzelne Snippets deaktivieren, ohne die gesamte Website zu zerstören.

Fehler 7: Änderungen im Frontend nicht sichtbar (Cache-Problem)

Symptom: CSS-Änderungen oder Menü-Updates sind im Frontend nicht sichtbar, obwohl sie im Backend gespeichert wurden.
Ursache: Ein Caching-Plugin liefert noch die alte, gecachte Version aus. Das Caching-Plugin weiß nicht, dass du etwas geändert hast – es serviert einfach die gespeicherte Version.
Lösung: Nach jeder Änderung an CSS, Menüs oder Theme-Einstellungen den Cache leeren:

• In der WordPress-Adminleiste auf „WP Fastest Cache“ klicken
• „Alle Caches löschen“ auswählen
  Tipp: Wenn du Änderungen direkt im Customizer machst, immer zuerst auf „Veröffentlichen“ klicken und erst dann den Cache leeren. Die Reihenfolge ist wichtig.

Fehler 8: Browsersprache-Erkennung funktioniert nicht

Symptom: Englischsprachige Besucher landen trotz aktivierter Browsersprache-Erkennung immer auf der deutschen Seite.
Häufige Ursachen und Lösungen:

Test-Tipp: Ein echter Test ist nur mit einem Browser möglich, der auf en eingestellt ist, oder via Terminal:

curl -H "Accept-Language: en" https://deine-domain.de/ -I

Du solltest einen Redirect auf /en/ sehen.

Endergebnis: Funktionstest DE ↔ EN

Der folgende Test zeigt das Ergebnis mit dem nativen Polylang-Menü-Switcher (Variante A), der artikelgenau auf die jeweilige Übersetzung verlinkt:

Auf dem deutschen Artikel: DE | EN – Klick auf EN führt direkt zur englischen Version

Nach dem Wechsel auf EN: Englisches Menü, EN fett/orange, zurück zu DE funktioniert ebenfalls

Hinweis für Variante B (HTML-Widget): Der statische HTML-Switcher im Header zeigt auf Unterseiten immer auf die jeweilige Sprach-Startseite, nicht auf den übersetzten Artikel. Artikelgenaues Umschalten ist mit Variante B nur möglich, wenn zusätzlich der native Polylang-Switcher im Menü aktiv bleibt.

Teil 9: Wartung und spätere Änderungen

Tanja schaut in die Runde. „Ihr denkt, das war’s?“

Es ist nie wirklich fertig. Websites wachsen, Themes ändern sich, neue Sprachen kommen hinzu. Hier sind die häufigsten Wartungsszenarien – damit du nicht wieder von vorne anfangen musst.

Dritte Sprache hinzufügen: In Polylang → Sprachen eine neue Sprache anlegen, ein neues Menü für diese Sprache erstellen und das HTML-Widget im Header um einen dritten Link ergänzen. CSS für .pll-link-xx entsprechend erweitern.

Theme-Wechsel: Das HTML-Widget und das zusätzliche CSS bleiben erhalten (sie liegen im Customizer, nicht im Theme). Prüfe nach dem Theme-Wechsel, ob die CSS-Selektoren .ast-header-html-2 und .site-primary-header-wrap noch greifen – diese sind Astra-spezifisch und müssen für andere Themes angepasst werden.

Wechsel von Astra Free zu Astra Pro: Astra Pro bietet einen echten Header Builder mit freier Positionierung. Das HTML-Widget und die absolute CSS-Positionierung können dann entfernt werden – stattdessen den nativen Polylang-Switcher direkt im Header-Builder platzieren.

Wechsel des Caching-Plugins: Die Ausnahme für die Startseite (→ Schritt 26) muss im neuen Plugin neu eingerichtet werden. Andernfalls funktioniert die Browsersprache-Erkennung nicht.

Migration auf Staging und zurück: Die Domain-URLs im HTML-Widget müssen auf der Staging-Umgebung angepasst werden. Am einfachsten: Widget auf Staging temporär deaktivieren und nur den nativen Polylang-Switcher nutzen.

Teil 10: Rückbau / Deaktivierung

Manchmal will man einen Schritt zurückgehen. Kein Problem – hier ist der saubere Rückweg.

HTML-Widget entfernen: Design → Customizer → Header Builder → HTML-2-Widget aus dem Header ziehen oder löschen.

Nativen Polylang-Switcher reaktivieren: Design → Menüs → Hauptmenü → Sprachumschalter-Eintrag aufklappen → gewünschte Einstellungen setzen. Im CSS den Block .lang-item { display: none !important; } entfernen.

CSS aufräumen: Im Customizer → Zusätzliches CSS den gesamten Block zwischen /* ===== Sprachumschalter DE | EN ===== */ und dem letzten } löschen. Der restliche CSS-Code der Website bleibt unberührt.

Menüs zurücksetzen: Design → Menüs → Tab „Positionen verwalten“ → Primäres Menü English und Off-Canvas-Menü English auf „kein Menü“ setzen, falls gewünscht.

Polylang deaktivieren: Plugins → Polylang → Deaktivieren. Bestehende Übersetzungsverknüpfungen bleiben in der Datenbank erhalten, sind aber ohne Polylang inaktiv. Alle Beiträge bleiben zugänglich – sie verlieren nur ihre Sprachzuordnung.

Teil 11: Hinweis für Entwickler – Variante C

Der HTML-Widget-Ansatz in Variante B ist ein pragmatischer Workaround für Astra Free. Für produktive Websites mit längerfristiger Wartung ist eine dynamische Lösung robuster.

Tanja: „Für Entwickler gibt es eine elegantere Lösung.“
Bernd: „Ich bin quasi auch Entwickler.“
Tanja: „Bernd, du hast functions.php mit Notepad bearbeitet.“
Bernd: „Das ist ein valider Editor.“
Tanja: „Ich rede weiter.“

Eine technisch robustere Alternative ist ein dynamischer Sprachumschalter, der über einen passenden Theme-Hook, einen Template-Part oder einen Shortcode eingebunden wird.

Beispiel: Shortcode

// In einem Child-Theme oder per Code-Snippets-Plugin:
add_shortcode( 'sprachumschalter', function() {
    if ( ! function_exists( 'pll_the_languages' ) ) return '';
    ob_start();
    pll_the_languages( array(
        'show_flags'          => 0,
        'show_names'          => 0,
        'display_names_as'    => 'slug',
        'hide_current'        => 0,
        'hide_if_no_translation' => 0,
    ) );
    return ob_get_clean();
} );

Der Shortcode [sprachumschalter] kann dann in einem Widget, einem Template-Part oder direkt im Header-Markup platziert werden. Polylang rendert dabei dynamisch die korrekten URLs – auf Artikelseiten zeigt der Switcher direkt auf die verknüpfte Übersetzung, nicht auf die Startseite.
Ausgabeformat: pll_the_languages() rendert standardmäßig eine HTML-Liste:

<ul class="ast-nav-menu">
  <li class="lang-item lang-item-de current-lang"><a href="/">DE</a></li>
  <li class="lang-item lang-item-en"><a href="/en/">EN</a></li>
</ul>

Das resultierende Markup muss je nach Theme per CSS an das Header-Layout angepasst werden – insbesondere Darstellung, Abstände und Hervorhebung der aktiven Sprache.

Vorteile gegenüber Variante B:

• Keine statischen URLs – funktioniert bei Domainwechsel und Staging ohne Anpassung
• Artikelgenaue Umschaltung automatisch
• Neue Sprachen werden automatisch eingebunden

Für produktive Nutzung empfohlen:

• In einem Child-Theme umsetzen, damit Theme-Updates den Code nicht überschreiben
• CSS für aktive Sprache, Kontrast und Fokus-Stil ergänzen (→ Accessibility, siehe unten)
• Nach jedem Theme-Update prüfen, ob Hook-Positionen noch stimmen
  Hinweis: pll_the_languages() gibt eine HTML-Liste aus und sollte in einem sichtbaren Frontend-Bereich eingebunden werden – nicht im <head> der Seite.

Go-live-Checkliste

Bevor du die zweisprachige Website offiziell in Betrieb nimmst, diese Punkte abhaken.
🔴 Pflicht · 🟡 Optional · 🔵 Nur Variante B · 🟢 Nur bei aktivem Redirect

Grundfunktion:

• 🔴 DE-Startseite lädt korrekt (deine-domain.de/)
• 🔴 EN-Startseite lädt korrekt (deine-domain.de/en/) – kein 404
• 🔴 Permalinks wurden neu gespeichert
• 🔴 Cache nach allen Änderungen geleert

Navigation:

• 🔴 Deutsches Menü zeigt korrekte Kategorien
• 🔴 Englisches Menü zeigt korrekte Kategorien
• 🔴 Sprachumschalter sichtbar
• 🔴 Aktive Sprache wird fett und farbig hervorgehoben

Sprachumschaltung:

• 🔴 Variante A / C: Klick auf EN von DE-Artikel → landet direkt auf englischer Übersetzung
• 🔴 Variante A / C: Klick auf DE von EN-Artikel → landet direkt auf deutschem Original
• 🔵 Variante B: Header-Switcher zeigt korrekt auf / (DE) und /en/ (EN)
• 🔵 Variante B: Verhalten auf Unterseiten bewusst getestet und dokumentiert

Inhalte:

• 🔴 Mindestens ein DE/EN-Beitrag testweise übersetzt und verknüpft
• 🔴 Rechtliche Seiten in beiden Sprachen vorhanden

Browser-Redirect:

• 🟢 Browser-Redirect in Inkognito-Tab getestet (kein Admin-Cookie)
• 🟢 Google Search Console: keine neuen Crawling-Fehler nach Aktivierung

Technik:

• 🔴 Desktop, Tablet und Mobile geprüft
• 🟡 Accessibility: Sprachumschalter per Tastatur erreichbar, ausreichender Kontrast
• 🟡 XML-Sitemap: EN-URLs erscheinen in der Sitemap (SEO-Plugin ggf. neu generieren)

Zusammenfassung: Was wurde eingerichtet?

Gemeinsame Grundlage (alle Varianten):

Variante A – Standard:

Variante B – Astra Free zentriert (dieser Guide):

Optional (unabhängig von Variante):

Accessibility-Hinweise

Beim eigenen HTML-Widget (Variante B) ist Barrierefreiheit nicht automatisch gewährleistet. Das klingt nach Bürokratie – ist aber für Tastaturnutzer und Screenreader-Nutzer ein echter Unterschied. Diese Punkte solltest du prüfen und ergänzen:
aria-label am Nav-Element:

<nav class="pll-switcher-center" aria-label="Sprache wechseln">
  <a href="..." class="pll-link-de" hreflang="de" lang="de">DE</a>
  <span class="pll-sep" aria-hidden="true">|</span>
  <a href="..." class="pll-link-en" hreflang="en" lang="en">EN</a>
</nav>

Aktive Sprache nicht nur über Farbe kennzeichnen – ergänze aria-current="true" auf dem aktiven Link oder stelle sicher, dass die Fettung allein als visueller Unterschied ausreicht. Farbe allein ist laut WCAG kein ausreichendes Unterscheidungsmerkmal.
Kontrast prüfen: Die inaktive Farbe (#888 im Beispiel-CSS) hat gegen einen weißen Header möglicherweise zu wenig Kontrast. Ziel: mindestens 4,5:1 für normalen Text (WCAG AA).
Fokus-Stil: Stelle sicher, dass die Links per Tastatur erreichbar sind und einen sichtbaren Fokus-Rahmen haben. Viele Themes entfernen den Browser-Standard-Fokus per outline: none. Ergänze im Customizer CSS:

.pll-switcher-center a:focus-visible {
    outline: 2px solid currentColor;
    outline-offset: 2px;
}

Das sorgt für einen sichtbaren Fokusrahmen bei Tastaturnavigation, ohne das visuelle Design bei Mausnutzung zu beeinflussen.

SEO-Prüfung nach den ersten Übersetzungen

Sobald die ersten Beiträge in beiden Sprachen veröffentlicht sind, diese Punkte prüfen:
hreflang-Tags:

• Sind die hreflang-Tags paarweise korrekt? DE-Seite verweist auf EN, EN-Seite verweist auf DE.
• Im Seitenquelltext prüfen: <link rel="alternate" hreflang="de" href="..."/> und <link rel="alternate" hreflang="en" href="..."/>müssen beide vorhanden sein.
  Canonicals:
• Zeigt jede Seite auf sich selbst als Canonical? DE-Seite → DE-URL, EN-Seite → EN-URL. Keine Kreuz-Verlinkung.
  Indexierung:
• EN-Seiten indexierbar? In Google Search Console prüfen, ob /en/-URLs gecrawlt und indexiert werden.
• Leere EN-Entwürfe (ohne Inhalt) nicht indexieren – entweder auf noindex setzen oder erst veröffentlichen, wenn Inhalt vorhanden.
  Interne Links:
• Sind interne Links innerhalb eines Sprachbereichs konsistent? Deutsche Artikel verlinken auf deutsche Seiten, englische auf englische.
  XML-Sitemap:
• Tauchen EN-URLs in der Sitemap auf? Nach dem Veröffentlichen erster englischer Beiträge das SEO-Plugin (Rank Math, Yoast, o.ä.) öffnen und die Sitemap einmal neu generieren lassen.
• In der Google Search Console die Sitemap einreichen und prüfen, ob EN-Seiten ohne Fehler indexiert werden.

Nächste Schritte

Die technische Einrichtung ist vollständig. Tanja nickt zufrieden. Ulf schaut aus dem Fenster. Bernd öffnet gerade ein neues Browserfenster – man weiß nie.
Jetzt kannst du Schritt für Schritt Inhalte auf Englisch ergänzen:

1. Rechtlich relevante Seiten zuerst: Impressum → Legal Notice, Datenschutz → Privacy Policy
2. Dann die wichtigsten Artikel übersetzen
3. Jede übersetzte Seite erscheint automatisch im Sprachumschalter des entsprechenden DE-Artikels

Ulf: „Das war gar nicht so schlimm.“
Tanja: „Das sagen alle am Ende.“
Bernd: „Ich hätte das in zehn Minuten gemacht.“
Tanja: „Bernd, du bist immer noch nicht fertig mit deinem Backup von letztem Monat.“
Bernd: „Das ist ein laufendes Projekt.“

OpenClaw ist ein KI-Agent, den du lokal auf deiner Synology DiskStation betreibst. Statt in der Cloud läuft er bei dir zu Hause – du behältst die Kontrolle über deine Daten, zahlst nur für die tatsächlich genutzten API-Anfragen und erreichst deinen persönlichen Assistenten per Telegram oder Browser.

Am Ende dieser Anleitung hast du:

• Einen laufenden OpenClaw-Container auf deiner DiskStation
• Einen Telegram-Bot, dem du auf deinem Smartphone einfach schreiben kannst
• Eine optionale Web-Oberfläche, erreichbar per SSH-Tunnel im Browser
• Optional: Netzwerk-Isolation, die dem Container den Zugriff auf dein Heimnetz verwehrt
• Optional: Einen eingebetteten Browser, mit dem OpenClaw auch JavaScript-lastige Webseiten bedienen kann

Die Grundinstallation – Container läuft, Telegram antwortet – dauert etwa 30 Minuten. Die optionalen Schritte kommen danach, wenn das Fundament steht.

Voraussetzungen

Bevor du anfängst – stelle sicher, dass du das Folgende zur Hand hast:

• Synology DS1621+ mit aktuellem DSM 7.2 oder neuer
• Container Manager installiert (aus dem Paket-Zentrum)
• SSH-Zugang zur DiskStation (wird in dieser Anleitung erklärt)
• Einen API-Schlüssel von Anthropic (Claude) oder OpenAI
• Telegram auf dem Smartphone

Noch kein API-Key? Für Claude gehe auf console.anthropic.com, melde dich an, hinterlege eine Zahlungsmethode und erstelle einen Schlüssel. Er beginnt mit sk-ant-...

Architektur auf einen Blick

So sieht die fertige Ordnerstruktur auf deiner DiskStation aus. Sie entsteht Schritt für Schritt – du musst nichts manuell vorbereiten.

/volume1/docker/openclaw/
├── compose.yaml             ← Container-Konfiguration (Berechtigungen, Netzwerk, Volumes)
├── openclaw-firewall.sh     ← Netzwerk-Isolation (optional, aber empfohlen)
├── config/                  ← API-Keys, Einstellungen (wird beim Onboarding befüllt)
└── workspace/               ← Arbeitsdateien des Agenten

OpenClaw besteht aus zwei Diensten, die in der compose.yaml definiert sind:

• openclaw-gateway – der dauerhaft laufende Dienst. Er hält die Verbindung zu Telegram, stellt die Web-UI bereit und kommuniziert mit der KI-API.
• openclaw-cli – ein Einmal-Container für Verwaltungsaufgaben (Onboarding, Konfiguration, Pairing). Er startet auf Abruf und beendet sich danach selbst.

Container oder VM? Die erste große Entscheidung

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen.
Tanja ist die IT-Expertin. Sie weiß, wie es funktioniert, erklärt geduldig und strukturiert – und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.
Bernd ist der selbsternannte „Experte“, der alles besser weiß – und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.
Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung, dafür ist Tanja da. 

„Und… Action!“

Es ist Montagmorgen. Bernd steht vor dem Whiteboard, Marker in der Hand, und hat „VM“ in Großbuchstaben hingeschrieben. Er lehnt sich zurück, faltet die Arme, sieht sehr zufrieden aus.
Bernd: „VM. Immer VM. Sicherer. Professioneller. Echte Admins nehmen VMs. Ende der Diskussion.“
Ulf: „Was ist nochmal der Unterschied? VM klingt nach VfL Mönchengladbach.“
Tanja: „Stell dir eine VM vor wie ein komplett eingerichtetes Fußballstadion – eigene Umkleide, eigener Rasen, eigene Kantine. Ein Docker-Container dagegen ist nur der Spieler mit seinen Fußballschuhen. Kein eigenes Stadion, aber er läuft deutlich schneller auf den Platz.“
Bernd: „Eben! Deshalb VM – wegen der Isolation!“
Tanja: „Das stimmt halb, Bernd. Eine VM bietet bessere Kernel-Isolation. Aber OpenClaw wurde als Docker-Applikation gebaut – mit fertigem Dockerfile und docker-compose.yml im Repo. Den Container-Weg wählen wir hier. Und wer wirklich maximale Isolation will, kann OpenClaw auch innerhalb einer VM per Docker Compose installieren – der Rest der Anleitung bleibt dann identisch.“

Diese Anleitung geht den Container-Weg. Die zusätzlichen iptables-Regeln im optionalen Sicherheitskapitel reduzieren das Risiko, dass ein kompromittierter Container interne Geräte im Heimnetz erreicht. Sie ersetzen jedoch keine VM-Isolation, kein Patch-Management und keine sorgfältige Prüfung der eingesetzten Container-Images.

Teil 1: Vorbereitung auf der DiskStation

Schritt 1.1: Container Manager installieren

Ulf: „Container Manager – ist das so eine Art Transfer-Manager für Docker-Spieler?“
Tanja: „Fast! Container Manager ist die grafische Oberfläche auf deiner DiskStation, über die du Docker-Container startest, stoppst und überwachst. Ohne ihn läuft gar nichts.“
Bernd: „Hab ich nie gebraucht. Ich mach das alles per SSH. Echter Admin braucht keine GUI.“
Tanja: „Bernd, du hast letzten Monat versehentlich alle Container gelöscht, weil du dich in der IP vertippt hast.“

1. Öffne die DiskStation-Oberfläche im Browser.
2. Öffne das Paket-Zentrum.
3. Suche nach Container Manager.
4. Klicke Installieren – falls nicht bereits vorhanden.

Schritt 1.2: SSH aktivieren

SSH (Secure Shell) ist dein verschlüsselter Tunnel direkt in die DiskStation. Statt für jeden Befehl durch die Weboberfläche zu klicken, kannst du Befehle direkt eintippen – wie eine Direktverbindung zum Herzstück deines Servers.

Bernd: „Ich hab SSH dauerhaft offen und Port 22 direkt ins Internet weitergeleitet. Effizienter.“
Tanja: „… Das machen wir nicht. SSH ist hier nur für die Verbindung im lokalen Netzwerk gedacht.“

1. Öffne die Systemsteuerung.
2. Gehe zu Terminal & SNMP.
3. Setze den Haken bei SSH-Dienst aktivieren.
4. Port bleibt auf 22.
5. Klicke Übernehmen.

Schritt 1.3: Per SSH verbinden

Jetzt verbindest du dich zum ersten Mal mit deiner DiskStation über das Terminal. Keine Sorge – das ist kein schwarzer Bildschirm aus einem Hacker-Film. Es ist nur ein Textfenster, in dem du Befehle tippst.

Auf dem Mac (Programme → Dienstprogramme → Terminal):

ssh dein-benutzername@deine_NAS_IP

Auf Windows (Windows-Taste, cmd, Enter):

ssh dein-benutzername@deine_NAS_IP

Die IP-Adresse deiner DiskStation findest du in DSM unter Systemsteuerung → Netzwerk → Netzwerkschnittstelle.

Schritt 1.4: Ordner anlegen

Nach dem ersten Login wechselst du zu root. Ohne root-Rechte darfst du keine Ordner in /volume1/ anlegen.

Ulf: „Root, ist das der Kapitän des Systems?“
Tanja: „Root ist der Admin aller Admins. Auf einem Linux-System darf root alles. Wir brauchen root jetzt für die Ordner – danach läuft der Container aber bewusst nicht als root.“

Nachdem du per SSH verbunden bist:

# Zu root wechseln
sudo -i

# Ordner erstellen
mkdir -p /volume1/docker/openclaw/config
mkdir -p /volume1/docker/openclaw/workspace

# Rechte setzen
chown -R 1000:1000 /volume1/docker/openclaw
chmod -R 755 /volume1/docker/openclaw

 Warum 1000:1000? Das ist die User-ID, unter der der Container später läuft. Indem du die Ordner schon jetzt auf diesen Nutzer setzt, hat der Container die nötigen Schreibrechte – ohne Administratorrechte zu benötigen.

Soll-Ergebnis – so prüfst du, ob es geklappt hat:

ls -la /volume1/docker/openclaw/

Du solltest sehen, dass beide Unterordner (config, workspace) dem Benutzer mit UID 1000 gehören:

drwxr-xr-x  1000 users  config/
drwxr-xr-x  1000 users  workspace/

Schritt 1.5: compose.yaml erstellen

Jetzt wird es konkret. Die compose.yaml ist das Herzstück: Hier steht alles drin, was der Container braucht – Berechtigungen, Netzwerk, Volumes, Sicherheitseinstellungen.

Ulf: „Compose.yaml – ist das wie der Aufstellungszettel vor dem Anpfiff?“
Tanja: „Genau so! Stell dir vor: Der Trainer schreibt auf, wer spielen darf, welche Position er hat, und was verboten ist. Genau das macht die compose.yaml für deinen Container.“
Bernd: „Ich mach das alles ohne Compose-Datei. docker run mit zehn Flags ist viel flexibler.“
Tanja: „Und wenn du beim nächsten Neustart die Flags nicht mehr weißt?“
Bernd: „…dann fang ich halt neu an.“

Immer noch in der SSH-Sitzung als root. Kopiere den kompletten Block und füge ihn im Terminal ein:

cat > /volume1/docker/openclaw/compose.yaml << 'DATEIENDE'
services:
  openclaw-gateway:
    image: ghcr.io/openclaw/openclaw:latest
    container_name: openclaw-gateway
    restart: unless-stopped
    user: "1000:1000"
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
      - /run
    pids_limit: 256
    dns:
      - 1.1.1.1
      - 8.8.8.8
    networks:
      - openclaw-isolated
    ports:
      - "18789:18789"
    volumes:
      - /volume1/docker/openclaw/config:/home/node/.openclaw
      - /volume1/docker/openclaw/workspace:/home/node/.openclaw/workspace
    environment:
      - HOME=/home/node
      - TERM=xterm-256color
      - NODE_ENV=production
    healthcheck:
      test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:18789/ >/dev/null 2>&1 || exit 1"]
      interval: 60s
      timeout: 10s
      retries: 3
      start_period: 30s
    init: true
    command:
      [
        "node",
        "dist/index.js",
        "gateway",
        "--bind",
        "lan",
        "--port",
        "18789",
      ]

  openclaw-cli:
    image: ghcr.io/openclaw/openclaw:latest
    container_name: openclaw-cli
    user: "1000:1000"
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    network_mode: "service:openclaw-gateway"
    volumes:
      - /volume1/docker/openclaw/config:/home/node/.openclaw
      - /volume1/docker/openclaw/workspace:/home/node/.openclaw/workspace
    environment:
      - HOME=/home/node
      - TERM=xterm-256color
      - NODE_ENV=production
    stdin_open: true
    tty: true
    init: true
    entrypoint: ["node", "dist/index.js"]
    profiles:
      - cli

networks:
  openclaw-isolated:
    driver: bridge
    ipam:
      config:
        - subnet: 172.30.0.0/24
          gateway: 172.30.0.1
DATEIENDE

Was bedeuten die wichtigsten Einstellungen?

Soll-Ergebnis – Datei validieren:

docker compose -f /volume1/docker/openclaw/compose.yaml config

docker compose config validiert die Datei und gibt sie normalisiert aus. Das ist verlässlicher als ein reines cat. Du solltest eine vollständige, fehlerfreie YAML-Ausgabe sehen. Eine Fehlermeldung wie mapping values are not allowed here weist auf Einrückungsfehler hin – dann den cat-Block aus dem vorigen Schritt nochmals einfügen.

Schritt 1.6: OpenClaw Onboarding durchführen

Das Onboarding ist ein interaktiver Einrichtungsassistent. Er fragt dich nach API-Key, Modell und Kommunikationskanal – und schreibt danach eine fertige Konfigurationsdatei ins config/-Verzeichnis. Dieser Schritt muss per SSH erledigt werden, weil der Assistent eine direkte Terminalverbindung braucht.

Bernd: „Ich hab einfach das Image gezogen und gestartet. Lief sofort.“
Tanja: „Und dann?“
Bernd: „Dann kam eine Fehlermeldung. Aber das ist normal.“
Tanja: „Das ist nicht normal. Das ist fehlende Konfiguration. Deshalb machen wir das Onboarding vor dem ersten Start.“

cd /volume1/docker/openclaw
docker compose run --rm openclaw-cli onboard

Der Assistent führt dich durch folgende Schritte:

Schritt 1 – Sicherheitshinweise bestätigen

Eingabe: Yes

Schritt 2 – Onboarding-Modus wählen

Eingabe: QuickStart
QuickStart ist der geführte Einrichtungspfad für neue Installationen. Er fragt nur das Nötigste ab und überspringt erweiterte Konfigurationsoptionen.

Schritt 3 – KI-Anbieter und Modell wählen

Ulf: „Welchen Provider soll ich nehmen? Ist das wie die Wahl zwischen Bundesliga und Champions League?“
Tanja: „Die Wahl beeinflusst Qualität und Kosten. Hier ein Überblick:“

(Stand Februar 2026)

Für einen Chat-Assistenten im Heimgebrauch reden wir bei beiden Anbietern eher über Cent-Beträge pro Gespräch. Der Unterschied ist in der Praxis gering.

Empfehlung: Nimm Anthropic, weil Claude bei längeren Gesprächen und komplexen Anweisungen qualitativ oft stärker ist. Wähle Haiku wenn du sparen möchtest, Sonnet wenn du Qualität willst. Du kannst das jederzeit wechseln. Falls dir vor allem der günstigste Preis wichtig ist: OpenAI mit GPT-4.1 mini oder nano.

Falls du noch keinen API-Key hast: Für Claude gehe auf console.anthropic.com. Falls du das gerade nicht einrichten willst: Wähle Back, dann Skip for now. Du kannst den Provider später nachrüsten:

cd /volume1/docker/openclaw
docker compose run --rm openclaw-cli configure

Schritt 4 – Authentifizierungsmethode

Eingabe: Anthropic API key

Schritt 5 – API-Key eingeben

Deinen sk-ant-...-Schlüssel eingeben.

Schritt 6 – Standardmodell bestätigen

Eingabe: Keep current (claude-sonnet-4-6)

Schritt 7 – Kommunikationskanal wählen

Eingabe: Telegram (Bot API)
Telegram ist der empfohlene Kanal für die Smartphone-Nutzung. Du hast auch Synology Chat als Option. Falls du dir unsicher bist: Wähle Skip for now – Kanäle lassen sich jederzeit nachrüsten.

Schritt 8 – Telegram Bot einrichten

Falls du Telegram gewählt hast, brauchst du einen Bot-Token:

1. Öffne Telegram und suche den Kontakt @BotFather.
2. Schreibe ihm: /newbot
3. Vergib einen Anzeigenamen (frei wählbar, z.B. „MeinOpenClaw“) und einen Benutzernamen (muss einmalig auf Telegram sein, muss auf bot enden, z.B. meinopenclaw_bot).
4. BotFather gibt dir einen Bot-Token – eine lange Zeichenkette. Den gibst du jetzt im Onboarding-Assistenten ein.

Schritt 9 – Skills konfigurieren

Eingabe: No
Skills sind optionale Zusatzmodule (Browser-Automation, Kalender, Notizen etc.). Sie laden jeweils eigene Software nach und können bei unserem schreibgeschützten Container Konflikte verursachen. Die Kernfunktion – per Telegram mit Claude chatten – funktioniert ohne Skills. Einzelne Skills lassen sich später gezielt nachrüsten.

Schritte 10 – 15 Weitere API-Keys (Google Places, Gemini, Notion, OpenAI-Image, Whisper, ElevenLabs)

Alle mit No beantworten. Das sind optionale Skills für spezielle Anwendungsfälle.

Schritt 16 – Hooks aktivieren

Eingabe: Skip for now
Hooks sind Automatisierungen, die bei bestimmten Ereignissen ausgelöst werden. Für den Start nicht nötig.

Das Onboarding ist abgeschlossen!

 Wichtig: Schreibe dir den Gateway Token auf, der am Ende des Onboardings angezeigt wird. Er sieht so aus:

#token=2bbea678f.........................67003d38

Du brauchst ihn für die optionale Web-Oberfläche. Schreib ihn jetzt auf.

Bevor du den Gateway zum ersten Mal startest, ein notwendiger Konfigurationsschritt. Ohne ihn startet der Gateway mit einem Fehler:

cd /volume1/docker/openclaw
docker compose run --rm openclaw-cli config set gateway.controlUi.allowedOrigins '["http://localhost:18789"]'

Was ist allowedOrigins? Das ist eine Sicherheitseinstellung, die festlegt, von welchen Adressen aus die Control UI – die Web-Oberfläche des Gateways – aufgerufen werden darf. Ohne diese Freigabe verweigert OpenClaw den Zugriff, weil die Web-UI über localhost (per SSH-Tunnel) erreichbar ist, was standardmäßig nicht erlaubt ist.

Schritt 1.7: Container starten

Variante A: Über Container Manager

1. Öffne Container Manager in der DiskStation-Oberfläche.
2. Gehe zu Projekt.
3. Klicke Erstellen.
4. Projektname: openclaw
5. Pfad: /volume1/docker/openclaw
6. Container Manager zeigt die compose.yaml an → Weiter → Erstellen.

Der erste Download des Images dauert erfahrungsgemäß rund 8 Minuten. Wenn du Container Manager verwendest und das Projekt vor dem Onboarding erstellt hast: Container Manager startet das Projekt sofort nach dem Erstellen. Der Container meldet dann „Missing config“ und beendet sich. Das ist kein Fehler – stoppe das Projekt, führe das Onboarding durch (Schritt 1.6), und starte dann neu.

Variante B: Per SSH

cd /volume1/docker/openclaw
docker compose up -d openclaw-gateway

Soll-Ergebnis – so prüfst du, ob der Container läuft:

# Läuft der Container?
docker ps --filter name=openclaw-gateway

# Was sagen die Logs?
docker logs openclaw-gateway --tail 50

Was du sehen solltest:

[gateway] listening on ws://0.0.0.0:18789
[telegram] starting provider (@dein_botname)

Was normale Erststart-Meldungen sind (kein Fehler):

• [warn] pids_limit discarded – der Synology-Kernel unterstützt dieses Feature nicht, es wird ignoriert.
  Was ein echter Fehler ist:
• Missing config → Onboarding (Schritt 1.6) nicht abgeschlossen.
• non-loopback Control UI requires allowedOrigins → den config set-Befehl am Ende von Schritt 1.6 nachholen.
• Error: EACCES: permission denied → Ordnerrechte prüfen (chown -R 1000:1000 /volume1/docker/openclaw).

Schritt 1.8: Telegram testen

Beim allerersten Mal antwortet dein Bot mit einem Pairing-Code. Pairing bedeutet: Du bestätigst einmalig, dass dieses Gerät (dein Smartphone) berechtigt ist, mit dem Bot zu chatten. Ohne diese Bestätigung antwortet der Bot nicht.
Schreibe dem Bot irgendetwas in Telegram. Er antwortet mit einem Code. Dann in der SSH-Sitzung:

cd /volume1/docker/openclaw
docker compose run --rm openclaw-cli pairing approve telegram <CODE>

Den Code aus der Telegram-Nachricht einsetzen. Danach funktioniert der Chat ganz normal.
Soll-Ergebnis: Der Bot antwortet auf deine nächste Nachricht mit einer sinnvollen KI-Antwort.

Teil 2: Optionale Erweiterungen

Die Grundinstallation läuft. OpenClaw antwortet per Telegram. Was jetzt kommt, ist optional – aber empfehlenswert.

Optional A: Web-Oberfläche per SSH-Tunnel

Zusätzlich zu Telegram gibt es eine browserbasierte Oberfläche. Sie ist bewusst nicht direkt im Netzwerk erreichbar – der Zugriff läuft über einen SSH-Tunnel. Das ist kein Umweg, sondern Absicht: Die Web-UI soll nicht offen im Heimnetz hängen.

SSH-Tunnel öffnen (auf dem Mac, neues Terminalfenster):

ssh -L 18789:127.0.0.1:18789 dein-benutzername@IP_der_Diskstation

Das Kommando leitet deinen lokalen Port 18789 verschlüsselt durch SSH an Port 18789 auf der DiskStation weiter. Solange dieses Terminalfenster offen ist, funktioniert der Tunnel.

Dann im Browser aufrufen (eigenen Token aus Schritt 1.6 einsetzen):

http://localhost:18789#token=2bbea678f.........................67003d38

Verwende localhost, nicht 127.0.0.1. Das ist kein Tippfehler – es macht technisch einen Unterschied bei der Erkennung des Tokens. Der Token muss direkt hinter dem # stehen, ohne Leerzeichen.

Falls „channel: open failed: administratively prohibited“ kommt:

SSH Port-Forwarding ist auf der DiskStation deaktiviert. Einmalig freischalten (andere Terminal-Sitzung, als root):

sudo -i
echo "AllowTcpForwarding yes" >> /etc/ssh/sshd_config
sed -i '85s/AllowTcpForwarding no/AllowTcpForwarding yes/' /etc/ssh/sshd_config
systemctl restart sshd

Falls systemctl nicht verfügbar ist:

synosystemctl restart sshd

Dann SSH-Tunnel neu starten und wieder im Browser aufrufen.
Falls „pairing required“ angezeigt wird:
Der Browser muss einmalig gepairt werden – genau wie Telegram in Schritt 1.8. Offene Pairing-Codes anzeigen:

sudo docker exec -it openclaw-gateway node /app/openclaw.mjs devices list

Den Code aus der Spalte „Pending → Request → Code“ notieren und bestätigen:

sudo docker exec -it openclaw-gateway node /app/openclaw.mjs devices approve DEIN_CODE

Optional B: Netzwerk-Isolation härten

Bisher kann der Container theoretisch alle Geräte in deinem Heimnetz erreichen – deinen Router, andere NAS-Geräte, Smart-Home-Systeme. Für einen KI-Agenten, der API-Anfragen ins Internet schickt, ist das ein unnötiges Risiko.

Bernd: „Ich versteh nicht, warum das nötig sein soll. Die Fritzbox macht das doch schon.“
Tanja: „Deine Fritzbox filtert Verbindungen von außen nach innen. Verbindungen vom Container in dein Netz sieht sie gar nicht – die laufen intern auf der NAS. Dafür brauchen wir iptables-Regeln direkt auf der DiskStation.“
Ulf: „iptables – ist das wie die Schiedsrichterregeln?“
Tanja: „Perfekter Vergleich! iptables ist das Regelwerk, das entscheidet, welche Datenpakete durchdürfen und welche direkt abgepfiffen werden.“
Ulf: „Und DOCKER-USER?“
Tanja: „DOCKER-USER ist die iptables-Kette, die Docker speziell für benutzerdefinierte Filterregeln vor der Container-Weiterleitung berücksichtigt. Wir schreiben unsere Regeln dorthin, damit sie Docker nicht überschreibt.“

Die zusätzlichen iptables-Regeln in diesem Abschnitt reduzieren das Risiko, dass ein kompromittierter Container interne Geräte im Heimnetz erreicht. Sie ersetzen jedoch keine VM-Isolation, kein Patch-Management und keine sorgfältige Prüfung der eingesetzten Container-Images.

Schritt B.1: Firewall-Skript erstellen

Das Skript arbeitet in drei Phasen:

• Phase 1: Löscht eigene Regeln, falls das Skript schon einmal gelaufen ist.
• Phase 2: Baut IPv4-Regeln neu auf.
• Phase 3: Ergänzt IPv6-Regeln.
  Das Skript ist idempotent – du kannst es beliebig oft ausführen, es baut immer sauber neu auf.

cat > /volume1/docker/openclaw/openclaw-firewall.sh << 'DATEIENDE'
#!/bin/bash
# =============================================================================
# openclaw-firewall.sh
# Netzwerk-Isolations-Skript für OpenClaw auf Synology DS1621+
# =============================================================================
# Kompatibel mit Synology DSM iptables 1.8.x (kein comment-Modul verfügbar).
#
# Blockiert ausgehenden Traffic vom OpenClaw-Container zu allen privaten
# und reservierten IPv4-Netzen. Internet-Zugang bleibt erlaubt.
# DNS läuft über öffentliche Server (1.1.1.1 / 8.8.8.8, gesetzt in
# docker-compose.yml), da der Router-DNS durch die Regeln blockiert wird.
#
# Idempotent: Löscht zuerst alle eigenen Regeln (per exakter Spezifikation),
# dann baut es die Regeln in definierter Reihenfolge neu auf.
# Kann beliebig oft ausgeführt werden.
#
# IPv6: Blockiert ULA (fc00::/7) und Link-Local (fe80::/10) global für den
# gesamten Docker-Forward-Traffic, da dem Container kein festes IPv6-Präfix
# zugewiesen ist. Falls du später andere Container mit IPv6 betreiben willst,
# diese Regeln anpassen.
#
# Verwendung:
#   Als Boot-Aufgabe im Synology Aufgabenplaner einrichten:
#   bash /volume1/docker/openclaw/openclaw-firewall.sh
# =============================================================================

sleep 30

DOCKER_SUBNET="172.30.0.0/24"   # Muss mit compose.yaml übereinstimmen

# ─────────────────────────────────────────────────────────────────────────────
# Phase 1: Alle eigenen Regeln entfernen (exakte Spezifikation)
# ─────────────────────────────────────────────────────────────────────────────

# IPv4
iptables -D DOCKER-USER -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT 2>/dev/null
iptables -D DOCKER-USER -s "$DOCKER_SUBNET" -d 192.168.0.0/16 -j DROP 2>/dev/null
iptables -D DOCKER-USER -s "$DOCKER_SUBNET" -d 10.0.0.0/8 -j DROP 2>/dev/null
iptables -D DOCKER-USER -s "$DOCKER_SUBNET" -d 172.16.0.0/12 -j DROP 2>/dev/null
iptables -D DOCKER-USER -s "$DOCKER_SUBNET" -d 169.254.0.0/16 -j DROP 2>/dev/null
iptables -D DOCKER-USER -s "$DOCKER_SUBNET" -d 100.64.0.0/10 -j DROP 2>/dev/null

# IPv6
ip6tables -D DOCKER-USER -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT 2>/dev/null
ip6tables -D DOCKER-USER -d fc00::/7 -j DROP 2>/dev/null
ip6tables -D DOCKER-USER -d fe80::/10 -j DROP 2>/dev/null

# ─────────────────────────────────────────────────────────────────────────────
# Phase 2: IPv4-Regeln in DOCKER-USER aufbauen
# ─────────────────────────────────────────────────────────────────────────────

# Position 1: Antwortpakete von erlaubten Verbindungen durchlassen
iptables -I DOCKER-USER 1 \
  -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# Position 2-6: Private und reservierte Netze blockieren
iptables -I DOCKER-USER 2 \
  -s "$DOCKER_SUBNET" -d 192.168.0.0/16 -j DROP

iptables -I DOCKER-USER 3 \
  -s "$DOCKER_SUBNET" -d 10.0.0.0/8 -j DROP

iptables -I DOCKER-USER 4 \
  -s "$DOCKER_SUBNET" -d 172.16.0.0/12 -j DROP

iptables -I DOCKER-USER 5 \
  -s "$DOCKER_SUBNET" -d 169.254.0.0/16 -j DROP

iptables -I DOCKER-USER 6 \
  -s "$DOCKER_SUBNET" -d 100.64.0.0/10 -j DROP

# RETURN: nur hinzufügen wenn keiner existiert
if ! iptables -L DOCKER-USER -n 2>/dev/null | grep -q "RETURN"; then
  iptables -A DOCKER-USER -j RETURN
fi

# ─────────────────────────────────────────────────────────────────────────────
# Phase 3: IPv6-Regeln (falls DOCKER-USER in ip6tables existiert)
# ─────────────────────────────────────────────────────────────────────────────

if ip6tables -L DOCKER-USER -n >/dev/null 2>&1; then
  ip6tables -I DOCKER-USER 1 \
    -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

  ip6tables -I DOCKER-USER 2 \
    -d fc00::/7 -j DROP

  ip6tables -I DOCKER-USER 3 \
    -d fe80::/10 -j DROP

  if ! ip6tables -L DOCKER-USER -n 2>/dev/null | grep -q "RETURN"; then
    ip6tables -A DOCKER-USER -j RETURN
  fi
fi

# ─────────────────────────────────────────────────────────────────────────────
# Ausgabe
# ─────────────────────────────────────────────────────────────────────────────
logger "openclaw-firewall: DOCKER-USER Regeln aktiv fuer $DOCKER_SUBNET"

echo ""
echo "========================================"
echo " OpenClaw Netzwerk-Isolation aktiviert"
echo "========================================"
echo ""
echo "IPv4 DOCKER-USER:"
iptables -L DOCKER-USER -n -v --line-numbers
echo ""

if ip6tables -L DOCKER-USER -n >/dev/null 2>&1; then
  echo "IPv6 DOCKER-USER:"
  ip6tables -L DOCKER-USER -n -v --line-numbers
  echo ""
fi

echo "Erwartete Reihenfolge:"
echo "  1  ACCEPT     ctstate RELATED,ESTABLISHED"
echo "  2  DROP       172.30.0.0/24 -> 192.168.0.0/16"
echo "  3  DROP       172.30.0.0/24 -> 10.0.0.0/8"
echo "  4  DROP       172.30.0.0/24 -> 172.16.0.0/12"
echo "  5  DROP       172.30.0.0/24 -> 169.254.0.0/16"
echo "  6  DROP       172.30.0.0/24 -> 100.64.0.0/10"
echo "  7  RETURN"
DATEIENDE

Dann das Skript ausführbar machen:

# Zu root wechseln
sudo -i

chmod +x /volume1/docker/openclaw/openclaw-firewall.sh

Welche Netze werden blockiert?

Hinweis IPv6: Die IPv6-Regeln gelten für den gesamten Docker-Forward-Traffic auf der DiskStation, nicht nur für OpenClaw. Falls du später andere Container mit IPv6 betreiben willst, müssen diese Regeln angepasst werden.

Schritt B.2: Firewall als Boot-Aufgabe einrichten

Die iptables-Regeln sind flüchtig – ein Neustart löscht sie. Damit sie nach jedem Hochfahren automatisch aktiv sind:

1. Öffne: Systemsteuerung → Dienste → Aufgabenplaner.
2. Klicke Erstellen → Ausgelöste Aufgabe → Benutzerdefiniertes Skript.
3. Reiter Allgemein:
   • Aufgabe: OpenClaw Netzwerk-Isolation
   • Benutzer: root
   • Ereignis: Hochfahren
4. Reiter Aufgabeneinstellungen: In das Textfeld eingeben:

   bash /volume1/docker/openclaw/openclaw-firewall.sh

5. Klicke OK und bestätige die Warnung.

Schritt B.3: Firewall sofort aktivieren

bash /volume1/docker/openclaw/openclaw-firewall.sh

Soll-Ergebnis – Regeln prüfen:

iptables -L DOCKER-USER -n -v --line-numbers

Erwartete Ausgabe:

num   target     prot  source           destination
1     ACCEPT     all   0.0.0.0/0        0.0.0.0/0        ctstate RELATED,ESTABLISHED
2     DROP       all   172.30.0.0/24    192.168.0.0/16
3     DROP       all   172.30.0.0/24    10.0.0.0/8
4     DROP       all   172.30.0.0/24    172.16.0.0/12
5     DROP       all   172.30.0.0/24    169.254.0.0/16
6     DROP       all   172.30.0.0/24    100.64.0.0/10
7     RETURN     all   0.0.0.0/0        0.0.0.0/0

Falls die Reihenfolge nicht stimmt: Skript nochmals ausführen – es räumt zuerst auf und baut sauber neu.

Isolation testen:

# Internet muss funktionieren:
sudo docker exec openclaw-gateway node -e "fetch('https://api.telegram.org').then(r=>console.log('OK',r.status)).catch(e=>console.log('FEHLER',e.message))"

# Heimnetz muss blockiert sein:
sudo docker exec openclaw-gateway node -e "fetch('http://192.168.2.1',{signal:AbortSignal.timeout(3000)}).then(r=>console.log('OFFEN!',r.status)).catch(e=>console.log('BLOCKIERT (gut!)'))"

# Firewall-Regeln prüfen:
sudo iptables -L DOCKER-USER -n -v --line-numbers

Erwartetes Ergebnis: Internet antwortet mit OK 200, Heimnetz meldet BLOCKIERT (gut!).

Optional C: Playwright-Browser nachrüsten

Bisher kommuniziert OpenClaw über APIs und Text. Mit einem eingebetteten Playwright-Browser kann er auch echte Webseiten laden, scrollen, Formulare ausfüllen und JavaScript-Rendering nutzen.

Ulf: „OpenClaw soll selbst surfen können? Wie ein Libero, der plötzlich stürmt?“
Tanja: „Genau so! Das LLM plant, Playwright führt aus. OpenClaw kann damit Inhalte aus dynamischen Seiten lesen, die über einfache HTTP-Requests nicht zugänglich sind.“
Bernd: „Ich hab einfach den System-Chromium genommen. Lief nicht. Dreimal probiert. Nie funktioniert.“
Tanja: „Deshalb bringt man die Browser-Binaries mit dem Container mit. Dann klappt es reproduzierbar – immer.“

Ein Playwright-Browser im Docker-Container bringt seine eigenen Browser-Binaries und Abhängigkeiten mit. Das vermeidet Konflikte mit System-Bibliotheken und Versionsinkompatibilitäten.

Schritt C.1: Dockerfile anlegen

Erstelle /volume1/docker/openclaw/Dockerfile:

FROM ghcr.io/openclaw/openclaw:latest

USER root

# Systembibliotheken für Chromium / Playwright
RUN apt-get update && apt-get install -y \
    libnspr4 \
    libnss3 \
    libatk1.0-0 \
    libatk-bridge2.0-0 \
    libcups2 \
    libdrm2 \
    libxkbcommon0 \
    libxcomposite1 \
    libxdamage1 \
    libxfixes3 \
    libxrandr2 \
    libgbm1 \
    libasound2 \
    ca-certificates \
    wget \
    && rm -rf /var/lib/apt/lists/*

USER node

Dann in der compose.yaml bei beiden Diensten (openclaw-gateway und openclaw-cli) die image-Zeile ersetzen:

# Vorher:
image: ghcr.io/openclaw/openclaw:latest

# Nachher:
build:
  context: /volume1/docker/openclaw
  dockerfile: Dockerfile

Schritt C.2: Chromium installieren

cd /volume1/docker/openclaw

sudo docker compose -p openclaw run --rm --entrypoint sh \
  -e PLAYWRIGHT_BROWSERS_PATH=/home/node/.openclaw/workspace/.browser \
  openclaw-cli -c 'mkdir -p /home/node/.openclaw/workspace/.browser && \
  node /app/node_modules/playwright-core/cli.js install chromium'

Soll-Ergebnis – Installation prüfen:

sudo docker exec -it openclaw-gateway sh -c 'ls -la /home/node/.openclaw/workspace/.browser'

Du solltest einen Ordner wie chromium-1208 sehen. Dann den Browser-Pfad testen:

sudo docker exec -it openclaw-gateway sh -c '/home/node/.openclaw/workspace/.browser/chromium-1208/chrome-linux64/chrome --version'

Eine ausgegebene Chrome-Versionsnummer bedeutet: Chromium ist korrekt installiert.
Der Ordnername (z.B. chromium-1208) hängt von der Playwright-Version ab. Prüfe ihn immer mit ls – er kann sich bei Updates ändern.

Schritt C.3: Browser-Pfad in openclaw.json setzen

Öffne /volume1/docker/openclaw/config/openclaw.json und füge den browser-Block ein:

"browser": {
  "enabled": true,
  "defaultProfile": "openclaw",
  "headless": true,
  "noSandbox": true,
  "executablePath": "/home/node/.openclaw/workspace/.browser/chromium-1208/chrome-linux64/chrome",
  "profiles": {
    "openclaw": {
      "cdpPort": 18800,
      "color": "#FF4500"
    }
  }
}

Schritt C.4: Testen

sudo docker exec -it openclaw-gateway sh -c '/home/node/.openclaw/workspace/.browser/chromium-1208/chrome-linux64/chrome --version'

Dann in OpenClaw (per Telegram oder Web-UI):

Verwende das Browser-Profil "openclaw" und öffne https://example.com.

Wenn OpenClaw antwortet und den Seiteninhalt beschreibt, ist alles korrekt eingerichtet.

Nützliche Befehle – der Spickzettel

Ulf: „Kann ich die ganzen Befehle irgendwo nachschlagen, ohne die ganze Anleitung nochmal zu lesen?“
Tanja: „Genau dafür gibt es diese Tabelle.“

Fehlerbehebung

Hier sind die häufigsten Probleme und ihre Lösungen. Bernd hat mindestens drei davon bereits persönlich erlebt.

Container startet nicht oder beendet sich sofort

Symptom: Container Manager meldet „unerwartet beendet“, Logs zeigen Fehler.
Prüfen:

docker logs openclaw-gateway --tail 50

Web-Oberfläche nicht erreichbar

Symptom: Browser zeigt leere Seite, Verbindung abgelehnt oder „pairing required“.
Prüfen:

docker ps --filter name=openclaw-gateway
docker logs openclaw-gateway --tail 50

Telegram antwortet nicht

Symptom: Bot bleibt stumm, keine Antwort auf Nachrichten.
Prüfen:

docker logs openclaw-gateway --tail 20

Internet-Test:

docker exec openclaw-gateway node -e "fetch('https://api.telegram.org').then(r=>console.log('OK',r.status)).catch(e=>console.log('FEHLER',e.message))"

Firewall-Regeln fehlen nach DSM-Update

Symptom: Internet-Zugriff vom Container ins Heimnetz ist wieder möglich.
Prüfen:

sudo iptables -L DOCKER-USER -n -v --line-numbers

Falls die Liste leer oder unvollständig ist:

sudo bash /volume1/docker/openclaw/openclaw-firewall.sh

Außerdem prüfen, ob die Boot-Aufgabe noch aktiv ist: Systemsteuerung → Aufgabenplaner.

„Read-only file system“

Symptom: Fehlermeldung bei einem Skill oder Modul, das schreiben will.
Temporäre Lösung: In der compose.yaml diese Zeile auskommentieren, Projekt neu starten:

# read_only: true

„non-loopback Control UI requires allowedOrigins“

Der Konfigurationsschritt aus Schritt 4.2 wurde übersprungen. Nachholen:

cd /volume1/docker/openclaw
docker compose run --rm openclaw-cli config set gateway.controlUi.allowedOrigins '["http://localhost:18789"]'

„Permission denied“

Die Ordner gehören dem falschen Benutzer. Beheben mit:

sudo chown -R 1000:1000 /volume1/docker/openclaw

DNS / kein Internet

Prüfe ob dns: 1.1.1.1 und dns: 8.8.8.8 in der compose.yaml vorhanden sind. Dann testen:

docker exec openclaw-gateway node -e "fetch('https://api.telegram.org').then(r=>console.log('OK',r.status)).catch(e=>console.log('FEHLER',e.message))"

„PIDs limit discarded“ Warnung

Harmlos. Der Synology-Kernel unterstützt das pids_limit-Feature nicht. Die Warnung kann ignoriert werden.

Wartung und Updates

Container aktualisieren:

cd /volume1/docker/openclaw
docker compose pull
docker compose down
docker compose up -d openclaw-gateway

Nach DSM-Updates: Firewall-Regeln prüfen und ggf. neu laden (siehe Fehlerbehebung oben).
Konfiguration ändern (Modell, API-Key, Kanäle):

cd /volume1/docker/openclaw
docker compose run --rm openclaw-cli configure

Fertig!

Tanja: „Das war’s. OpenClaw läuft, die Firewall ist aktiv, Telegram ist verbunden. Du hast einen abgesicherten AI-Agenten auf deiner Heimnetz-NAS.“
Ulf: „Und Bernd? Hat er seine VM noch?“
Bernd: „Meine VM läuft übrigens auch. Aber der RAM war dann weg und das DSM-Update hat dann… ähm. Das ist eine andere Geschichte.“
Tanja: „…war die VM weg. Ich weiß, Bernd. Ich weiß.“

Du hast in dieser Anleitung folgendes aufgebaut:

• Container Manager und SSH auf der DiskStation aktiviert
• Ordnerstruktur für OpenClaw angelegt
• compose.yaml mit vollständigen Sicherheitseinstellungen erstellt und validiert
• OpenClaw per interaktivem Onboarding konfiguriert
• Telegram-Bot verbunden und gepairt

Optional ergänzt:

• Web-Oberfläche per SSH-Tunnel zugänglich gemacht
• Netzwerk-Isolation per iptables eingerichtet und als Boot-Aufgabe gespeichert
• Playwright-Browser installiert

Das Ganze läuft auf deiner Synology NAS zuhause, ohne Cloud-Abhängigkeiten für die Infrastruktur. Als Telefonanlage dient die Fritz!Box 7590, als Telefonie-Server Asterisk im Docker-Container, als KI-Gehirn die OpenAI Realtime API. Die Automatisierung übernimmt n8n.

Klingt komplex? An einigen Stellen ist es das auch, diese Anleitung führt dich aber Schritt für Schritt durch. Mit SSH-Grundkenntnissen und etwas Geduld ist das Ergebnis nachbaubar.

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen.

Tanja ist die IT-Expertin. Sie weiß, wie es funktioniert, erklärt geduldig und strukturiert und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.
Bernd ist der selbsternannte „Experte“, der alles besser weiß – und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.
Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung, dafür ist Tanja da.

„Und… Action!“

Donnerstagabend. Büro. Ulf starrt auf sein Handy.
Ulf: „Schon wieder eine verpasste Anruf-Benachrichtigung. Keine Nachricht. Keine Nummer. Nix.“
Bernd ohne aufzuschauen: „Ruf zurück“,
Ulf: „Ich kenn die Nummer nicht. Und wenn ich zurückruf, ist besetzt. Oder niemand geht ran. Oder — — –„
Bernd: „Ich hab das gelöst, Anrufbeantworter. Ganz klassisch. ‚Hinterlassen Sie eine Nachricht nach dem Piepton.‘ Fertig.“
Tanja legt ihren Stift hin. „Und wie viele Leute hinterlassen heutzutage noch Nachrichten auf einem Anrufbeantworter?“
Bernd überlegt. „Na… Oma.“
Tanja: „Genau.“

1 Technische Beschreibung

1.1 Was macht dieses Projekt?

Ulf fragt: „Also die KI geht ans Telefon und redet mit dem Anrufer?“,
Tanja: „Genau, sie begrüßt ihn, fragt nach seinem Namen, hört sich das Anliegen an, klärt wie dringend es ist und verabschiedet sich. Alles auf Deutsch, alles in natürlicher Sprache.“
Ulf: „Und dann?“
Tanja: „Und dann bekommst du eine E-Mail mit dem kompletten Gesprächsverlauf. Wer hat angerufen, was wollte die Person, wie dringend war es.“
Bernd lehnt sich vor: „Ich hätte da einfach einen billigen Anrufbeantworter hingestellt.“
Tanja: „Hattest du. Der hat nichts aufgenommen, weil der Piepton zu leise war.“
Bernd sagt nichts mehr.

Der KI-Assistent übernimmt Anrufe auf deiner Festnetznummer vollautomatisch. Er begrüßt den Anrufer freundlich, fragt nach Name und Anliegen, klärt die Dringlichkeit und verabschiedet sich in natürlichem Deutsch, ohne roboterhafte Pausen. Wenige Sekunden nach dem Auflegen landet eine vollständige Zusammenfassung in deinem Posteingang.

1.2 Warum diese Architektur?

Ulf: „Moment, kann die Fritz!Box nicht einfach direkt mit OpenAI reden? Warum brauchen wir drei Systeme dazwischen?“
Tanja: „Gute Frage. Die Fritz!Box spricht SIP – das ist das klassische Telefonie-Protokoll. OpenAI spricht WebSocket – das ist ein modernes Streaming-Protokoll. Die beiden verstehen sich nicht direkt. Wir brauchen einen Übersetzer.“
Ulf: „Asterisk?“
Tanja: „Asterisk ist der Übersetzer auf der Telefonie-Seite. Und das Node.js-Relay ist die Brücke zu OpenAI. Zusammen bilden sie den Verbindungskanal.“
Ulf: „Das ist wie beim Fußball, die Fritz!Box ist der Torwart, der den Ball abschlägt. Asterisk ist der defensive Mittelfeldspieler, der ihn annimmt. Und das Relay ist der Spielmacher, der ihn zu OpenAI weiterleitet.“
Kurze Stille.
Tanja: „Das ist, überraschend präzise.“

Die Fritz!Box ist ein reines Telefon-Gateway – sie versteht kein WebSocket, das OpenAI für die Realtime API benötigt. Asterisk übernimmt daher die Rolle des Vermittlers: Er nimmt das klassische SIP/RTP-Telefonsignal entgegen und reicht es an das Node.js-Relay weiter. Das Relay öffnet seinerseits eine WebSocket-Verbindung zu OpenAI und streamt das Audio bidirektional.
Der vollständige Signalweg:

Telefon → FritzBox (SIP) → Asterisk (Docker) → [ARI/Node.js Relay] → WebSocket → api.openai.com:443

OpenAI übernimmt dabei die komplette Gesprächsintelligenz: Spracherkennung, KI-Antworten und Text-to-Speech in einem einzigen Modell mit sehr niedriger Latenz. Nach dem Gespräch sendet das Relay das Transkript per Webhook an n8n, das daraus eine formatierte E-Mail erstellt.

1.3 Technologie-Stack

1.4 Voraussetzungen

Bevor du loslegst – ein ehrlicher Check. Du brauchst:
Hardware:

• Synology NAS mit Intel-CPU (z. B. DS1621xs+, DS1621+, DS923+, DS720+ oder vergleichbar) – ARM-Prozessoren sind für Docker-Workloads wie diesen zu schwach
• Mindestens 4 GB RAM auf der NAS (8 GB empfohlen, wenn n8n parallel läuft)
• DSM 7.0 oder neuer
• Fritz!Box mit aktiver Festnetznummer (getestet mit Fritz!Box 7590)
  Software & Dienste:
• Docker bzw. Container Manager auf der Synology bereits eingerichtet
• n8n läuft bereits als Docker-Container
• OpenAI-Account mit hinterlegter Zahlungsmethode und API-Key
• Optional: Cloudflare-Tunnel für externen Zugriff auf n8n-Webhooks
  Kenntnisse:
• SSH-Grundkenntnisse – also: Befehle in die Konsole tippen können
• Grundlegendes Verständnis von Docker und compose.yaml
• Keine Programmierkenntnisse nötig – du bearbeitest vorhandene Konfigurationsdateien

1.5 Kosten

Ulf: „Was kostet das Ganze?
Bernd: „Ich hab schon ein ChatGPT-Plus-Abo – zählt das?“
Tanja: „Leider nein, das Plus-Abo ist für die Chat-Oberfläche. Die Realtime API läuft über die Entwicklerplattform. Die hat eine eigene Abrechnung. Kein Abo, kein Monatspreis. Du zahlst minutengenau, genau das was du verbrauchst.“

Tanja: „Ein typisches Gespräch dauert ein bis drei Minuten. Das sind $0,12 bis $0,75 pro Anruf. Mit $10 Startguthaben kommst du für viele Wochen aus, wenn du das für gelegentliche Heimanrufe nutzt.“
Ulf: „Und wenn das Guthaben aufgebraucht ist?“.
Tanja: „Dann läuft nichts mehr. Deswegen setzt du in der OpenAI-Konsole einen Spending Alert und ein monatliches Kostenlimit – dann wirst du rechtzeitig benachrichtigt, bevor das Konto leer ist.“
Bernd: „Ich würde das Limit einfach weglassen. Kostet ja nicht viel.“
Tanja: „Wenn jemand deinen Webhook automatisiert aufruft, absichtlich oder aus Versehen, hast du am Monatsende eine unschöne Überraschung. Das Limit ist keine Bremse, es ist eine Sicherung.“

1.6 Ablauf im Überblick

Bevor wir bauen, die Vogelperspektive: So läuft ein kompletter Anruf durch das System.

1. Anruf kommt auf der Fritz!Box-Festnetznummer an
2. Fritz!Box leitet den Anruf per SIP an Asterisk weiter
3. Asterisk nimmt den Anruf an und übergibt ihn an das Node.js-Relay (via ARI)
4. Das Relay öffnet eine WebSocket-Verbindung zu wss://api.openai.com/v1/realtime und streamt Audio bidirektional
5. OpenAI führt das komplette Gespräch mit dem Anrufer
6. Nach Gesprächsende sendet das Relay das Transkript per HTTP POST an n8n
7. n8n erstellt eine formatierte E-Mail mit Anrufernummer, Name, Anliegen, Dringlichkeit und vollständigem Gesprächsverlauf

2 Implementierung

2.1 Vorbereitung: OpenAI API-Key erzeugen

Ulf: „Wo bekomme ich diesen API-Key her? Ist das irgendwo in meinen Account-Einstellungen?“
Tanja: „Fast. Du brauchst die Entwicklerplattform. Das ist eine separate Seite von OpenAI. platform.openai.com, nicht chat.openai.com.“ Tanja tippt die Adresse. „Dort erstellst du den Key und lädst Guthaben auf.“
Ulf: „Und das ist dann mit meinem normalen Account verknüpft?“
Tanja: „Selbe E-Mail, aber separate Abrechnung. Was du dort verbrauchst, wird unabhängig von allem anderen abgerechnet.“

Die OpenAI Realtime API ist das KI-Gehirn deines Telefonassistenten. Sie ermöglicht Echtzeit-Sprachkonversationen: Spracherkennung, Antwortgenerierung und Text-to-Speech laufen in einem einzigen Modell mit sehr niedriger Latenz. Ohne API-Key läuft gar nichts.

Den Key bekommst du unter platform.openai.com/account/api-keys. Wichtig: Das ist die Entwicklerplattform – ein vorhandenes ChatGPT-Abo hilft hier nicht weiter.

1. In deinem Projekt: API Keys → Create new secret key
2. Benenne den Key sinnvoll, z. B. KI-Telefonassistent
3. Kopiere den Key sofort und speichere ihn im Passwortmanager – Keys werden nur einmal vollständig angezeigt
4. Gehe zu Billing → Add payment method
5. Lade ein Startguthaben auf (z. B. $10 für erste Tests)

2.2 Vorbereitung: IP-Telefon in der Fritz!Box einrichten

Damit Asterisk Anrufe von der Fritz!Box empfangen kann, muss er sich dort wie ein normales Telefon anmelden. Wir richten dafür ein virtuelles IP-Telefon ein – die Fritz!Box behandelt es genauso wie ein echtes Schnurlostelefon, leitet Anrufe dorthin weiter und übergibt sie per SIP-Protokoll.

Ulf: „Warum ein virtuelles Telefon?“ Kann Asterisk sich nicht einfach direkt einklinken?“
Tanja: „Stell dir vor, du willst in ein Bürogebäude rein. Du brauchst einen Ausweis. Das virtuelle IP-Telefon ist der Ausweis von Asterisk bei der Fritz!Box.“

1. Melde dich an der Benutzeroberfläche deiner Fritz!Box 7590 an (meisthttp://fritz.box)
2. Navigiere zu Telefonie -> Telefoniegeräte
3. Klicke auf Neues Gerät einrichten
4. Wähle Telefon (mit oder ohne Anrufbeantworter) aus und klicke auf „Weiter“
5. Wähle LAN/WLAN (IP-Telefon) aus und gib dem Kind einen Namen (z. B. Asterisk_KI)

6. WICHTIG (Zugangsdaten): Im nächsten Schritt vergibst du einen Benutzernamen und ein Passwort. Notiere dir diese Daten gut!
   • Benutzername: KI_ASSISTANT_USER (muss mindestens 8 Zeichen haben)
   • Passwort: `DEIN_SICHERES_PASSWORT
   • Registrar (SIP-Server): fritz.box oder deine Fritz!Box-IP

7. Wähle die Rufnummer aus, auf die der KI-Assistent reagieren soll – deine Festnetznummer
8. Bestätige die Einrichtung (ggf. musst du dies per Telefon-Code oder Tastendruck an der Fritz!Box verifizieren).

2.3 Vorbereitung: Synology NAS

Tanja: „Bevor wir Container bauen, legen wir die Ordnerstruktur an. Das ist wie der Werkzeugschrank, bevor man anfängt zu schrauben. Wer den überspringt, sucht hinterher alles.“
Bernd hebt die Hand: „Ich fange immer direkt an. Hab keine Zeit für Vorbereitung.“
Tanja:„Du hast letzte Woche zwei Stunden gesucht, wo du die compose.yaml hingelegt hast.“
Bernd schweigt.

Wir legen jetzt die Ordnerstruktur und die .env-Datei an, die später alle API-Keys und Zugangsdaten sicher aufbewahrt.

1. Erstelle folgende Verzeichnisse auf der NAS:
   • /volume1/docker/asterisk/
     • config/ – hier kommen später alle SIP- und Dialplan-Dateien rein
     • logs/ – damit wir sehen, was beim Telefonieren passiert
2. Erstelle darin die Datei /volume1/docker/asterisk/.env
3. Öffne auf deinem PC einen Texteditor (TextEdit, VS Code oder Notepad++) und füge folgenden Inhalt ein:

# OpenAI
OPENAI_API_KEY=DEIN_OPENAI_API_KEY

# Wird später gebraucht:
OPENAI_REALTIME_MODEL=gpt-realtime
N8N_WEBHOOK_BASE_URL=https://n8n.DEINE_DOMAIN.de

4. Berechtigungen setzen: Rechtsklick auf den asterisk-Ordner -> Eigenschaften -> Berechtigungen -> Nur dein Admin-User soll lesenden Zugriff haben.

Warum .env? Weil du damit in der compose.yaml sauber auf die Zugangsdaten referenzieren kannst, ohne sie direkt in YAML-Dateien oder Screenshots sichtbar zu machen. Das ist Best Practice – nicht Paranoia.

2.4 Das richtige Modell wählen – Qualität vs. Kosten

Aktuell stehen drei Realtime-Modelle zur Verfügung:

Die Kosten pro Anruf sind Schätzwerte bei ca. 2 Minuten Nutzer-Audio und 1 Minute KI-Antwort. Längere Gespräche oder ausführliche System-Prompts erhöhen den Preis entsprechend.

Für dieses Projekt empfehle ich gpt-realtime. Es ist das erste allgemein verfügbare Realtime-Modell, wurde speziell für produktive Sprachagenten optimiert und bietet gegenüber gpt-4o-realtime-preview spürbar bessere Sprachqualität, zuverlässigeres Instruction Following – und liegt dabei 20 % günstiger. Besonders praktisch: gpt-realtime unterstützt neben WebRTC und WebSocket auch native SIP-Verbindungen – also genau das Protokoll, das Asterisk und die Fritz!Box sprechen.
Wer Kosten sparen möchte und keine hochkomplexen Gespräche erwartet, kann gpt-realtime-mini ausprobieren. Bei gelegentlichen Heimanrufen ist der Qualitätsunterschied im Alltag kaum spürbar – und die Kosten pro Anruf sinken auf einen Bruchteil.

3 Asterisk als Docker-Container einrichten und mit der Fritz!Box verbinden

Ulf: „Also jetzt bauen wir Asterisk?“
Tanja: „Jetzt bauen wir Asterisk. Aber wir machen es in zwei Schritten. Erst konfigurieren, dann starten, dann testen. Erst wenn der Test grünes Licht gibt, machen wir weiter.“
Bernd: „Ich würde alles auf einmal starten. Spart Zeit.“
Tanja: „Und wenn dann was nicht funktioniert, weißt du nicht wo.“
Bernd: „Stimmt, ist mir schon passiert.“

Asterisk läuft als Docker-Container auf deiner Synology. Er übernimmt eine zentrale Rolle: Er registriert sich bei der Fritz!Box wie ein IP-Telefon, nimmt eingehende Anrufe entgegen und reicht sie an die OpenAI-Brücke weiter. Alles Folgende baut auf dieser Verbindung auf – deshalb testen wir sie explizit, bevor wir weitermachen.

3.1 Docker-Setup: Die compose.yaml

Die compose.yaml ist dein Bauplan. Anstatt kryptische Befehle in die Konsole zu tippen, definierst du hier einmalig, welche Dateien in den Container gemountet werden und wie er sich verhalten soll.

1. Öffne einen Texteditor (z.B. TextEDIT, VS Code oder Notepad++) und erstelle eine neue Datei namens compose.yaml
2. Kopiere den folgenden Block hinein:

Hinweis: In meinem Fall läuft n8n bereits, daher fügen wir hier nur den Asterisk-Teil hinzu. Wie man n8n installiert siehe https://www.foundic.org/n8n-selbst-hosten-synology-nas-docker-installation

version: "3.8"

services:
  asterisk:
    image: andrius/asterisk:20
    container_name: asterisk_ki
    restart: unless-stopped
    network_mode: "host"
    healthcheck:
      disable: true
    volumes:
      # === Config-Dateien (read-only) ===
      - /volume1/docker/asterisk/config/pjsip.conf:/etc/asterisk/pjsip.conf:ro
      - /volume1/docker/asterisk/config/extensions.conf:/etc/asterisk/extensions.conf:ro
      - /volume1/docker/asterisk/config/modules.conf:/etc/asterisk/modules.conf:ro
      - /volume1/docker/asterisk/config/logger.conf:/etc/asterisk/logger.conf:ro
      - /volume1/docker/asterisk/config/rtp.conf:/etc/asterisk/rtp.conf:ro
      - /volume1/docker/asterisk/config/ari.conf:/etc/asterisk/ari.conf:ro
      - /volume1/docker/asterisk/config/http.conf:/etc/asterisk/http.conf:ro
      # === Logs (read-write) ===
      - /volume1/docker/asterisk/logs:/var/log/asterisk:rw
    environment:
      - TZ=Europe/Berlin
      - ASTERISK_UID=0
      - ASTERISK_GID=0

3. Kopiere die fertige Datei nach /volume1/docker/asterisk/

Warum network_mode: "host"?
Ulf zeigt auf die compose.yaml :„Moment, was bedeutet das hier network_mode: host? Klingt irgendwie gefährlich.“
Tanja: „Ist es nicht, aber die Erklärung braucht eine Minute.“
Bernd: „Ich kenn das, NAT. Hab ich mal bei uns im Büro eingerichtet. Hat nicht funktioniert.“
Tanja: „Genau das ist das Problem. Stell dir vor, der Docker-Container ist ein Mitarbeiter, der in einem abgeschlossenen Glaskasten sitzt. Er kann nach draußen telefonieren, aber wenn jemand zurückruft, landet der Anruf an der Glaskasten-Tür, und der Container hört nichts. Das nennt sich One-Way-Audio: du hörst die andere Seite, aber sie hört dich nicht. Oder umgekehrt.“
Ulf: „Das klingt wie beim Fußball wenn das Headset des Torwarts kaputt ist. Der Trainer brüllt, aber der Keeper hört nix.“
Tanja: „Perfekter Vergleich. Mit network_mode: host reißen wir den Glaskasten weg. Der Container verhält sich dann so, als wäre er direkt die DiskStation – gleiche IP, gleiche Ports, kein NAT dazwischen. Asterisk und die Fritz!Box können sich problemlos gegenseitig hören.“
Ulf: „Und das ist sicher?“
Tanja: „Für diesen Anwendungsfall: ja. Asterisk lauscht nur auf den Ports, die wir ihm erlauben. Der Kompromiss ist bewusst eingegangen.“
Bernd nickt langsam. „Ich hätte einfach alle Ports geöffnet.“
Tanja: „Das, wäre nicht sicher.“

Wichtig: Port 5060 muss frei sein. Mit network_mode: "host" kann Asterisk nur dann sauber SIP sprechen, wenn auf der DiskStation niemand sonst bereits auf Port 5060 (UDP/TCP) lauscht. Wenn der Port belegt ist, startet Asterisk zwar – aber die SIP-Registrierung schlägt still fehl, oder Calls brechen unerwartet ab.

Den RTP-Portbereich definieren wir nicht in der compose.yaml, sondern in der rtp.conf – das ist der richtige Ort dafür.

3.2 Docker-Setup: Asterisk-Container-Konfiguration

Ulf: „Sechs Dateien? Für einen Telefonserver?“
Tanja: „Jede macht genau eine Sache. Stell dir vor, du richtest eine neue Werkstatt ein. Du hast einen Schrank für Werkzeuge, einen für Schrauben, einen für die Bedienungsanleitungen. Du könntest alles in eine einzige Schublade werfen.“
Bernd: „Mach ich so“
Ulf: „… aber dann weißt du hinterher nicht mehr, wo was ist, wenn etwas nicht funktioniert.“ Tanja zählt an den Fingern ab: „pjsip.conf: wie Asterisk mit der Fritz!Box redet. rtp.conf: welche Ports für Audio reserviert sind. extensions.conf: was bei einem eingehenden Anruf passiert. modules.conf: welche Asterisk-Funktionen geladen werden. logger.conf: was ins Log geschrieben wird. asterisk.conf: globale Grundeinstellungen.“
Ulf: „Also sechs Schubladen, jede beschriftet“,
Tanja: „Genau. Wenn später Audio nicht funktioniert, schaust du in rtp.conf. Wenn Asterisk sich nicht bei der Fritz!Box registriert, schaust du in pjsip.conf. Du musst nicht eine riesige Datei durchsuchen, sondern weißt sofort wo das Problem liegt.“
Bernd: „Ich hätte alles in eine Datei gepackt“.
Tanja: „Das weiß ich. Fang einfach oben an. Eine Datei nach der anderen.“

Wir erstellen im Verzeichnis /volume1/docker/asterisk/config/ diese sechs Dateien:

1. pjsip.conf → SIP-Registrierung bei der Fritz!Box
2. rtp.conf → RTP-Portbereich (Real-time Transport Protocol für Audiodaten)
3. extensions.conf → Minimaler Dialplan (was passiert, wenn ein Anruf reinkommt)
4. modules.conf → welche Asterisk-Module geladen werden
5. logger.conf → welche Log-Nachrichten wo landen
6. asterisk.conf → globale Asterisk-Einstellungen

3.2.1 pjsip.conf – SIP zur Fritz!Box

PJSIP ist der moderne SIP-Stack von Asterisk und wird von der Fritz!Box sauber unterstützt. Diese Datei definiert, wie Asterisk sich bei der Fritz!Box anmeldet und Anrufe entgegennimmt.
Datei: /volume1/docker/asterisk/config/pjsip.conf

[global]
type=global
user_agent=Asterisk PBX

; ===== UDP TRANSPORT =====
[transport-udp]
type=transport
protocol=udp
bind=0.0.0.0

; ===== FRITZBOX AUTHENTICATION =====
[fritzbox-auth]
type=auth
auth_type=userpass
username=KI_FRITZBOX_USER
password=DEIN_SICHERES_FRITZBOX_PASSWORT

; ===== OUTBOUND REGISTRATION =====
[fritzbox-reg]
type=registration
transport=transport-udp
outbound_auth=fritzbox-auth
server_uri=sip:fritz.box
client_uri=sip:KI_FRITZBOX_USER@fritz.box
retry_interval=60
expiration=3600

; ===== AOR (Address of Record) =====
[fritzbox-aor]
type=aor
max_contacts=1
remove_existing=yes

; ===== IDENTIFY - Erkennt FritzBox =====
[fritzbox-identify]
type=identify
endpoint=fritzbox
match=DEINE_FRITZBOX_IP

; ===== ENDPOINT (für ein- UND ausgehende Anrufe) =====
[fritzbox]
type=endpoint
transport=transport-udp
context=from-fritzbox
aors=fritzbox-aor
auth=fritzbox-auth
outbound_auth=fritzbox-auth
disallow=all
allow=alaw
allow=ulaw
direct_media=no
force_rport=yes
rewrite_contact=yes
rtp_symmetric=yes
from_user=KI_FRITZBOX_USER
from_domain=fritz.box

Diese Platzhalter musst du ersetzen:

• KI_FRITZBOX_USER → Benutzername aus der Fritz!Box (Schritt 2.2)
• DEIN_SICHERES_FRITZBOX_PASSWORT → SIP-Passwort aus der Fritz!Box
• DEINE_FRITZBOX_IP → z. B. 192.168.0.1

3.2.2 rtp.conf – Audio-Ports

Wir legen den RTP-Portbereich explizit fest, damit Audio vorhersagbar läuft. RTP ist das Protokoll, das den eigentlichen Audiostrom überträgt – ohne definierten Portbereich könnte Asterisk beliebige Ports verwenden, was Firewalls und NAT noch chaotischer macht.
Datei: /volume1/docker/asterisk/config/rtp.conf

[general]
rtpstart=20000
rtpend=20255

Firewall-Hinweis: Falls die Firewall auf der Diskstation aktiv ist, lege Regeln an für Port 5060 (UDP) und den Bereich 20000–20255 (UDP).

3.2.3 extensions.conf – Minimal-Dialplan

Ulf: „Was macht der Dialplan?“
Tanja: „Stell dir vor, Asterisk ist ein Empfangstresen. Der Dialplan ist die Arbeitsanweisung: Wenn jemand anruft, was passiert dann? Wohin wird der Anruf weitergeleitet?“ Sie tippt kurz. „Im Moment sagen wir nur: Annehmen, kurz warten, an die OpenAI-Brücke übergeben.“
Datei: /volume1/docker/asterisk/config/extensions.conf

[general]
static=yes
writeprotect=no

[from-fritzbox]
; Eingehender Anruf von FritzBox → an OpenAI Relay weiterleiten
exten => s,1,NoOp(Eingehender Anruf von FritzBox - CID=${CALLERID(all)})
 same => n,Answer()
 same => n,Wait(0.5)
 same => n,NoOp(Uebergabe an OpenAI Realtime via Stasis...)
 same => n,Stasis(asterisk_to_openai_rt)
 same => n,Hangup()

; Catch-all für alle Nummern, die die FritzBox sendet
exten => _X.,1,Goto(from-fritzbox,s,1)

Ein paar Erläuterungen für den Fall, dass du später debuggen musst:

• exten => _X.,1 fängt jede gerufene Nummer ab – die Fritz!Box übergibt oft konkrete MSN-Nummern, und so landest du sicher im Dialplan
• NoOp(...) schreibt ins Log, welche Nummer Asterisk tatsächlich sieht – hilft enorm beim Fehlersuchen
• Wait(0.5) entschärft bei manchen Setups Race-Conditions beim Audiostart

3.2.4 modules.conf, logger.conf und asterisk.conf

Diese drei Dateien sind der Maschinenkeller. Unspektakulär, aber ohne sie startet Asterisk nicht sauber.
Datei: /volume1/docker/asterisk/config/modules.conf

[modules]
autoload=yes

; Sicherheitshalber kritische ARI-Module explizit laden
load = res_http_websocket.so
load = res_ari.so
load = res_ari_channels.so
load = res_ari_bridges.so
load = res_ari_events.so
load = res_stasis.so
load = res_stasis_answer.so
load = res_stasis_playback.so
load = res_stasis_recording.so
load = res_stasis_snoop.so
load = chan_rtp.so

Asterisk hat hunderte Module. autoload=yes lädt alle automatisch – die kritischen ARI-Module werden zusätzlich explizit genannt, damit Asterisk sie auf jeden Fall findet.

Datei: /volume1/docker/asterisk/config/logger.conf

[general]
dateformat=%F %T

[logfiles]
console => notice,warning,error,verbose(5)
messages => notice,warning,error,verbose(5)

Datei: /volume1/docker/asterisk/config/asterisk.conf

[directories]
astetcdir => /etc/asterisk
astvarlibdir => /var/lib/asterisk
astdbdir => /var/lib/asterisk
astmoddir => /usr/lib/asterisk/modules
astspooldir => /var/spool/asterisk
astrundir => /var/run/asterisk
astlogdir => /var/log/asterisk

[options]
verbose = 3
debug = 0

Warum so minimal? Damit Asterisk sicher startet und wir die wichtigen Meldungen direkt auf der Konsole sehen. Datei-Logs können wir später gezielt ergänzen.

3.3 Asterisk im Docker starten

Alle Dateien liegen an ihrem Platz. Jetzt starten wir den Container – über den Container Manager auf der Diskstation.

1. Container Manager öffnen
   • DSM -> Container Manager
2. Neues Projekt erstellen
   • Links: Projekt
   • Erstellen
   • Projektname: asterisk_ki
3. compose.yml auswählen
   • Von bestehender compose.yml
   • Pfad auswählen: /volume1/docker/asterisk/compose.yml
   • Weiter
4. Projekt starten
   • Erstellen & starten (oder „Fertigstellen“ -> „Starten“)

Firewall-Erinnerung: Falls die Firewall auf der Synology aktiv ist, jetzt Regeln anlegen: Port 5060 (UDP) und Port 20000–20255 (UDP).

3.4 Prüfen, ob Asterisk bei der Fritz!Box registriert ist

Ulf: „Und jetzt einfach anrufen und schauen ob’s geht?“
Tanja: „Nein, erst verifizieren wir, dass Asterisk sich registriert hat. Erst dann testen wir den Anruf. Wer diesen Schritt überspringt, verbringt anschließend eine Stunde damit, im Dunkeln zu tappen.“
Bernd: „Ich hätte einfach angerufen“
Tanja: „Das weiß ich.“

Wir schauen jetzt direkt in die Asterisk-Konsole. Dafür gibt es zwei Wege:
Weg 1 – über den Container Manager:

• Container Manager öffnen → Container asterisk_ki auswählen
• Tab Terminal → Erstellen → bash wählen
• Befehl eingeben: asterisk -rvvv
• Sobald der Prompt asterisk*CLI> erscheint, eingeben: pjsip show registrations
  Weg 2 – über SSH:
• SSH auf der Diskstation aktivieren: Systemsteuerung → Terminal & SNMP → SSH-Dienst aktivieren
• Terminal öffnen und einloggen: ssh DEIN_DSM_USER@DEINE_DISKSTATION_IP
• In die Asterisk-CLI: docker exec -it asterisk_ki asterisk -rvvv
• Registrierung anzeigen: pjsip show registrations
  Das Ergebnis sollte so aussehen:

<Registration/ServerURI..............................>  <Auth..........>  <Status.......>
==========================================================================================
 fb-trunk/sip:192.168.178.1                              fb-auth           Registered

Das Wort Registered ist dein grünes Licht. Alles andere – Failed, Rejected, gar keine Ausgabe – bedeutet: Zugangsdaten prüfen, Fritz!Box-Konfiguration nochmal kontrollieren, erst dann weitermachen.

4 Die OpenAI-Brücke: WebSocket-Relay einrichten und KI-Gespräche aktivieren

Ulf: „Asterisk läuft, Fritz!Box meldet ‚Registered‘, was kommt jetzt?“.
Tanja: „Jetzt, bauen wir den spannendsten Teil. Das Relay. Der zweite Docker-Container, der Asterisk und OpenAI miteinander verbindet.“
Bernd:„Ich würde das alles in einem Container zusammenstecken“.
Tanja: „Dann hast du einen Container, der alles macht und bei dem du nichts mehr einzeln debuggen kannst. Zwei Container, zwei Verantwortlichkeiten – das ist sauberer.“
Bernd: „Klingt nach mehr Arbeit.“
Tanja: „Klingt nach weniger Kopfschmerzen.“

Das Relay übersetzt zwei grundlegend verschiedene Welten: auf der einen Seite das klassische RTP-Audioprotokoll von Asterisk, auf der anderen den WebSocket-Stream, den OpenAI erwartet. Sobald diese Brücke steht, übernimmt OpenAI das komplette Gespräch – Spracherkennung, Antwortgenerierung und Text-to-Speech in Echtzeit.

4.1 Asterisk-to-OpenAI-Realtime (WebSocket Bridge)

Wir erweitern die Ordnerstruktur um den openai-relay-Container:

/volume2/docker/
├── asterisk/
│   ├── compose.yaml
│   ├── config/
│   │   ├── pjsip.conf
│   │   ├── extensions.conf
│   │   ├── ari.conf
│   │   ├── http.conf
│   │   ├── modules.conf
│   │   ├── logger.conf
│   │   └── rtp.conf
│   └── logs/
└── openai-relay/
    ├── compose.yaml
    ├── Dockerfile
    └── config.conf

Drei neue Dateien im Verzeichnis openai-relay: das Dockerfile, die compose.yaml und die config.conf. Schauen wir uns alle drei an.

4.2 Das Dockerfile

Das Dockerfile baut das Docker-Image direkt aus einem öffentlichen Repository – du musst keinen Code manuell klonen oder pflegen.
Erstelle die Datei /volume1/docker/openai-relay/Dockerfile:

FROM node:20-slim

RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Community Edition klonen
RUN git clone https://github.com/infinitocloud/asterisk_to_openai_rt_community.git .

RUN npm install

ENV NODE_ENV=production

CMD ["node", "index.js"]

4.3 Die compose.yaml für openai-relay

Da Asterisk im network_mode: host läuft, muss das Relay dasselbe tun – sonst erreicht es die RTP-Audio-Ports nicht.
Erstelle die Datei /volume1/docker/openai-relay/compose.yaml:

version: "3.8"

services:
  openai-relay:
    build: .
    container_name: openai-relay
    restart: unless-stopped
    network_mode: "host"
    volumes:
      # config.conf wird in den Container gemountet
      - /volume1/docker/openai-relay/config.conf:/app/config.conf:ro
    environment:
      - TZ=Europe/Berlin
      - NODE_ENV=production
    depends_on: []
    # Hinweis: asterisk_ki muss ZUERST gestartet werden,
    # da openai-relay sich per ARI verbindet.
    # Da die Container in separaten compose-Dateien sind,
    # manuell sicherstellen: erst asterisk_ki, dann openai-relay.

4.4 Asterisk Core-Konfiguration: ari.conf und http.conf

Ulf: „Was ist ARI?“.
Tanja: „ARI steht für Asterisk REST Interface. Es ist die Schnittstelle, über die das Node.js-Relay mit Asterisk kommuniziert. Ohne ARI kann das Relay keinen Anruf übernehmen.“
Ulf: „Das klingt nach dem Trainertelefon zur Bank. Der Coach kann dem Ersatzspieler Anweisungen geben, ohne auf das Feld zu müssen.“
Tanja: „Exakt“.

Diese beiden Dateien sind das Bindeglied zwischen Asterisk und dem Relay. Besonders wichtig: type=user in der ari.conf – das ist häufig der Grund, warum ARI-Verbindungen still scheitern.
Datei: /volume1/docker/asterisk/config/ari.conf

[general]
enabled=yes
pretty=yes
allowed_origins=*

[ari_user]
type=user
read_only=no
password=dein_ari_passwort

Diese Platzhalter musst du ersetzen:

• ARI_USERNAME=ari_user -> frei wählbarer Benutzername
• ARI_PASSWORD=dein_ari_passwort -> frei wählbares Passwort (merken, kommt gleich wieder)

Datei: /volume1/docker/asterisk/config/http.conf

[general]
enabled=yes
bindaddr=127.0.0.1
bindport=8088

127.0.0.1 statt 0.0.0.0: Da beide Container auf dem Host-Netz der Synology laufen, braucht der HTTP-Port nicht nach außen offen zu sein. Das ist eine einfache, effektive Sicherheitsmaßnahme.

4.5 Das config.conf – Schaltzentrale des Relays

Diese Datei ist das Herzstück des openai-relay-Containers. Hier trägst du ein, mit welchem OpenAI-Key das Relay spricht, wie es sich bei Asterisk anmeldet und was die KI beim Gespräch sagen soll.
Erstelle die Datei /volume1/docker/openai-relay/config.conf:

# OpenAI Realtime API Key
OPENAI_API_KEY=OpenAI_Projekt_API_Key

# ARI Credentials (muessen mit ari.conf uebereinstimmen)
ARI_URL=http://127.0.0.1:8088
ARI_USERNAME=ari_user
ARI_PASSWORD=dein_ari_passwort

# Anruf Limit von 5 Minuten
CALL_DURATION_LIMIT_SECONDS=300

# System-Prompt fuer den Assistenten
SYSTEM_PROMPT=Du bist ein professioneller deutschsprachiger Telefonassistent. Fuehre das Gespraech in dieser Reihenfolge: 1) Begruesse den Anrufer freundlich und sage dass gerade niemand erreichbar ist und du die KI Telefon-Assistentin bist. 2) Frage nach dem Namen des Anrufers falls nicht bereits genannt. 3) Frage worum es geht und hoere aufmerksam zu. 4) Frage wie dringend das Anliegen ist. 5) Fasse das Anliegen kurz zusammen und bestaetige dass du die Nachricht weiterleiten wirst. 6) Verabschiede dich freundlich. Antworte immer auf Deutsch, kurz und praezise. Vermeide lange Monologe.

# Logging
LOG_LEVEL=info

Diese Platzhalter ersetzen:

• OpenAI_Projekt_API_Key -> dein OpenAI API-Key aus Schritt 2.1
• ARI_USERNAME=ari_user -> vdie Werte aus ari.conf
• ARI_PASSWORD=dein_ari_passwort -> die Werte aus ari.conf

Den SYSTEM_PROMPT kannst du frei anpassen. Das ist die Persönlichkeit deines KI-Assistenten. Halte ihn konkret und strukturiert: Je klarer die Reihenfolge, desto zuverlässiger arbeitet das Modell.

4.6 Stimme der KI ändern

OpenAI bietet verschiedene Stimmen für die Realtime API an. Standard ist alloy – du kannst aber auf andere Stimmen wie echo, fable, onyx, nova oder shimmer wechseln.
Um die Stimme zu ändern, kopierst du zunächst die Konfigurationsdatei aus dem laufenden Container auf die NAS:

sudo docker cp openai-relay:/app/config.js /volume2/docker/openai-relay/config.js

Füge in dieser config.js nach dem zweiten Eintrag folgende Zeile ein:

OPENAI_VOICE: process.env.OPENAI_VOICE || 'alloy',

Damit der Container diese Datei auch findet, erweitere die compose.yaml um den zweiten Volume-Eintrag:

volumes: 
- /volume2/docker/openai-relay/config.conf:/app/config.conf:ro 
- /volume2/docker/openai-relay/config.js:/app/config.js:ro

Und trage in der config.conf ein:

OPENAI_VOICE=alloy

Danach den Container neu starten . Die neue Stimme ist aktiv.

4.7 Webhook für n8n Workflow vorbereiten

Aktuell werden Transkripte nur in die Konsole geloggt und gehen nach dem Auflegen verloren. Jetzt erweitern wir das System so, dass nach jedem Gespräch automatisch ein Transkript an n8n geschickt wird.

Ulf: „Moment, wir müssen Code in fertigen Dateien ändern?“
Tanja: „Wir kopieren die Dateien erst raus, ändern sie, und mounten sie dann als Volume in den Container rein. Der Container bleibt unberührt. Wir steuern sein Verhalten von außen.“
Ulf: „Das ist wie beim Fußball“. Der Spieler ist unveränderlich, aber der Trainer gibt ihm von außen neue Anweisungen.“
Tanja: „Genau.“

Schritt 1: Es müssen folgende JavaScript-Dateien aus dem Container kopiert werden, damit wir sie anpassen und als Volume mounten können.

sudo docker cp openai-relay:/app/config.js /volume1/docker/openai-relay/config.js
sudo docker cp openai-relay:/app/asterisk.js /volume1/docker/openai-relay/asterisk.js
sudo docker cp openai-relay:/app/openai.js /volume1/docker/openai-relay/openai.js

Schritt 2: In /volume1/docker/openai-relay/config.js suche nach INITIAL_MESSAGE: und füge direkt darüber ein:

OPENAI_VOICE: process.env.OPENAI_VOICE || 'alloy',
N8N_WEBHOOK_URL: process.env.N8N_WEBHOOK_URL || '',
INITIAL_MESSAGE: process.env.INITIAL_MESSAGE || 'Hi',

Schritt 3: config.conf ergänzen
Füge am Ende der /volume1/docker/openai-relay/config.conf hinzu:

OPENAI_VOICE=alloy 
N8N_WEBHOOK_URL=https://n8n.civicgem.org/webhook/NEUE_WEBHOOK_ID

Hinweis: Die NEUE_WEBHOOK_ID wird erst im nächsten Schritt beim Aufbau des n8n-Workflows definiert. Trag hier zunächst einen Platzhalter ein und ersetze ihn danach.

Schritt 4: compose.yaml aktualisieren
Erweitere die Volumes in /volume1/docker/openai-relay/compose.yaml:

volumes:
      - /volume2/docker/openai-relay/config.conf:/app/config.conf:ro
      - /volume2/docker/openai-relay/config.js:/app/config.js:ro
      - /volume2/docker/openai-relay/asterisk.js:/app/asterisk.js:ro
      - /volume2/docker/openai-relay/openai.js:/app/openai.js:ro

Aktuell werden die Transkripte nur in die Konsole geloggt und gehen nach dem Anruf verloren. Wir müssen openai.js so erweitern, dass die Transkripte während des Gesprächs gesammelt und nach Gesprächsende per HTTP POST an n8n geschickt werden.

Schritt 5: openai.js erweitern – Transkript sammeln
Suche in /volume1/docker/openai-relay/openai.js die Zeile (ca. Zeile 88):

  let lastUserItemId = null;

Füge direkt darunter ein:

  let transcriptLog = [];

Dann suche diesen Block (ca. Zeile 164-168):

if (role === 'User') {
              logOpenAI`User command transcription for ${channelId}: ${response.transcript}`, 'info');
            } else {
              logOpenAI(`Assistant transcription for ${channelId}: ${response.transcript}`, 'info');
            }

Ersetze ihn durch:

            if (role === 'User') {
              logOpenAI(`User command transcription for ${channelId}: ${response.transcript}`, 'info');
              transcriptLog.push({ role: 'user', text: response.transcript, time: new Date().toISOString() });
            } else {
              logOpenAI(`Assistant transcription for ${channelId}: ${response.transcript}`, 'info');
              transcriptLog.push({ role: 'assistant', text: response.transcript, time: new Date().toISOString() });
            }

Dann suche (ca. Zeile 167)

            logOpenAI`User command transcription for ${channelId}: ${response.transcript}`, 'info');
          }
          break;
        case 'response.audio.done':

Ersetze die eine Zeile:

            logOpenAI(`User command transcription for ${channelId}: ${response.transcript}`, 'info');

durch:

            logOpenAI(`User command transcription for ${channelId}: ${response.transcript}`, 'info');
            transcriptLog.push({ role: 'user', text: response.transcript, time: new Date().toISOString() });

Zum Schluss: Suche sipMap.set(channelId, channelData); innerhalb von connectWebSocket (ca. Zeile 246) und füge direkt davor ein:

        channelData.transcriptLog = transcriptLog;

Suche diesen Block (ca. Zeile 180):

        case 'conversation.item.input_audio_transcription.completed':
          if (response.transcript) {
            logger.debug(`User transcript completed - Full message: ${JSON.stringify(response, null, 2)}`);
            logOpenAI(`User command transcription for ${channelId}: ${response.transcript}`, 'info');
          }
          break;

Ersetze durch:

        case 'conversation.item.input_audio_transcription.completed':
          if (response.transcript) {
            logger.debug(`User transcript completed - Full message: ${JSON.stringify(response, null, 2)}`);
            logOpenAI(`User command transcription for ${channelId}: ${response.transcript}`, 'info');
            transcriptLog.push({ role: 'user', text: response.transcript, time: new Date().toISOString() });
          }
          break;

Suche Zeile (ca. Zeile 224):

            input_audio_transcription: {
              model: 'whisper-1',
              language: 'en'
            },

Suche language: en und ersetze durch de für Deutsche Sprache

              language: 'de'

Schritt 6: asterisk.js erweitern – Transkript an n8n senden
…/docker/openai-relay/asterisk.js erweitern** — nach Gesprächsende die gesammelten Transkripte an n8n senden.

Änderung 1: Ganz oben nach der letzten require-Zeile einfügen:

const http = require('http');
const https = require('https');

Änderung 2: Suche in der cleanupChannel-Funktion diese Zeile:

    } catch (e) { 
      logger.error(`Cleanup error for ${channelId}: ${e.message}`);
    } finally {
      cleanupPromises.delete(channelId);
      cleanupPromises.delete(`ws_${channelId}`);
    }

Füge direkt davor (also vor } finally {) ein:

      // Send transcript to n8n webhook
      if (config.N8N_WEBHOOK_URL && channelData.transcriptLog && channelData.transcriptLog.length > 0) {
        try {
          const payload = JSON.stringify({
            channelId: channelId,
            callerName: channelData.channel?.caller?.name || 'Unbekannt',
            callerNumber: channelData.channel?.caller?.number || 'Unbekannt',
            callStart: channelData.transcriptLog[0]?.time || new Date().toISOString(),
            callEnd: new Date().toISOString(),
            transcript: channelData.transcriptLog
          });
          const url = new URL(config.N8N_WEBHOOK_URL);
          const client = url.protocol === 'https:' ? https : http;
          const req = client.request(url, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
          }, (res) => {
            logger.info(`n8n webhook response for ${channelId}: ${res.statusCode}`);
          });
          req.on('error', (e) => logger.error(`n8n webhook error for ${channelId}: ${e.message}`));
          req.write(payload);
          req.end();
          logger.info(`Transcript sent to n8n for ${channelId} (${channelData.transcriptLog.length} entries)`);
        } catch (e) {
          logger.error(`Failed to send transcript to n8n for ${channelId}: ${e.message}`);
        }
      }

4.8 Cloudfare öffenen für Webhooks

Ulf: „Ich nutze Cloudflare mit Zero Trust für n8n. Muss ich da was anpassen?“
Tanja: „Ja, Zero Trust blockiert standardmäßig alle eingehenden Requests, die nicht authentifiziert sind – also auch Webhooks von OpenAI. Wir müssen einen Bypass für den Webhook-Pfad einrichten.“

Wenn du Cloudflare mit Zero Trust für n8n nutzt, werden Webhooks grundsätzlich geblockt. Wir richten eine Ausnahme speziell für den /webhook/-Pfad ein. Zur EInrichtung von Cloudflare siehe https://www.foundic.org/n8n-cloudflare-tunnel-synology-nas.

Teil 1 – Neue Access Application anlegen:

1. Cloudflare Zero Trust Dashboard öffnen:
   1. Gehe zu: https://one.dash.cloudflare.com/
   2. Melde dich an
   3. Wähle dein Team/Account
2. Access Application finden:
   1. Navigiere zu: Protect & Connect -> Zero Trust -> Access controls -> Applications
   2. Finde deine n8n-Application in der Liste
   3. Wähle „+ Add an application“
   4. Select: Self-hosted
   5. Applciation name: n8n-webhook
   6. Session Duration: 24hours
   7. „+ Add public hostname“
      • Subdomain: die bisher benutzte
      • Domain: deine Domain
      • Path: webhook/*
   8. Wähle links im Menü „Policies“ aus
   9. Klicke auf „Add a policy“
      • Policy konfigurieren:
        Policy Name: n8n Webhook Bypass
        Action: „Bypass“
        Session duration: Same as application session timeout
        Selection: Everyone
        Klicke auf „Save“ 

Teil 2 – WAF-Regel erstellen:
Gehe im Cloudflare Dashboard zur obersten Kontoebene -> Domains -> deine Domain -> (links im Menü) Security -> Overview -> in der Mitte im Kasten „Web app exploits“ -> Manage custom rules -> + Create rule -> Custom rules

• Rule name: Allow n8n Webhook
• Field: URI Path …, Operator: starts with, Value: .. /webhook/
• Choose action: Skip
• Aktiviere alle Sicherheitsoptionen (WAF, Super Bot Fight Mode etc.), damit OpenAI ungehindert durchkommt
• Klicke auf Deploy

4.9 n8n Workflow bauen

Ulf: „Jetzt kommt der Teil, den ich kenne, n8n.“
Tanja: „Fast, erst brauchen wir noch ein App-Passwort für Gmail. Das normale Google-Passwort geht nicht.“
Ulf: „Warum nicht?“
Tanja: „Weil Google beim normalen Passwort verlangt, dass du dich per Browser verifizierst. Eine Maschine kann das nicht. Ein App-Passwort ist ein separater 16-stelliger Code, der nur für automatisierte Zugänge gedacht ist.“
Ulf: „Und wenn ich keins hab?“
Tanja: „Dann bleibt die E-Mail aus.“

Schritt 1: Gmail App-Passwort erstellen
Falls der n8n Workflow eine Zusammenfassung an Gmail bzw. Googel Mail senden soll brauchst Du ein App-Passwort (nicht Dein normales Gmail-Passwort). So richtest Du es ein:
Gmail App-Passwort erstellen:

• Gehe zu https://myaccount.google.com/apppasswords
• (2-Faktor-Authentifizierung muss aktiv sein)
• App-Name: n8n
• Du bekommst ein 16-stelliges Passwort – kopiere es

Schritt 2: SMTP Credentials in n8n anlegen
SMTP Credentials anlegen in n8n anlegen

• n8n -> Settings -> Credentials -> Add Credential -> Typ: SMTP
• Name: SMTP Gmail account
• User: deine-adresse@gmail.com
• Password: dein 16-stelliges App-Passwort
• Host: smtp.gmail.com
• Port: 465
• SSL/TLS: Ein
• Speichern

Schritt 3: Die drei Workflow-Nodes
Erstelle einen neuen n8n-Workflow mit drei Nodes hintereinander.
Node 1: Webhook

• Method: POST
• Path: anruf-zusammenfassung
• Authentication: None

Node 2: Code in JavaScript

• Mode: Run Once for All Items
• Language: JavaScript

// Transkript formatieren
const body = $input.first().json.body;
const transcript = body.transcript || [];
const callerName = body.callerName || 'Unbekannt';
const callerNumber = body.callerNumber || 'Unbekannt';
const callStart = body.callStart ? new Date(body.callStart).toLocaleString('de-DE', { timeZone: 'Europe/Berlin' }) : 'Unbekannt';
const callEnd = body.callEnd ? new Date(body.callEnd).toLocaleString('de-DE', { timeZone: 'Europe/Berlin' }) : 'Unbekannt';

// Gespraechsverlauf als Text
let gespraech = '';
for (const entry of transcript) {
  const rolle = entry.role === 'assistant' ? 'Anna (KI)' : 'Anrufer';
  gespraech += `${rolle}: ${entry.text}\n\n`;
}

// Zusammenfassung erstellen
let zusammenfassung = `ANRUF-ZUSAMMENFASSUNG\n`;
zusammenfassung += `========================\n\n`;
zusammenfassung += `Anrufer: ${callerName}\n`;
zusammenfassung += `Telefonnummer: ${callerNumber}\n`;
zusammenfassung += `Anruf Beginn: ${callStart}\n`;
zusammenfassung += `Anruf Ende: ${callEnd}\n\n`;
zusammenfassung += `GESPRAECHSVERLAUF:\n`;
zusammenfassung += `------------------------\n\n`;
zusammenfassung += gespraech;

// HTML Version fuer E-Mail
let html = `<h2>Anruf-Zusammenfassung</h2>`;
html += `<table style="border-collapse:collapse; margin-bottom:20px;">`;
html += `<tr><td style="padding:4px 12px 4px 0; font-weight:bold;">Anrufer:</td><td>${callerName}</td></tr>`;
html += `<tr><td style="padding:4px 12px 4px 0; font-weight:bold;">Telefonnummer:</td><td>${callerNumber}</td></tr>`;
html += `<tr><td style="padding:4px 12px 4px 0; font-weight:bold;">Beginn:</td><td>${callStart}</td></tr>`;
html += `<tr><td style="padding:4px 12px 4px 0; font-weight:bold;">Ende:</td><td>${callEnd}</td></tr>`;
html += `</table>`;
html += `<h3>Gespr\u00e4chsverlauf</h3>`;
for (const entry of transcript) {
  const rolle = entry.role === 'assistant' ? 'Anna (KI)' : 'Anrufer';
  const color = entry.role === 'assistant' ? '#2563eb' : '#059669';
  html += `<p><strong style="color:${color};">${rolle}:</strong> ${entry.text}</p>`;
}

const subject = `Anruf von ${callerName} (${callerNumber}) - ${callStart}`;

return [{ json: { subject, text: zusammenfassung, html, callerName, callerNumber } }];

Als letzten Node 3: Send Email erstellen

• Credential to connect with: SMTP Gmail account
• Operations: Send
• From Email: deine E-Mail-Adresse
• To Email: deine E-Mail-Adresse
• Subject: {{ $json.subject }}
• Email Format: HTML
• HTML: {{ $json.html }}

Schritt 4: Workflow aktivieren
Aktiviere den Workflow über Publish und kopiere die Webhook-URL aus dem Webhook-Node. Sie sieht etwa so aus:

https://n8n.deine-domain.de/webhook/anruf-zusammenfassung

Schritt 5: URL in config.conf eintragen
Öffne /volume1/docker/openai-relay/config.conf und trage die URL ein:

N8N_WEBHOOK_URL=https://n8n.deine-domain.de/webhook/anruf-zusammenfassung

Starte den openai-relay-Container neu. Jetzt sollte es funktionieren.

4.10 Optional: KI legt nach der Verabschiedung selbst auf

Ulf: „Legt die KI eigentlich selbst auf?“
Tanja: „Standardmäßig nicht. Sie verabschiedet sich und wartet dann. Der Anrufer muss auflegen.“
Ulf: „Das ist unhöflich. Ich würde das ändern.“
Tanja: „Du kannst. Es ist optional, aber es macht das Gespräch deutlich runder.“

Die Logik ist einfach: Wenn die KI sich verabschiedet – erkannt an Schlüsselwörtern im Transkript – startet ein Timer. Sagt der Anrufer innerhalb von 8 Sekunden nichts mehr, legt das System auf.
Alle Änderungen in /volume1/docker/openai-relay/openai.js:
Änderung 1: Nach der Zeile let transcriptLog = []; (ca. Zeile 95) einfügen:

  let goodbyeTimer = null;
  let goodbyeDetected = false;
  const GOODBYE_TIMEOUT_MS = 8000;
  const goodbyePattern = /wiedersehen|wiederh.ren|tsch.ss|sch.nen tag|guten tag noch/i;

Änderung 2: Im response.audio_transcript.done-Block, nach dem transcriptLog.push-Aufruf im else-Zweig (KI-Antwort), einfügen:

// Check if assistant said goodbye
              if (goodbyePattern.test(response.transcript)) {
                logger.info(`Goodbye detected for ${channelId}, starting ${GOODBYE_TIMEOUT_MS}ms hangup timer`);
                if (goodbyeTimer) clearTimeout(goodbyeTimer);
                goodbyeTimer = setTimeout(async () => {
                  logger.info(`Goodbye timeout reached for ${channelId}, hanging up`);
                  if (ws && ws.readyState === WebSocket.OPEN) {
                    ws.close();
                  }
                  try {
                    const cd = sipMap.get(channelId);
                    if (cd && cd.channel) {
                      await cd.channel.hangup();
                      logger.info(`Channel ${channelId} hung up after goodbye`);
                    }
                  } catch (e) {
                    logger.error(`Error hanging up channel ${channelId} after goodbye: ${e.message}`);
                  }
                }, GOODBYE_TIMEOUT_MS);
              }

Änderung 3: Im conversation.item.created-Block, nach if (response.item.role === 'user') { und vor lastUserItemId = ..., einfügen:

              if (goodbyeTimer) {
                clearTimeout(goodbyeTimer);
                goodbyeTimer = null;
                logger.info(`Goodbye timer cancelled for ${channelId}, user is speaking`);
              }

Dieser Teil ist wichtig: Wenn der Anrufer nach der Verabschiedung doch nochmal etwas sagt, wird der Timer abgebrochen. Die KI antwortet dann nochmals – und startet den Timer bei der nächsten Verabschiedung neu.
Danach Container neu starten.

5 Fazit

Einige Wochen später.
Ulf öffnet sein Handy. Eine E-Mail. Betreff: „Anruf von Klaus Müller (0171-…) – heute, 14:32 Uhr.“
Ulf öffnet sie. Vollständiger Gesprächsverlauf. Name, Anliegen, Dringlichkeit, alles da. Drei Minuten Gespräch, in einer lesbaren E-Mail zusammengefasst.
Ulf: „Hat funktioniert“.
Tanja: „Das weiß ich“.
Bernd schaut kurz rüber: „Ich habe auch eine Lösung gebaut. Ich habe meiner Frau gesagt, sie soll Anrufe entgegennehmen.“
Ulf: „Und?“
Bernd „Sie nimmt das Telefon nicht mehr ab.“

Was als Heimserver-Bastelprojekt begann, ist am Ende ein erstaunlich leistungsfähiges System. Ein Anrufer merkt kaum einen Unterschied zu einem echten Gespräch – die KI begrüßt freundlich, hört zu, fragt nach und verabschiedet sich. Wenige Sekunden später landet die vollständige Zusammenfassung im Postfach.

Was gut funktioniert: Der größte Vorteil dieser Architektur ist die vollständige Kontrolle über die eigene Infrastruktur. Asterisk, n8n und das Relay laufen lokal auf der Synology – nur die KI-Verarbeitung findet bei OpenAI statt. Keine monatlichen Abokosten für Telefonie-Dienste, keine Abhängigkeit von externen SIP-Anbietern, volle Transparenz über die Gesprächsdaten.

Wo es knifflig werden kann: Der schwierigste Teil ist erfahrungsgemäß die initiale Netzwerkkonfiguration – insbesondere network_mode: host, die Firewall-Regeln auf der Synology und die Cloudflare-Webhook-Freigabe. Wer hier sorgfältig vorgeht und jeden Schritt einzeln testet, spart sich viel Fehlersuche. Das Motto gilt auch hier: erst testen, dann weitermachen.

Mögliche nächste Schritte:

• Unterschiedliche System-Prompts je nach Rufnummer oder Tageszeit
• Mehrsprachige Unterstützung
• Integration in einen Kalender, damit die KI direkt Rückruftermine vereinbaren kann
• Erweiterung des n8n-Workflows mit einer KI-basierten Zusammenfassung via Claude oder ChatGPT

Bei Fragen oder Verbesserungsvorschlägen: Kommentar hinterlassen.

Das System durchforstet das Internet selbstständig nach den wichtigsten Entwicklungen im Bereich Künstliche Intelligenz. Als Gehirn dahinter dient n8n, ein selbst gehostetes Automatisierungswerkzeug, das verschiedene spezialisierte KI-Agenten zu einem digitalen Redaktionsteam zusammenschnürt. Dieses Team filtert die riesige Informationsflut aus RSS-Feeds, bewertet jeden Treffer nach Relevanz und verwandelt die besten Artikel in hochwertige Blog-Beiträge.

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen und n8n wirklich zu verstehen.

Tanja ist die IT-Expertin. Sie weiß, wie n8n funktioniert, erklärt geduldig und strukturiert – und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.
Bernd ist der selbsternannte „Experte“, der alles besser weiß – und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.
Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung – dafür ist Tanja da.

„Und… Action!“

Montag, 8:47 Uhr. Im Büro.
Ulf starrt auf seinen Bildschirm. Drei Browserfenster mit KI-Newsseiten, ein halbvolles Glas Kaffee, und das dumpfe Gefühl, dass er gerade wieder eine halbe Stunde damit verschwendet hat, Heise, Golem und t3n nacheinander durchzuklicken, um ja nichts zu verpassen.
Ulf: „Ich will eigentlich nur die wichtigen KI-News haben“, murmelt er. „Ohne selbst stundenlang zu suchen.“
Tanja, die seit zehn Minuten daneben sitzt und ihre Notizen liest, hebt den Kopf. „Dann hör auf, es manuell zu machen. Lass eine Maschine für dich suchen.“
Bernd lehnt im Türrahmen. „Ich mach das auch automatisch. Ich hab einen Google Alert eingerichtet. Auf das Wort ‚KI‘.“ Er nickt sich selbst anerkennend zu. „Kriegst hundert Mails am Tag. Alles drin.“
Kurze Stille.
Tanja: „Das ist ungefähr so, als würdest du den kompletten Supermarkt bestellen und dann schauen, was du davon essen kannst.“

Das Entscheidende: Das System arbeitet als „Human-in-the-Loop“-Konstruktion. Die KI übernimmt Recherche, Qualitätsprüfung und das Schreiben. Du als Admin behältst die Kontrolle – kein Artikel erscheint auf deiner Website, bevor du in WordPress grünes Licht gibst. So kombinierst du die Geschwindigkeit von KI mit menschlichem Urteilsvermögen. Schnell und trotzdem klug.
Technisch gesehen baust du ein Multi-Agenten-System, das die Stärken verschiedener Sprachmodelle geschickt kombiniert: GPT-4o-mini für die schnellen, massenhaften Bewertungsaufgaben – und Claude für die anspruchsvolle Artikelerstellung. Dazu kommt eine eigene Datenbank als „Langzeitgedächtnis“, die Duplikate verhindert und deine Redaktionsprozesse professionalisiert.

Das Redaktionsteam – fünf Agenten:

• Agent 1: Recherche (RSS-Feeds, alle 2 Stunden)
• Agent 2: Redaktionelle Einzelbewertung (GPT-4o-mini, alle 4 Stunden)
• Agent 3: Content-Recherche & Anreicherung (GPT-4o-mini + Tavily, täglich)
• Agent 4: Artikel schreiben + Coverbild erstellen (Claude + Flux-2-Flex, täglich)
• Agent 5: Veröffentlichen auf WordPress (täglich, mit menschlicher Freigabe)

2 Technische Beschreibung

2.1 Systemarchitektur

Ulf: „Warte mal kurz, die fünf Agenten reden die miteinander? Wie im Büro, so mit Slack oder so?“
Tanja schüttelt den Kopf: „Stell dir eine Fabrik vor. Jede Abteilung macht ihren Job und legt das Ergebnis ins Regal. Die nächste Abteilung holt es von dort ab. Niemand ruft niemanden an.“
„Das Regal“, ergänzt Tanja, „ist die Datenbank.“
Bernd: „Ich hätte die alle einfach miteinander verbunden. Direkt. Viel einfacher.“
Tanja: „Dann hast du ein System, das ausfällt, wenn einer der fünf Agenten einen Fehler macht, und du weißt nicht mehr, wo. Die Datenbank ist der Schlüssel. Jeder Agent liest daraus, schreibt zurück, und setzt einen Status. So weiß jeder, was der andere getan hat – ohne direkt miteinander sprechen zu müssen.“

Der KI Newsroom folgt einer Pipeline-Architektur: Fünf spezialisierte n8n-Workflows arbeiten sequenziell, jeder übernimmt genau eine Aufgabe. Der Schlüssel, der sie zusammenhält, ist eine gemeinsame PostgreSQL-Datenbank als zentrales Gedächtnis. Kein Agent spricht direkt mit einem anderen – sie kommunizieren ausschließlich über die Datenbank, indem sie Datensätze lesen, verarbeiten und deren Status hochsetzen. Die gesamte Infrastruktur läuft self-hosted auf einer Synology NAS im Docker-Betrieb.

[Internet / RSS-Feeds]
        ↓
  A1: Recherche         → ki_artikel (Status: NEU)
        ↓
  A2: Bewertung         → ki_artikel (Status: BEWERTET)
        ↓
  A3: Content-Recherche → ki_story   (Status: ANGEREICHERT)
        ↓
  A4: Artikel + Bild    → ki_artikel (Status: PUBLISH_READY)
        ↓
  A5: WordPress         → ki_artikel (Status: PUBLISHED)
        ↓
  [WordPress / foundic.org]

2.2 Datenbankschema

Die Datenbank besteht aus drei Tabellen – stell sie dir wie drei verschiedene Schubladen in einem Aktenschrank vor.

• ki_artikel ist die große Hauptschublade. Hier landet jeder eingelesene RSS-Artikel und bleibt dort bis zur Veröffentlichung. Die Tabelle speichert Rohdaten aus dem Feed, KI-Bewertungsscores, fertige WordPress-Inhalte und den aktuellen Workflow-Status. Das Feld url_normalized verhindert Duplikate: Tracking-Parameter wie utm_source, das www.-Präfix und überflüssige Trailing Slashes werden aus URLs entfernt, bevor ein Artikel eingetragen wird. So landen Heise-Links mit und ohne ?utm_campaign=newsletter nicht doppelt in der Datenbank.
• ki_story ist die Kreativschublade. Hier liegt der angereicherte, tiefenrecherchierte Inhalt – der von Agent 3 erstellte Hintergrundtext und später der von Claude verfasste fertige WordPress-Artikel. Jede Story ist genau einem Eintrag in ki_artikel zugeordnet.
• ki_artikel_edges ist die Verbindungsschublade. Wenn Tavily bei der Recherche verwandte Webseiten findet, dokumentiert diese Tabelle die Verbindung: Welcher Artikel hat welche Quelle gefunden? Mit welchem Suchbegriff? Auf welchem Ranking-Platz? So entsteht im Hintergrund ein kleines Wissensnetz aus verlinkten Artikeln.

2.3 Die fünf Agenten im Detail

Agent 1 – Recherche (alle 2 Stunden): 22 parallele RSS-Feed-Leser versorgen das System mit Nachrichten aus der gesamten deutschsprachigen Tech- und Qualitätspresse: Heise, Golem, t3n, Computerwoche, FAZ, Handelsblatt, Spiegel, Süddeutsche und viele mehr. Jeder Feed ist mit einem Quellnamen gelabelt. Ein Postgres-Node mit Skip on Conflictverhindert doppelte Einträge; die URL-Normalisierung via JavaScript entfernt vor dem Speichern alle Tracking-Parameter.
Agent 2 – Bewertung (alle 4 Stunden): Ein Basic LLM Chain-Node mit GPT-4o-mini bewertet jeden neuen Artikel auf zwei Dimensionen: KI-Anwendungsrelevanz und KI-Entwicklungsbedeutung (je 0–10). Die Gesamtnote gewichtet Anwendungsrelevanz mit 60 % und Entwicklungsbedeutung mit 40 %. Zusätzlich ordnet die KI jeden Artikel einer von 12 vordefinierten Subkategorien zu.
Agent 3 – Content-Recherche (täglich): Artikel mit score_gesamt >= 7,5 werden tiefenrecherchiert. Der Workflow lädt den Volltext von der Quellseite, prüft die Textqualität und ergänzt mit bis zu 20 Tavily-Suchergebnissen. GPT-4o-mini fasst alles zu einem strukturierten Hintergrundtext zusammen.
Agent 4 – Artikel + Bild (täglich): Der Artikel mit dem höchsten Score geht an Claude Sonnet, der daraus einen rechtskonformen WordPress-Artikel schreibt. Gleichzeitig generiert Flux-2-Flex ein eigenes Coverbild im Editorial-Flat-Design-Stil.
Agent 5 – WordPress (täglich): Fertige Artikel landen zunächst als Entwurf in WordPress – und warten auf deine Freigabe. Das ist der Human-in-the-Loop-Kontrollpunkt.

2.4 Technologien & Kosten

Bei täglicher Publikation eines Artikels bleiben die monatlichen API-Kosten typischerweise unter 5 Euro – dank GPT-4o-mini für das hohe Volumen (Bewertung + Recherche) und Claude Sonnet nur für den einzelnen, täglich erscheinenden Artikel. Flux-2-Flex kostet ca. 1–2 Cent pro Bild, Tavily ist bis 1.000 Suchen/Monat kostenlos.

3 Umsetzung in n8n

3.1 Datenbank-Setup

Tanja: „Bevor wir die Agenten bauen, brauchen wir das Fundament. Die Datenbank.“
Ulf runzelt die Stirn: „Warum können wir nicht einfach alles in Excel speichern?“
Tanja: „Weil 500 Artikel pro Tag in Excel so aussehen wie ein Stadion nach dem Derbysieg – alles durcheinander, nichts mehr auffindbar.“
Bernd: „Ich hab mal alle Kundendaten in einer Excel-Datei gehabt, hat super funktioniert. Bis ich aus Versehen die falsche Spalte gelöscht hab.“
Tanja ignoriert ihn: „Wir nutzen PostgreSQL. Das ist eine Datenbank, die auf der NAS läuft, Dinge ordentlich wegschreibt und auf Anfrage blitzschnell wieder rausgibt. n8n redet mit ihr wie ein Büro mit seinem Aktenschrank.“

3.1.1 Die Verbindung herstellen (Credentials)

Tanja: „Keine Panik – das klingt komplizierter als es ist. Du musst n8n nur einmalig sagen, wo deine Datenbank wohnt und wie das Passwort lautet. Danach merkt es sich das.“

1. Logge dich in deine n8n-Oberfläche auf der NAS ein
2. Gehe links auf Start from scratch -> Add first step -> „+“ -> suche nach „Postgres“ -> wähle „Execute a SQL query“ aus -> Credential to connect with: „Create a new Credential“

Wie man n8n mit PostGres SQL Datenbank auf einer Synology Diskstation am Beispiel einer DS1621+ installiert findest Du in dem Artikel https://www.foundic.org/n8n-selbst-hosten-synology-nas-docker-installation.

3. Jetzt musst du die Daten eingeben, die du im Synology Container Manager findest unter Container -> postgres container -> Details
   • Host: IP-Adresse oder Containername (wenn im gleichen Projekt)
   • Database: Meistens postgres oder n8n_db (je nachdem, was bei der Installation als POSTGRES_DB angegeben wurde)
   • User: Der Name, den du vergeben hast (oft postgres oder admin)
   • Password: Dein festgelegtes Passwort

4. Klicke auf Save. Wenn oben ein grünes Schild mit „Connection tested successfully“ erscheint, steht die Leitung!
5. Nenne ihn oben links in der Workflow Übersicht: Set-up Database

3.1.2: Erste Tabellen in der Datenbank erstellen

Die Tabelle ki_artikel ist das zentrale digitale Gedächtnis deines Newsrooms – hier landen alle gesammelten Nachrichten, Bewertungen und der Veröffentlichungsstatus.
Stell dir vor, du richtest einen neuen Aktenschrank ein. Bevor du Dinge hineinlegen kannst, musst du die Fächer beschriften. Genau das macht das folgende SQL-Skript: Es legt die Fächerstruktur an.

1. Schließe das Credential-Fenster (oben rechts auf das X klicken).
2. Du befindest dich nun wieder im Fenster der Postgres-Node (Execute a SQL query), ggf. Doppel Klick auf „Execute a SQL query“
3. Lösche die 1 im Feld Query komplett heraus.
4. Kopiere das folgende SQL-Skript und füge es dort ein:

CREATE TABLE ki_artikel (
  -- Eindeutige ID
  id SERIAL PRIMARY KEY,

  -- Original-Daten
  url VARCHAR(500) UNIQUE NOT NULL,
  title TEXT NOT NULL,
  description TEXT,
  content TEXT, -- für später
  source VARCHAR(200) NOT NULL, -- z.B. 'Heise'
  published_date TIMESTAMP,
  image_url TEXT,
  source_type TEXT  -- z.B. 'rss'
  first_seen_at TIMESTAMPTZ NOT NULL DEFAULT now()
  url_normalized TEXT

  -- Workflow-Status
  status VARCHAR(50),

  -- Bewertung
  score_relevanz INTEGER,
  score_bedeutung INTEGER,
  score_gesamt DECIMAL(3,1),
  subkategorie VARCHAR(80) DEFAULT NULL,
  bewertung_begruendung TEXT,

  -- Zeitstempel
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Index für schnelle Abfragen (Top-News)
CREATE INDEX idx_published_date ON ki_artikel(status, published_date DESC);
CREATE INDEX ki_artikel_url_normalized_idx ON ki_artikel(url_normalized);

Klicke auf Execute step.

Danach erstellst du zwei weitere Tabellen. Die erste verbindet Artikel miteinander (ki_artikel_edges), die zweite speichert den angereicherten Redaktionsinhalt (ki_story).
Tabelle ki_artikel_edges – das Verbindungsnetz zwischen Artikeln:

CREATE TABLE IF NOT EXISTS ki_artikel_edges (
  id BIGSERIAL PRIMARY KEY,

  from_artikel_id BIGINT NOT NULL
    REFERENCES ki_artikel(id) ON DELETE CASCADE,

  to_artikel_id BIGINT NOT NULL
    REFERENCES ki_artikel(id) ON DELETE CASCADE,

  relation_type TEXT NOT NULL,     -- z.B. 'tavily_related'
  query TEXT,                      -- optional: Suchquery
  rank INT,                        -- Reihenfolge im Tavily Result
  score NUMERIC,                   -- optional: Tavily score/relevance
  retrieved_at TIMESTAMPTZ NOT NULL DEFAULT now(),

  UNIQUE (from_artikel_id, to_artikel_id, relation_type)
);

CREATE INDEX IF NOT EXISTS ki_artikel_edges_from_idx
  ON ki_artikel_edges(from_artikel_id);

CREATE INDEX IF NOT EXISTS ki_artikel_edges_to_idx
  ON ki_artikel_edges(to_artikel_id);

CREATE INDEX IF NOT EXISTS ki_artikel_edges_type_idx
  ON ki_artikel_edges(relation_type);

Tabelle ki_story – der Ort, an dem die fertigen Artikel reifen:

CREATE TABLE IF NOT EXISTS ki_story (
  id BIGSERIAL PRIMARY KEY,

  primary_artikel_id BIGINT NOT NULL
    REFERENCES ki_artikel(id) ON DELETE RESTRICT,

  content_enriched TEXT NOT NULL,
  enrichment_source TEXT,          -- 'direct' | 'search_llm'
  score_gesamt_enriched NUMERIC(4,2),
  tavily_link_count INTEGER,
  status TEXT NOT NULL DEFAULT 'DRAFT',
  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),

  -- WordPress
  wp_title TEXT,
  wp_content TEXT,
  wp_excerpt TEXT,
  wp_tags TEXT,
  image_file_path TEXT,
  wordpress_post_id BIGINT,
  wordpress_url TEXT
);

CREATE INDEX IF NOT EXISTS ki_story_primary_idx
  ON ki_story(primary_artikel_id);

3.1.3: Workflow-Status Logik

Das status-Feld in ki_artikel ist die Ampelanlage deines Systems. Jeder Agent schaut, ob eine Ampel auf sein Farbe steht, bearbeitet den Artikel und schaltet die Ampel weiter:

• NEU (Insert)
• BEWERTET (Bewertung fertig)
• ANGEREICHERT (Hintergrundtext fertig)
• PUBLISH_READY (Artikel gezogen/„reserviert“)
• PUBLISHED (WordPress veröffentlicht)
• PUBLISH_BLOCKED (wenn irgendwas rechtlich/technisch nicht passt)

3.2 Agent 1: Recherche über RSS Feeds

Ulf: „RSS-Feeds, sist das nicht Technologie von vor zwanzig Jahren?“
Tanja: „Fußball gibt es seit 150 Jahren, trotzdem ist es die effektivste Art, 22 Leute auf einem Feld zu koordinieren. RSS ist das Gleiche: simpel, robust, funktioniert überall.“
Bernd: „Ich habe gehört, RSS ist tot“.
Tanja: „Dann haben Heise, Spiegel, FAZ und die Süddeutsche es noch nicht mitbekommen. Die betreiben alle noch aktiv RSS-Feeds.“

3.2.1 Den Arbeitsplatz einrichten

1. Gehe zurück zur Workflow-Übersicht und klicke auf Create new workflow
2. Nenne ihn oben links: 1 Agent: Recherche über RSS Feeds
3. Klicke auf Add First Step und wähle Schedule Trigger
   • Trigger Interval: Hours
   • Stelle ihn zunächst auf Manual (= Custom Cron) – damit der Trigger beim Bauen nicht ständig feuert. Den echten Takt stellst du am Ende ein.
   • Hours Between Triggers: 2
   • Trigger at Minute: 0

3.2.2 Die Quellen anzapfen (RSS-Feed)

1. Klicke auf das + hinter dem Schedule-Trigger
2. Suche nach der Node RSS Feed Read
   • Node: rssFeedRead
   • URL: RSS-Feed eintragen (z.B. https://www.heise.de/rss/heise-atom.xml)
3. Klicke auf Test Step. Du solltest jetzt eine Liste mit Titeln und Links sehen
4. Du kannst beliebig viele RSS Feed Reader parallel in den Workflow setzen und mit dem Trigger verbinden. Klicke dazu auf den Ausgangspunkt des Triggers und dann auf den Eingangspunkt des jeweiligen RSS Feed Readers.

3.2.3 RSS Feed die Quelle zuordnen

1. Klicke auf das + Symbol am Ausgang deiner RSS-Nodes
2. Suche nach der Node Edit Fields (Brauchst diesen Node für jeden RSS-Feed)
3. Einstellung: * Klicke auf „Add Field“ -> „String“.
   • Node: Edit Fields
   • Name des Feldes: source_name -> String
   • Wert (Value): z.B. Heise
   • Include Other Input Fields: aktivieren
4. Wiederholung: diese zwei Knoten für alle Deine weitere RSS-Feeds (RSS Feed -> Edit Fields -> Wert: abc) die Du regelmäßig auslesen möchtest.

3.2.4 Archiv in Datenbank aufbauen

Jetzt zeigst du n8n, wo das Archiv liegt – und wie die Zeitungsschnipsel dort einsortiert werden. Denk an einen Bibliothekar, der eingehende Bücher nach einem festen Schema einräumt.

1. Klicke auf das + am Ausgang deiner Edit Fields-Nodes
2. Suche nach Postgres und wähle „Insert rows in a table“ aus:
   • Node: Insert rows in table
   • Credential to connect with: deine n8n-postgres-Verbindung aus Schritt 3.1.1
   • Operation: Insert
   • Schema: From list: public
   • Tabel: From list: ki_artikel
   • Mapping Column Mode: Map Each Column Manually (Daten einsortieren)
3. Jetzt kommt der wichtigste Teil: Du musst n8n sagen, welches RSS-Feld in welche Datenbankspalte gehört. Klicke auf Add Column und trage nacheinander folgende Zuordnungen ein:

Für url_normalized kopiere diesen JavaScript-Ausdruck in das Value-Feld:

{{ 
(() => {
  const raw = $json.link || $json.url || "";
  try {
    const u = new URL(raw.startsWith("http") ? raw : "https://" + raw);

    // Fragment entfernen
    u.hash = "";

    // Tracking-Parameter entfernen
    const dropExact = new Set([
      "fbclid","gclid","dclid","msclkid","igshid",
      "mc_cid","mc_eid","mkt_tok","yclid","cmpid"
    ]);

    for (const k of Array.from(u.searchParams.keys())) {
      const key = k.toLowerCase();
      if (key.startsWith("utm_") || dropExact.has(key)) {
        u.searchParams.delete(k);
      }
    }

    // Host & Protokoll normalisieren
    u.hostname = u.hostname.replace(/^www\./i, "").toLowerCase();
    u.protocol = "https:";

    // Trailing slash nur bei Root entfernen
    if (u.pathname === "/") u.pathname = "";

    u.search = u.searchParams.toString()
      ? "?" + u.searchParams.toString()
      : "";

    return u.toString();
  } catch (e) {
    return raw;
  }
})()
}}

Warum dieser Aufwand? Weil derselbe Artikel von Heise mit fünf verschiedenen Tracking-URLs auftauchen kann – ?utm_source=twitter, ?utm_campaign=newsletter usw. Ohne Normalisierung würde jede Variante als neuer Artikel landen. Mit diesem Code landen alle Varianten als ein einziger Datensatz.

4. Lösche alle anderen vorausgefüllten „Values to Update“, damit nur die oben definierten Felder geschrieben werden.
5. Ganz unten: Options → Add option → Skip on Conflict aktivieren. Damit wird ein Artikel, dessen URL bereits in der Datenbank liegt, einfach übersprungen statt einen Fehler zu werfen.
6. Testlauf: Klicke auf den orangefarbenen Button „Execute Workflow“. Was jetzt passieren sollte: n8n zieht die News aus den Feeds (grüne Zahlen erscheinen), schickt sie zur Postgres-Node (nächste grüne Zahl) und speichert sie auf deiner NAS. Wenn du die Zahlen siehst – Glückwunsch, dein erstes Archiv lebt.

3.2.5 Workflow veröffentlichen

Stelle den Schedule Trigger auf 2 Stunden und aktiviere den Workflow über Publish.

3.3 Agent 2: Redaktionelle Einzelbewertung

Ulf: „Okay, wir haben jetzt ein Archiv voller Artikel, aber wie wissen wir, welche davon gut sind?“
Tanja: „Indem wir eine KI fragen, die liest Titel und Beschreibung, gibt eine Note von 0 bis 10 und ordnet den Artikel einer Kategorie zu.“
Bernd schnaubt. „Ich bewerte das manuell. Mit Bauchgefühl. Das ist viel besser als jede KI.“
Tanja: „Du hast gestern einen Artikel über ‚KI in der Landwirtschaft‘ als Top-News markiert. Wir schreiben einen Blog über KI-Tools für Wissensarbeiter.“
Stille.
Bernd: „Es war ein interessanter Artikel“.

3.3.1 Den Workflow starten

1. Gehe zurück zur Workflow-Übersicht und klicke auf Create new workflow
2. Nenne ihn oben links: 2 Agent: Redaktionelle Einzelbewertung
3. Füge einen Schedule Trigger hinzu:
   • Trigger Interval: Hours
     Stelle sie für den Anfang auf Manual (= Custom (Cron)), damit wir beim Bauen nicht ständig neue Daten ziehen. Später stellen wir sie auf „Alle 4 Stunden“
   • Hours Between Triggers: 4
   • Trigger at Minute: 0

3.3.2 Datensatz aus Datenbank auslesen

1. Füge eine Postgres-Node „Execute a SQL query“ hinzu:
   • Credtial to connect with: n8n-postgres
   • Query:

SELECT id, title, description, url 
FROM ki_artikel 
WHERE status = 'NEU' 
LIMIT 5;

Mit LIMIT 5 starten wir ruhig – zum Testen reichen fünf Artikel. Später kannst du das Limit hochsetzen.

3.3.3 Loop einbauen

Die KI soll jeden Artikel einzeln bewerten – nicht alle auf einmal. Dafür kommt ein Loop-Node:

• Node: Loop Over Items
• Bartch Size: 1
• Done: bleibt leer
• Loop: nächster Knoten
  Stell es dir vor wie ein Fließband: Artikel rein, bewerten, nächster Artikel.

3.3.4 Basic LLM Chain

Bernd: „Moment, wenn wir schon KI einsetzen, dann richtig. Ich würde hier GPT-5.2 nehmen. Das Beste vom Besten.“
Tanja dreht sich zu ihm. „Wie viele Artikel bewertet Agent 2 pro Tag?“
Bernd zuckt die Schultern. „Weiß ich nicht. Hundert? Zweihundert?“
Tanja: „Nehmen wir 150. GPT-5.2 kostet etwa $15 pro Million Input-Token. GPT-4o-mini kostet $0,15 – also hundertmal weniger.“ Sie schreibt zwei Zahlen auf einen Zettel. „Pro Artikel gehen wir von rund 500 Token für Titel und Beschreibung aus, plus nochmal 200 Token Ausgabe. Bei 150 Artikeln täglich und 30 Tagen im Monat kommst du mit GPT-4o auf etwa 33 Euro im Monat. Nur für die Bewertung.“
Ulf: „Und mit mini?“.
Tanja: „33 Cent“
Kurze Pause.
Bernd: „Aber, GPT-5.2 ist doch viel schlauer.“
Tanaj: „Für diese Aufgabe brauchen wir kein Genie, wir fragen: Ist dieser Artikel relevant? Welche Kategorie? Begründung in 25 Wörtern. Das ist eine strukturierte Klassifikationsaufgabe – kein Raketenantrieb, kein Gedicht, keine Rechtsberatung. GPT-4o-mini löst das genauso zuverlässig wie der große Bruder. Der Unterschied: Geschwindigkeit und Preis.“
Ulf: „Wann würde man dann das große Modell nehmen?“
Tanja: „Agent 4. Artikel schreiben. Da steckt Nuancen drin, Argumentation, Stil, Urheberrechtssensibilität. Dafür nehmen wir Claude Sonnet. Aber für ‚Note 0 bis 10 vergeben‘ – da ist mini schlau genug und 100-mal günstiger.“
Bernd schaut auf seinen Bildschirm. „Ich hätte trotzdem das große genommen.“
Tanj: „Das weiß ich, deshalb entscheide ich das.“

Jetzt kommt das Herzstück von Agent 2. Warum der „Basic LLM Chain“ und nicht der „AI Agent“? Ganz einfach: Der AI Agent ist wie ein Allrounder, der theoretisch Werkzeuge benutzen, recherchieren und selbst entscheiden kann. Wir brauchen hier aber nur einen einzigen Durchgang: Text rein -> Prompt anwenden -> JSON raus. Der Basic LLM Chain macht genau das – schneller und günstiger.

• Node: Basic LLM Chain
• Source for Prompt (User Message): Define below
• Prompt (User Message):

Rolle: Du bist eine kritische Analystin und KI-Trend-Scout.
Aufgabe: Bewerte den folgenden Artikel nach seinem Nutzen für interessierte KI-Anwender, die KI im Alltag (privat & beruflich) besser einsetzen und zukünftige Entwicklungen verstehen wollen. Ordne den Artikel zudem präzise den vorgegebene Subkategorien zu.

Input-Daten:
Titel: {{ $json.title }}
Beschreibung: {{ $json.description }}

---

### 1. Strenge Bewertungs-Logik (Skala 0 bis 10):

KI-Anwendungsrelevanz (Nutzwert heute):
- 0–1: Kein KI-Bezug oder rein abstrakt / technisch ohne Nutzenableitung.
- 2–4: KI wird erwähnt, aber ohne konkrete Nutzungsideen.
- 5–6: Liefert Beispiele, Tools, Produktivitäts- oder Alltagsbezug.
- 7–8: Klare, übertragbare Use-Cases (Arbeit, Lernen, Organisation, Kreativität).
- 9–10: Hoher Mehrwert: verändert konkret, wie man KI sinnvoll nutzt.

KI-Entwicklungsbedeutung (Blick in die Zukunft):
- 0–1: Unbedeutend oder reine Randnotiz.
- 2–4: Allgemeine Entwicklung ohne Tiefgang.
- 5–6: Relevanter Trend (z. B. Copilots, Regulierung, KI im Alltag).
- 7–8: Wichtige Weichenstellung (z. B. neue Einsatzfelder, starke Verbreitung).
- 9–10: Paradigmenwechsel mit klaren Folgen für Nutzer:innen.

---

### 2. Subkategorien (Wähle EXAKT einen Namen aus dieser Liste):

1. Anwendungsfälle & Best Practices (Konkretisierung: Praxisbeispiele, Alltag/Beruf, Produktivitäts-Szenarien)
2. Prompting (Konkretisierung: Operative Assets: Gebrauchsfertige Vorlagen, konkrete Befehlsketten und „Copy & Paste“-Prompts für sofortige Ergebnisse)
3. Lernen & Skill-Aufbau (Konkretisierung: Methodisches Wissen: Tutorials, Lernpfade, Konzepte wie Chain-of-Thought, Methodik, Erklärungen zum „Mitdenken“)
4. Tools & Produkt-Updates (Konkretisierung: Software-Releases, neue Funktionen, UI-Änderungen)
5. Automatisierung & Agenten (Konkretisierung: n8n/Zapier Workflows, Agent-Flows, APIs, Prozessautomatisierung)
6. KI-Kreativität (Konkretisierung: Fokus auf generative Medien-Erstellung: Bild, Video, Audio, Design jenseits reiner Text-Assistenz)
7. News & Entwicklungen (Konkretisierung: Markt- & Strategie-News, Trends, allgemeine Einordnung)
8. Modelle & Open Source (Konkretisierung: LLMs, Open-Source-Modelle, GitHub-Projekte, technischer Deep Dive)
9. Hardware & Lokale KI (Konkretisierung: Gadgets, AI-PCs, Chips wie Nvidia/NPU, Local-AI-Setups)
10. Sicherheit & Privacy (Konkretisierung: Datenschutz, Security, sichere KI-Nutzung)
11. Ethik, Recht & Politik (Konkretisierung: AI Act, Regulierung, Governance, Deepfakes)
12. Kein KI-Fokus (Fokus: Default-Kategorie für alle Inhalte ohne klaren KI-Nutzen oder KI-Bezug, allgemeine Technik-News oder Off-Topic)

WICHTIG: Wenn die Sub-Kategorie "Kein KI-Fokus" gewählt wird, dann müssen Anwendungsrelevanz <= 1 UND Entwicklungsbedeutung <= 1 sein.

---

### 3. Ausgabe-Format & Validierung:
Erzeuge ausschließlich ein valides JSON-Objekt ohne Markdown-Formatierung.

WICHTIG: Das Feld "subkategorie" MUSS buchstabengetreu mit einem der oben genannten 12 Namen übereinstimmen. Ändere keine Sonderzeichen, erfinde keine neuen Namen und achte auf exakte Groß-/Kleinschreibung.

STRICT OUTPUT RULES:
- Gib GENAU EIN JSON-Objekt aus.
- Kein Text vor oder nach dem JSON.
- KEIN Komma nach der schließenden }.
- Verwende ausschließlich doppelte Anführungszeichen für JSON.

{
  "anwendungsrelevanz": Zahl,
  "entwicklungsbedeutung": Zahl,
  "subkategorie": "EXAKTER_NAME_AUS_LISTE",
  "begruendung": "Maximal 25 Wörter. Begründung der Kategorie + Begründung der  Anwendungsrelevanz und Entwicklungsbedeutung."
}

Verbinde den Basic LLM Chain mit dem OpenAI Chat Model:

• Node: OpenAI Chat Model
• Credential to connect with: OpenAI account
• Model: gpt-4o-mini
• Use Response API: active

3.3.5 Code in JavaScript

GPT-4o-mini liefert manchmal JSON mit Markdown-Umrandung zurück (Backticks, json-Tags). Dieser Code-Node räumt das auf und berechnet den Gesamtscore:

• Node: Code in JavaScript
• Mode: Run Once for Each ITem
• Language: JavaScript

let raw = $json.text;
// Entfernt Backticks und säubert den Text
let clean = raw.replace(/```json/g, "").replace(/```/g, "").trim().replace(/,\s*$/, "");
let data = JSON.parse(clean);

// Falls die KI es in "output" verpackt hat
if (data.output) data = data.output;

// Nur EIN return-Block mit allen Feldern:
return {
  anwendungsrelevanz: Number(data.anwendungsrelevanz),
  entwicklungsbedeutung: Number(data.entwicklungsbedeutung),
  subkategorie: data.subkategorie,
  begruendung: data.begruendung,
  // Hier passiert die wichtige Berechnung für DECIMAL(3,1)
  score_gesamt: (Number(data.anwendungsrelevanz)*6 + Number(data.entwicklungsbedeutung)*4)/10
};

Die Formel am Ende ist keine Magie: Anwendungsrelevanz zählt sechsfach, Entwicklungsbedeutung vierfach. Das teilen wir durch 10 – fertig ist ein Score zwischen 0 und 10, gespeichert als DECIMAL(3,1).

3.3.6 Merge Combine

Jetzt haben wir ein Problem: Der Bewertungs-Code kennt nur die KI-Ergebnisse, aber nicht mehr die Datenbank-ID des Artikels. Ohne die ID können wir den Datensatz nicht aktualisieren. Der Merge-Node löst das: Er fügt die Datenbankfelder (inkl. id) und die Bewertungsfelder zu einem gemeinsamen Datensatz zusammen.

• Node: Merge Combine
• Mode: Combine
• Combine by: Position
• Number of Inputs: 2
  Verbinde die zwei Eingänge: Ausgang „loop“ des Loop Over Items-Nodes → Eingang 1 des Merge; Ausgang des Code-Nodes → Eingang 2 des Merge.

3.3.7 In Datenbank speichern

1. Füge einen Postgres-Node am Ende hinzu:
   • Node: Update rows in a table
   • Credential to connect with: n8n-postgres
   • Operation: Update
   • Schema: public
   • Table: ki_artikel
   • Mapping Column Mode: Map Each Column Manually
   • Columns to match on: id

Verbinde den Ausgang dieses Nodes zurück mit dem Eingang des Loop Over Items-Nodes – so läuft die Schleife für alle abgerufenen Artikel durch.

3.3.8 Workflow veröffentlichen

Stelle den Schedule Trigger auf 4 Stunden und aktiviere den Workflow über Publish.

3.4 Dashboard mit Metabase (Optional)

Ulf: „Moment, ich will mal sehen, was da in meiner Datenbank passiert. Wie schaue ich da rein?“
Tanja: „Mit Metabase, das ist ein Dashboard-Tool, das sich direkt an deine PostgreSQL-Datenbank hängt. Du kannst dann Fragen stellen wie: ‚Wie viele Artikel wurden heute bewertet?‘ und bekommst eine Tabelle oder ein Diagramm zurück.“
Bernd: „Ich guck einfach direkt in die Datenbank, mit dem Terminal. Ist professioneller.“
Ulf: „Du hast letzte Woche eine Tabelle aus Versehen gelöscht, weil du ein Leerzeichen vergessen hast.“
Bernd hustet.

Metabase brauchst du nicht zwingend – die Agenten laufen auch ohne. Aber es ist hilfreich, wenn du einen schnellen Überblick willst: Wie viele Artikel wurden eingelesen? Wie verteilen sich die Scores? Welche Kategorien dominieren?

3.4.1 Ordnerstruktur vorbereiten

Metabase möchte seine eigenen Einstellungen (welche Fragen du gestellt hast, wie dein Dashboard aussieht) irgendwo speichern. Standardmäßig macht es das innerhalb des Containers. Wenn du den Container löschst oder updatest, ist dein Dashboard weg.

Damit dein Dashboard „ewig“ lebt, solltest du unter Volume-Einstellungen (im nächsten Schritt) einen Ordner auf deiner NAS verknüpfen:

• Ordner: Erstelle auf deiner NAS einen Ordner docker/metabase.

3.4.2 Metabase einrichten

• Image Name: metabase/metabase
• Port: standardmäßig 3000

Vorgehensweise:

1. Lade das Image im Container Manager auf der Synology herunter

2. Führe das Image aus: metabase/metabase:latest → Ausführen

• Containername: metabase-newsroom
• Port: 3000
• Volume-Einstellungen: + Ordner hinzufügen
  • Ordner docker/metabase auswählen (vorher auf der NAS erstellen)
  • Mount-Pfad: /metabase.db eintragen

3. Umgebungsvariable GIT_COMMIT_SHA: unknown eintragen

4. Container starten

Wichtig: Falls die Firewall auf deiner Diskstation aktiv ist, lege eine Regel für Port 3000 (Protokoll TCP) an – sonst kommst du über den Browser nicht auf Metabase.

Metabase läuft unter http:// (nicht https://). Öffne http://<deine-Synology-IP>:3000 im Browser. Beim ersten Start führt dich ein Setup durch die Datenbankverbindung:

1. Database type: PostgreSQL
2. Display name: z. B. „KI News Datenbank“
3. Host: Containername deiner Postgres-Instanz (z. B. n8n_db)
4. Port: 5432
5. Database name: postgres
6. Username: dein Postgres-Benutzername
7. Password: dein Postgres-Passwort

Deine erste SQL-Auswertung erstellst du über + NEU -> >_ SQL-Abfrage. Diese Query gibt dir einen ersten Tagesüberblick:

SELECT 
    DATE(created_at) AS datum,
    -- 1) Wie viele RSS-Feeds wurden eingelesen?
    COUNT(*) AS eingelesen_gesamt,
    -- 2) Wie viele davon wurden bewertet?
    COUNT(*) FILTER (WHERE status = 'bewertet') AS bewertet,
    -- 3) Verteilung der Scores (Umwandlung in Zahlenwert mit ::float)
    COUNT(*) FILTER (WHERE score_gesamt::float BETWEEN 0 AND 2.9) AS "Score_0_bis_2",
    COUNT(*) FILTER (WHERE score_gesamt::float BETWEEN 3 AND 7.9) AS "Score_3_bis_7",
    COUNT(*) FILTER (WHERE score_gesamt::float >= 8) AS "Score_8_bis_10"
FROM ki_artikel
GROUP BY DATE(created_at)
ORDER BY datum DESC;

3.5 Agent 3: Content-Recherche

Ulf: „Wir haben jetzt bewertete Artikel, was kommt jetzt?“
Tanja: „Jetzt wird es interessant, Agent 3 nimmt die besten Artikel – die mit Score 7,5 oder höher – und recherchiert dazu. Er lädt den Originaltext, sucht verwandte Quellen im Web und lässt GPT-4o-mini daraus einen strukturierten Hintergrundtext schreiben.“
Ulf: „Moment, kann die KI nicht einfach selbst im Internet suchen? Warum der Umweg über Tavily?“
Tanja: „Gute Frage. Schauen wir uns das an.“

3.5.1 Den Workflow starten

1. Gehe zurück zur Workflow-Übersicht und klicke auf Create new workflow
2. Nenne ihn oben links: A3 Agent: Content-Recherche
3. Füge einen Schedule Trigger hinzu:
   • Trigger Interval: Hours
   • Stelle zunächst auf Manual zum Testen
   • Hours Between Triggers: 23
   • Trigger at Minute:

3.5.2 Datensatz aus Datenbank auslesen

1. Füge eine Postgres-Node hinzu:
   • Node: Execute a SQL query
   • Credential to connect with: n8n-postgres
   • Query:

SELECT a.id, a.url, a.title, a.description
FROM ki_artikel a
LEFT JOIN ki_story s ON s.primary_artikel_id = a.id
WHERE a.score_gesamt >= 7.5
  AND s.id IS NULL
  AND (a.status IS NULL OR a.status <> 'ANGEREICHERT')
LIMIT 5;

Hinweis: Wir holen nur Artikel mit einem Gesamtscore von mindestens 7.5 – das sind die wirklich relevanten Treffer, die eine aufwendige Recherche wert sind. Das LIMIT 5 hält die Laufzeit beim ersten Testen überschaubar.

Der LEFT JOIN mit WHERE s.id IS NULL ist eine elegante Abkürzung: Er findet alle Artikel, zu denen es noch keine Story gibt – also genau die, die noch bearbeitet werden müssen.

Führe außerdem diese zwei Index-Befehle einmalig direkt in der Datenbank aus, um sie abzusichern:

CREATE UNIQUE INDEX IF NOT EXISTS ki_story_primary_uniq ON ki_story(primary_artikel_id);

und

CREATE UNIQUE INDEX IF NOT EXISTS idx_ki_artikel_url_normalized ON ki_artikel(url_normalized);

3.5.3 Loop einbauen

Damit n8n jeden Artikel einzeln abarbeitet, kommt als nächstes der Loop-Knoten:

• Node: Loop Over Items (Split In Batches)
• Batch Size: 1
• Knoten-Ausgang Done: bleibt leer
• Konten-Ausgang Loop: nächster Knoten

3.5.4 Website-Inhalt abrufen

Wir versuchen zunächst, den Volltext direkt von der Quellwebsite zu laden – als würde ein Mensch den Artikel öffnen und lesen.

1. Füge einen HTTP Request-Node hinzu:
   • Method: GET
   • URL: ={{ $json.url }}
   • Add Options → Response Format: Text
   • Send Headers: ON

Diese Header sind wichtig: Viele Websites liefern schönere Inhalte, wenn die Anfrage wie ein echter Browser-Aufruf aussieht – statt wie ein nackter Bot.

2. Füge einen Code Node (JavaScript) hinzu, der das rohe HTML in brauchbaren Fließtext verwandelt:

// n8n Code node (JavaScript)
// Erwartet HTML im Feld: $json.data (aus HTTP Request)

const html = ($json.data || '').toString();

// 1) Skripte/Styles entfernen
let cleaned = html
  .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, ' ')
  .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, ' ');

// 2) Häufige Layout-Blöcke grob entfernen (optional, aber hilfreich)
cleaned = cleaned
  .replace(/<nav\b[^<]*(?:(?!<\/nav>)<[^<]*)*<\/nav>/gi, ' ')
  .replace(/<header\b[^<]*(?:(?!<\/header>)<[^<]*)*<\/header>/gi, ' ')
  .replace(/<footer\b[^<]*(?:(?!<\/footer>)<[^<]*)*<\/footer>/gi, ' ');

// 3) HTML-Tags -> Text (mit Zeilenumbrüchen an sinnvollen Stellen)
cleaned = cleaned
  .replace(/<\/(p|div|br|li|h1|h2|h3|h4|h5|section|article)>/gi, '\n')
  .replace(/<[^>]+>/g, ' ');

// 4) HTML Entities (minimal)
cleaned = cleaned
  .replace(/&nbsp;/g, ' ')
  .replace(/&amp;/g, '&')
  .replace(/&quot;/g, '"')
  .replace(/&#39;/g, "'")
  .replace(/&lt;/g, '<')
  .replace(/&gt;/g, '>');

// 5) Whitespace normalisieren
cleaned = cleaned
  .replace(/\r/g, '')
  .replace(/[ \t]+/g, ' ')
  .replace(/\n{3,}/g, '\n\n')
  .trim();

// 6) Optional: begrenzen (für DB/LLM)
const maxLen = 20000;
const content_candidate = cleaned.slice(0, maxLen);
const content_candidate_len = content_candidate.length;

// --- Qualitäts-Check ---
const words = content_candidate.split(/\s+/).filter(w => w.length > 3);
const wordCount = words.length;

const avgWordLength =
  words.reduce((sum, w) => sum + w.length, 0) / (wordCount || 1);

const badMarkers = [
  'cookie', 'zustimmen', 'abo', 'newsletter', 'anzeigen',
  'karriere', 'impressum', 'datenschutz', 'suche', 'login',
  'heise+', 'jobs'
];

const badHits = badMarkers.filter(m =>
  content_candidate.toLowerCase().includes(m)
).length;

const content_quality_ok =
  content_candidate_len > 1500 &&
  wordCount > 250 &&
  avgWordLength > 4 &&
  badHits < 5;

return [{
  ...$json,
  content_candidate,
  content_candidate_len,
  content_quality_ok,
  content_word_count: wordCount,
  content_avg_word_len: avgWordLength,
  content_bad_hits: badHits,
}];

Das Ergebnis enthält das Flag content_quality_ok. Ein brauchbarer Text braucht mindestens 1.500 Zeichen, 250 Wörter und darf nicht von Boilerplate-Begriffen wie „Cookie“ oder „Impressum“ dominiert sein. Das Flag dient als Metainformation; die Tavily-Recherche läuft in jedem Fall danach – der Web-Kontext ist die eigentliche Basis für den LLM-Text.

3.5.5 Warum Tavily statt OpenAI-Websuche?

Ulf: „Kurze Frage, kann ich nicht einfach GPT mit Internetzugang nehmen? Dann brauche ich Tavily gar nicht.“
Tanja: „Du kannst, aber schau dir kurz die Kosten an.“

Ulf: „Okay, ich versteh das noch nicht ganz,“ und zeigt auf die Tabelle. „Serper und Brave liefern auch Suchergebnisse. Warum ist Tavily besser?“
Tanja: „Stell dir vor, du schickst einen Praktikanten los, um Informationen über ein Thema zu sammeln. Serper und Brave kommen zurück mit einem Stapel Zeitungsadressen. Tavily kommt zurück mit den ausgeschnittenen Artikeln. Bereits lesbar, bereits sortiert.“
Ulf runzelt die Stirn. „Also liefert Tavily den Inhalt der Seiten gleich mit?“
Tanja: „Genau. Serper und Brave geben dir nur Links – du musst jede Seite noch selbst aufrufen und den Text extrahieren. Tavily liefert bereits aufbereitete Textauszüge. GPT-4o-mini bekommt also sauberen Kontext statt rohem HTML-Müll. Das spart Token – und bessere Eingabe bedeutet bessere Ausgabe.“
Bernd: „Klingt nach wenig Unterschied, ich würde einfach OpenAIs eingebaute Websuche nehmen. Weniger Gedöns.“
Tanja: „Kostet dich 3 bis 10 Cent pro Suche, Tavily ist bis tausend Suchen im Monat kostenlos. Danach 1,5 Cent. Das ist Faktor 10 bis 30 günstiger, bei gleicher oder besserer Qualität für unseren Anwendungsfall.“
Ulf: „Tausend Suchen reichen uns?“
Tanja: „Wir recherchieren täglich für maximal einen Artikel, mit bis zu 20 Tavily-Treffern pro Durchlauf. Das sind rund 600 Suchen im Monat. Passt locker ins kostenlose Kontingent.“
Bernd tippt kurz auf seinem Handy. „Okay, Tavily.“
Tanja: „Danke“.

3.5.6 Tavily Search einrichten

1. Erstelle dir einen Account auf app.tavily.com und kopiere deinen API Key
2. Füge in n8n den Node Search: Tavily hinzu
3. Erstelle unter Credential to connect with ein neues Credential mit deinem API Key
4. Konfiguriere den Node:
   • Query:

   {{ 
  (
    ($('Execute a SQL query').item.json.title || '') + ' ' + 
    ($('Execute a SQL query').item.json.description || '')
  ).slice(0, 380)
}}

4. Konfiguriere den Node:
   • Add Options → Search Depth: Advanced 
   • Add Options → Max Results: 20

Die Query kombiniert Titel und Beschreibung des Artikels und schneidet bei 380 Zeichen ab. Mit Advanced und 20 Ergebnissen holen wir das Maximum aus dem Tavily-Free-Kontingent.

3.5.7 Schlechte URLs aussortieren

Tavily liefert manchmal SEO-Schrottseiten, Feed-Aggregatoren oder themenfremd. Ein Code-Node filtert diese heraus, bevor sie die Datenbank verschmutzen:

• Node: Code (JavaScript)
• Mode: Run Once for All Items

const input = $input.first().json;
const list = Array.isArray(input.results) ? input.results : [];

// --- Konfiguration ---
const BLOCKED_DOMAINS = [
  'feed-reader.net', 'rssingn.com', 'finanztrends.de',
  'it-daily.net', 'possible.fm', 'edu.ly',
];

const BAD_TITLE_PATTERNS = [
  'die besten', 'tools im vergleich', 'im vergleich', 'ranking', 'best of',
];

const MIN_CONTENT_LENGTH = 250;
const MIN_SCORE = 0.55;

function host(u) {
  try { return new URL(u).hostname.replace(/^www\./, ''); } catch { return ''; }
}

const kept = [];
for (const r of list) {
  const url = String(r.url || '').toLowerCase();
  const title = String(r.title || '').toLowerCase();
  const content = String(r.content || '').toLowerCase();
  const h = host(url);

  let reason = null;
  if (!url || !title) reason = 'missing url/title';
  else if (BLOCKED_DOMAINS.some(d => h.includes(d))) reason = 'blocked domain';
  else if (BAD_TITLE_PATTERNS.some(p => title.includes(p))) reason = 'seo/list title';
  else if (content.length < MIN_CONTENT_LENGTH) reason = 'too short content';
  else if (typeof r.score === 'number' && r.score < MIN_SCORE) reason = 'low score';

  if (!reason) kept.push({ ...r, _quality_flag: 'accepted' });
}

// Fallback: wenn alles rausfliegt, nimm Top 5 nach Score
const final = kept.length > 0
  ? kept
  : [...list].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, 5)
      .map(r => ({ ...r, _quality_flag: 'fallback' }));

return final.map(r => ({
  json: {
    ...r,
    _debug: {
      input_count: list.length,
      kept_count: kept.length,
    }
  }
}));

Der Fallback am Ende ist wichtig: Wenn alle Treffer rausgefiltert würden, nimmt der Code trotzdem die Top 5 nach Score – damit der Workflow nie komplett leer weiterläuft.

3.5.8 Tavily-Treffer in der Datenbank speichern

Die gefundenen Quellen werden doppelt verwertet: als Kontext für das LLM (nächster Schritt) und als eigene Datensätze in der Datenbank. Dafür brauchen wir drei Nodes hintereinander.

Node 1: Prepare Tavily Results (Code in JavaScript)
Dieser Code normalisiert die URLs der Tavily-Treffer und bereitet die Felder für die Datenbank vor – analog zur URL-Normalisierung aus Agent 1:

function normalizeUrl(input) {
  try {
    const url = new URL(input.startsWith('http') ? input : 'https://' + input);
    url.hash = '';
    const dropKeys = new Set(['fbclid','gclid','mc_cid','mc_eid','msclkid','utm_source']);
    for (const k of Array.from(url.searchParams.keys())) {
      if (k.toLowerCase().startsWith('utm_') || dropKeys.has(k.toLowerCase()))
        url.searchParams.delete(k);
    }
    url.hostname = url.hostname.replace(/^www\./i, '').toLowerCase();
    url.protocol = 'https:';
    if (url.pathname === '/') url.pathname = '';
    return url.toString();
  } catch (e) { return input; }
}

function extractHost(input) {
  try { return new URL(input).hostname.replace(/^www\./i, '').toLowerCase(); }
  catch (e) { return 'unknown'; }
}

const fromId = $('Execute a SQL query').item?.json?.id ?? null;
const results = items.every(it => typeof it?.json?.url === 'string')
  ? items.map(it => it.json)
  : (Array.isArray(items?.[0]?.json?.results) ? items[0].json.results : []);

return results.filter(r => r?.url).slice(0, 10).map((r, idx) => {
  const norm = normalizeUrl(r.url);
  const host = extractHost(norm || r.url);
  return { json: {
    from_artikel_id: fromId,
    relation_type: 'tavily_related',
    query: items?.[0]?.json?.query ?? '',
    rank: idx + 1,
    score: r.score ?? null,
    url: r.url,
    url_normalized: norm,
    title: r.title ?? '(no title)',
    description: (r.content ?? '').slice(0, 800),
    source: host,
    source_type: 'tavily',
  }};
});

Node 2: Upsert Tavily Article (Postgres – Execute a SQL query)
Jeder gefundene Treffer landet als eigener Datensatz in ki_artikel. Durch ON CONFLICT wird ein bereits bekannter Artikel nicht doppelt eingetragen, sondern nur fehlende Felder ergänzt:

INSERT INTO ki_artikel (
  url, url_normalized, title, description,
  source, published_date, image_url, source_type, status, first_seen_at
)
VALUES (
  '{{ ($json.url || "").replace(/'/g, "''") }}',
  '{{ ($json.url_normalized || "").replace(/'/g, "''") }}',
  '{{ ($json.title || "").replace(/'/g, "''") }}',
  '{{ ($json.description || "").replace(/'/g, "''") }}',
  '{{ ($json.source || "").replace(/'/g, "''") }}',
  NULL, NULL, 'tavily', 'ANGEREICHERT', now()
)
ON CONFLICT (url_normalized)
DO UPDATE SET
  title       = COALESCE(NULLIF(ki_artikel.title,''), EXCLUDED.title),
  description = COALESCE(NULLIF(ki_artikel.description,''), EXCLUDED.description),
  source      = COALESCE(NULLIF(ki_artikel.source,''), EXCLUDED.source),
  status      = COALESCE(NULLIF(ki_artikel.status,''), 'ANGEREICHERT')
RETURNING id;

Node 3: Upsert Tavily Edge (Postgres – Execute a SQL query)
Die Verbindung zwischen dem Ausgangsartikel und dem gefundenen Tavily-Treffer wird in ki_artikel_edges gesichert:

INSERT INTO ki_artikel_edges (
  from_artikel_id, to_artikel_id, relation_type, query, rank, score, retrieved_at
)
VALUES (
  {{ $node["Prepare Tavily Results"].json.from_artikel_id }},
  {{ $node["Upsert Tavily Article"].json.id }},
  '{{ (($node["Prepare Tavily Results"].json.relation_type) || "tavily_related").replace(/'/g, "''") }}',
  '{{ (($node["Prepare Tavily Results"].json.query) || "").replace(/'/g, "''") }}',
  {{ $node["Prepare Tavily Results"].json.rank || 1 }},
  {{ $node["Prepare Tavily Results"].json.score ?? 'NULL' }},
  now()
)
ON CONFLICT (from_artikel_id, to_artikel_id, relation_type)
DO UPDATE SET
  rank         = EXCLUDED.rank,
  score        = EXCLUDED.score,
  query        = EXCLUDED.query,
  retrieved_at = now();

3.5.9 LLM-Kontext aufbereiten

Parallel zur Datenbankspeicherung bereitet ein Edit Fields-Node den kombinierten Kontext für GPT-4o-mini auf:

• Node: Edit Fields
• Field Name: llm_context
• Type: String
• Value (Expression):

=RSS ARTICLE
Title: {{ $('Loop Over Items').item.json.title }}
Description: {{ $('Loop Over Items').item.json.description }}

WEB SEARCH CONTEXT
={{
  "RSS ARTICLE\nTitle: " + 
  $('Loop Over Items').item.json.title + 
  "\nDescription: " + 
  $('Loop Over Items').item.json.description +
  "\n\nWEB SEARCH CONTEXT\n" + 
  ($node["Search: Tavily"].json.results || [])
    .slice(0, 10)
    .map((r, i) => "[Source " + (i+1) + "]\n" + (r.content || ""))
    .join("\n\n")
}}

Damit hat die KI sowohl den Original-RSS-Artikel als auch bis zu 10 aufbereitete Webseitentexte aus Tavily als Kontext.

3.5.10 Hintergrundtext mit GPT-4o-mini erstellen

• Node: Basic LLM Chain
• Source for Prompt: Define below
• Prompt (User Message):

Du erhältst einen Artikel aus einem RSS-Feed sowie zusätzlichen Web-Kontext.

Aufgabe:
- Beschreibe das Thema inhaltlich breiter und tiefer.
- Erkläre Hintergründe, technische Zusammenhänge und Einordnung.
- Struktur: 1) Kurzüberblick (3-4 Sätze) 2) Details (5-10 Bulletpoints) 3) Bedeutung/Implikationen (3 Bulletpoints).
- Keine Quellenangaben, keine Spekulationen.

TEXT:
{{ $json.llm_context }}

Den Basic LLM Chain mit dem OpenAI Chat Model verbinden:

• Node: OpenAI Chat Model
• Credential to connect with: OpenAI account
• Model: gpt-4o-mini

3.5.11 Story-Felder aufbereiten

Ein Edit Fields-Node fasst das LLM-Ergebnis zusammen mit Metadaten aus dem Loop:

• Node: Edit Fields (Name: Edit Fields: ki_story)

Der score_gesamt_enriched kombiniert den ursprünglichen Bewertungsscore mit der Anzahl brauchbarer Tavily-Quellen – je mehr gute Quellen gefunden wurden, desto höher steigt der Score leicht an.

3.5.12 Story in Datenbank speichern

• Node: Postgres – Execute a SQL query (Name: Upsert Story (ki_story))

INSERT INTO ki_story (
  primary_artikel_id,
  content_enriched,
  enrichment_source,
  tavily_link_count,
  score_gesamt_enriched,
  status,
  updated_at
)
VALUES (
  {{ $json.id }},
  '{{ ($json.content_enriched || "").replace(/'/g, "''") }}',
  '{{ ($json.enrichment_source || "").replace(/'/g, "''") }}',
  {{ parseFloat($json.tavily_link_count) || 0 }},
  {{ parseFloat($json.score_gesamt_enriched) || 0 }},
  'ANGEREICHERT',
  now()
)
ON CONFLICT (primary_artikel_id)
DO UPDATE SET
  content_enriched      = EXCLUDED.content_enriched,
  enrichment_source     = EXCLUDED.enrichment_source,
  tavily_link_count     = EXCLUDED.tavily_link_count,
  score_gesamt_enriched = EXCLUDED.score_gesamt_enriched,
  updated_at            = now();

3.5.13 Status aktualisieren und Loop schließen

Zum Abschluss wird der Status des Artikels in ki_artikel auf ANGEREICHERT gesetzt, damit Agent 4 ihn im nächsten Schritt aufgreifen kann.

1. Füge einen Postgres-Node hinzu:
   • Node: Update rows in a table
   • Credential to connect with: n8n-postgres
   • Operation: Update
   • Schema: public
   • Table: ki_artikel
   • Mapping Column Mode: Map Each Column Manually
   • Columns to match on: id

2. Verbinde den Ausgang dieses Nodes zurück mit dem Eingang von „Loop Over Items“, damit alle weiteren Artikel aus der Datenbank der Reihe nach abgearbeitet werden.

3.5.14 Workflow veröffentlichen

Stelle den Schedule Trigger auf 23 Stunden und aktiviere den Workflow über Publish. Agent 3 läuft damit einmal täglich, reichert alle Artikel mit score_gesamt >= 7.5 an und übergibt sie bereit an Agent 4.

3.6 Agent 4: Artikel erstellen mit eigenem Bild

Ulf: „Jetzt wird es richtig spannend. Jetzt schreibt die KI den Artikel?“
Tanja: „Claude schreibt ihn, und Flux-2-Flex malt dazu ein Coverbild.“
Bernd schaut auf. „Ich habe meinen letzten Artikel einfach von einer anderen Website kopiert und ein bisschen umgeschrieben. Hat keiner gemerkt.“
Stille.
Tanja: „Das, nennt sich Urheberrechtsverletzung.“
Bernd: „Aber …“
Tanja: „Nein.“

3.6.1 Rechtliche Einschätzung

Vorab eine kurze persönliche Einschätzung als Laie, das ist keine Rechtsberatung:
Text: Die KI darf Fakten und Kontext verwenden, aber niemals Sätze aus dem Originalartikel wörtlich übernehmen. Kurze Zitate sind erlaubt, wenn sie als solche gekennzeichnet und mit Quellenlink versehen sind. Claude wird im Prompt explizit angewiesen, alles vollständig neu zu formulieren.
Bilder: Das größte Abmahnrisiko liegt bei Bildern. Das image_url-Feld aus dem RSS-Feed darf nicht einfach als Featured Image übernommen werden – das wäre die Neuveröffentlichung eines urheberrechtlich geschützten Bildes auf deiner Website. Stattdessen generieren wir mit Flux-2-Flex ein eigenes Bild, das zu 100 % uns gehört.

3.6.2 Den Workflow starten

1. Gehe zur Workflow-Übersicht und klicke auf Create new workflow
2. Nenne ihn: A4 Agent: Artikel erstellen mit eigenem Bild
3. Füge einen Schedule Trigger hinzu:
   • Trigger Interval: Hours
   • Hours Between Triggers: 23
   • Trigger at Minute: 0
     Für den Aufbau nutzen wir zunächst den Manual Trigger, damit wir beim Testen direkt starten können.

3.6.3 Die beste Story aus der Datenbank holen

Agent 4 liest aus der ki_story-Tabelle – dort liegt der angereicherte Inhalt aus Agent 3. Das SQL-Query ist das komplexeste des gesamten Projekts: Es holt die beste Story und lädt direkt alle zugehörigen Tavily-URLs als Array mit, damit Claude sie im Quellenabschnitt verlinkt.

1. Füge eine Postgres-Node hinzu:
   • Node: Execute a SQL query
   • Query:

SELECT
  s.id AS story_id,
  s.status,
  s.score_gesamt_enriched,
  s.content_enriched,

  a.title AS original_title,
  a.url AS original_url,
  a.published_date AS original_published_at,
  a.source AS original_source,

  COALESCE((
    SELECT ARRAY_AGG(x.url ORDER BY x.rank NULLS LAST, x.retrieved_at DESC, x.url)
    FROM (
      SELECT DISTINCT
        a2.url,
        e.rank,
        e.retrieved_at
      FROM ki_artikel_edges e
      JOIN ki_artikel a2
        ON a2.id = e.to_artikel_id
      WHERE e.from_artikel_id = s.primary_artikel_id
        AND e.relation_type = 'tavily_related'
        AND a2.url_normalized IS DISTINCT FROM a.url_normalized
      ORDER BY e.rank NULLS LAST, e.retrieved_at DESC, a2.url
      LIMIT 10
    ) x
  ), ARRAY[]::text[]) AS tavily_urls

FROM ki_story s
JOIN ki_artikel a ON a.id = s.primary_artikel_id
WHERE s.status = 'ANGEREICHERT'
ORDER BY s.score_gesamt_enriched DESC
LIMIT 1;

3.6.4 Artikel-Prompt für Claude aufbauen

Ein Edit Fields-Node baut den vollständigen Prompt auf. Er ist bewusst restriktiv: sechs verbindliche Redaktionsregeln verhindern Urheberrechtsverletzungen.

• Node: Edit Fields (Name: Edit Fields: Prompt erstellen)
• Add Field → Name: `prompt` → Type: String → Value (Expression):

={{ 
"Du bist Redakteur für foundic.org (Kategorie NEWS).\n\n" +

"REGELN (verbindlich):\n" +
"1) Du darfst Fakten verwenden, aber NICHTS wörtlich übernehmen. Alles vollständig neu formulieren.\n" +
"2) Keine Tabellen aus der Quelle übernehmen.\n" +
"3) Zitate: Standard 0. Nur wenn zwingend nötig: max. 1 Zitat <20 Wörter.\n" +
"4) Keine erfundenen Details. Bei Unsicherheit vorsichtig/konjunktiv.\n" +
"5) ANTWORT: ausschließlich ein einziges, gültiges JSON-Objekt. Kein Text davor/danach. Kein Markdown. Keine ```.\n" +
"6) WICHTIG: In JSON-Strings dürfen KEINE echten Zeilenumbrüche vorkommen. Nutze ein Array für Content-Blöcke.\n\n" +

"ARTIKELDATEN:\n" +
"ORIGINAL_TITEL: " + ($json.title ?? "") + "\n" +
"BESCHREIBUNG: " + ($json.description ?? "") + "\n" +
"INHALT (nur Kontext, NICHT übernehmen): " + (($json.content ?? "").slice(0, 1500)) + "\n" +
"QUELLE: " + ($json.source ?? "") + "\n" +
"DATUM: " + ($json.published_date ?? "") + "\n" +
"URL: " + ($json.url ?? "") + "\n\n" +

"Pflichtregeln für wp_title:\n" +
"- wp_title ist eine kurze Umformulierung des ORIGINAL_TITEL (gleicher Sachverhalt).\n" +
"- wp_title enthält mindestens 2 Kernbegriffe aus ORIGINAL_TITEL (z.B. Siemens/CES/Industrie).\n" +
"- max. 12 Wörter.\n\n" +

"ERWARTETES JSON (Keys nie weglassen, fehlende Werte: \"\" oder []):\n" +
"{\n" +
"  \"wp_title\": \"...\",\n" +
"  \"wp_excerpt\": \"...\",\n" +
"  \"wp_content_blocks\": [\n" +
"    \"<h2>Worum geht’s?</h2>\",\n" +
"    \"<p>...</p>\",\n" +
"    \"<h2>Hintergrund & Einordnung</h2>\",\n" +
"    \"<p>...</p>\",\n" +
"    \"<p>...</p>\",\n" +
"    \"<h2>Was bedeutet das?</h2>\",\n" +
"    \"<ul><li>...</li><li>...</li><li>...</li></ul>\",\n" +
"    \"<h2>Quelle</h2>\",\n" +
"    \"<p><a href=\\\"" + ($json.url ?? "") + "\\\">" + (($json.title ?? "").replace(/"/g, '\\"')) + "</a> (" + ($json.source ?? "") + ", " + ($json.published_date ?? "") + ")</p>\"\n" +
"  ],\n" +
"    \"<p><i>Dieser Artikel wurde mit KI erstellt und basiert auf den angegebenen Quellen sowie den Trainingsdaten des Sprachmodells.</i></p>\"\n" +  
" ],\n" +
"  \"wp_tags\": [\"...\",\"...\",\"...\",\"...\",\"...\"]\n" +
"}\n"
}}

Der Prompt ist bewusst restriktiv aufgebaut: sechs verbindliche Redaktionsregeln verhindern Urheberrechtsverletzungen, die Quellen-Regeln sorgen dafür, dass Claude nur hochwertige Medien verlinkt, und das JSON-Ausgabeformat ermöglicht die maschinelle Weiterverarbeitung ohne Nachbearbeitung.

3.6.5 Artikel mit Claude Sonnet schreiben

• Node: Message a model (Anthropic)
• Credential to connect with: Anthropic API Key (erstellen unter console.anthropic.com)
• Model: claude-sonnet-4-5-20250929
• Messages → Content: ={{ $json['prompt'] }}
• Options → Maximum Number of Tokens: 4000
  Das Token-Limit auf 4000 hochzusetzen ist wichtig – ohne diese Einstellung wird der Artikel mittendrin abgeschnitten.

3.6.6 Claude-Output parsen

Claude liefert die Antwort als Rohtext zurück. Ein Edit Fields-Node extrahiert daraus das JSON-Objekt:

• Node: Edit Fields (Name: Edit Fields1)
• Add Field -> Name: parsed -> Type: Object -> Value:

={{
  (() => {
    const raw =
      $json?.content?.[0]?.text ??
      $json?.content?.[0]?.content?.[0]?.text ??
      $json?.text ??
      "";

    const cleaned = raw.replace(/```(?:json)?/gi, "").trim();

    try {
      return JSON.parse(cleaned);
    } catch (e) {
      return { error: "JSON konnte nicht gelesen werden", raw: cleaned };
    }
  })()
}}

Der Code probiert mehrere mögliche Pfade im Claude-Response-Objekt durch. Falls das Parsing scheitert, gibt er ein Fehlerobjekt zurück – so bricht der Workflow nicht kommentarlos ab, sondern hinterlässt einen lesbaren Hinweis.

3.6.7 Felder für WordPress aufbereiten

Ein zweiter Edit Fields-Node „entpackt“ die geparsten Felder in eigenständige, benannte Variablen:

• Node: Edit Fields (Name: Edit Fields2)

Die wp_content_blocks werden durch join('\n\n') zu einem einzigen HTML-String zusammengefügt – genau das Format, das die WordPress REST API erwartet.

3.6.8 Bildprompt für Flux aufbauen

Jetzt startet der Bildgenerierungsprozess. Ein Edit Fields-Node baut den Flux-Prompt auf Basis des fertig geschriebenen Artikels:

• Node: Edit Fields (Name: Edit Fields3)
• Add Field → Name: `prompt` → Type: String → Value:

={{ 
"THEMA (kurz): " + ($json.wp_title ?? "") + 
". KONTEXT (kurz): " + ($json.wp_excerpt ?? "") + 
". " +
"Erstelle auf Basis des obigen Blogtextes eine moderne, vektorbasierte Editorial-Illustration im Flat-Design, geeignet als ruhiges Coverbild für einen professionellen Tech- oder Wissensblog. " +
"Stil und Gestaltung: Editorial-Flat-Illustration (Flat Design 2.0), vektorbasiert, sauber und minimalistisch. " +
"Klare Linien, einfache geometrische Formen, ruhige Flaechen und harmonische Proportionen. " +
"Reduzierte, professionelle Farbpalette mit warmen, gedämpften Toenen (Beige, Apricot, Orange) kombiniert mit zurueckhaltenden Blau- und Gruentoenen auf hellem Hintergrund. " +
"Weiches, flaechiges Licht mit sehr subtilen Schatten oder leichten Verlaeufen, keine realistische Lichtquelle. " +
"Abstrahierte, neutrale Figuren oder symbolische Objekte ohne individuelle Merkmale. " +
"Aufgeraeumte Komposition mit Fokus auf eine zentrale visuelle Metapher. " +
"Ruhige, sachliche Bildwirkung mit redaktionellem Charakter. " +
"Inhaltliche Vorgaben: Thema visuell abstrahieren, nicht woertlich oder erzählerisch. Keine konkrete Szene mit erkennbarem Ort oder realen Marken. " +
"Zwingende Verbote: Kein Text im Bild (keine Buchstaben, Woerter, Zahlen, Schriftzeichen). Keine Logos/Markenzeichen/firmenspezifischen Symbole. Keine Fotografie, kein Fotorealismus. Keine 3D-Darstellung. Keine Comic- oder Cartoon-Optik. " +
"Technische Vorgaben: Quadratisches Bildformat. Zeitgemaesser, konsistenter Stil fuer redaktionelle Online-Inhalte. "
}}

Der Prompt nutzt wp_title und wp_excerpt aus dem gerade erstellten Artikel als inhaltliche Basis. Die detaillierten Stil-Vorgaben (Flat Design 2.0, gedämpfte Farben, kein Text, kein Fotorealismus) sorgen für ein konsistentes, redaktionelles Bildlook über alle generierten Cover hinweg.

3.6.9 Bild bei Black Forest Labs anfordern

Die BFL-API arbeitet asynchron – du stellst einen Auftrag, bekommst eine Auftragsnummer zurück und fragst später nach, ob das Bild fertig ist. Wie eine Bäckerei: Bestellung aufgeben, Zettelchen nehmen, später abholen.

Schritt 1: API Key einrichten
Erstelle auf bfl.ai einen Account, lade Guthaben auf und kopiere deinen API Key. Speichere ihn in n8n als Custom Auth Credential:

• Gehe zu n8n Hauptmenü → Credentials → New
• Type: Custom Auth
• Name: z. B. BFL API Key
• JSON:

{
  "headers": {
    "x-key": "bfl_DEIN_API_KEY_HIER"
  }
}

Schritt 2: Bild-Job starten

• Node: HTTP Request (Name: HTTP Request - URL Bild)
• Method: POST
• URL: https://api.bfl.ai/v1/flux-2-flex
• Authentication: Generic Credential Type → Custom Auth → dein BFL-Credential
• Send Headers: ON
  • Name: Content-Type / Value: application/json
• Send Body: ON → Body Content Type: JSON → Specify Body: Using JSON
• JSON Body:

{
  "prompt": "={{ $json['`prompt`'] }}",
  "prompt_upsampling": true,
  "width": 1024,
  "height": 1024,
  "steps": 35,
  "guidance": 5,
  "output_format": "jpeg",
  "safety_tolerance": 2
}

• Response Format: JSON
  Die 35 Render-Steps liefern eine gute Balance zwischen Bildqualität und Generierungszeit (ca. 8–15 Sekunden).

3.6.10 Warten und Bild abrufen

Da die API asynchron arbeitet, brauchen wir eine Poll-Schleife: warten -> nachfragen -> fertig oder nochmal warten.
Wait-Node:

• Node: Wait
• Resume: After Time Interval
• Wait Amount: 11 Sekunden
  11 Sekunden ist in der Praxis eine gute Wartezeit für Flux-2-Flex. Zu kurz führt zu vielen unnötigen Check-Requests, zu lang verlängert die Workflow-Laufzeit unnötig.
  Check-Node:
• Node: HTTP Request (Name: HTTP Request - Check URL Bild)
• Method: GET
• URL: ={{ $('HTTP Request - URL Bild').item.json.polling_url }}
• Response Format: JSON
  IF-Node (fertig oder weiter warten):
• Node: IF
• Condition: {{ $json.status }} is equal to Ready
  • TRUE → weiter zum Download
  • FALSE → zurück zum Wait-Node (Verbindung vom FALSE-Ausgang zurück zu „Wait“)
    Achtung: BFL gibt Ready mit großem R zurück – nicht READY. Tippfehler hier führen zu einer Endlosschleife.
    Download-Node:
• Node: HTTP Request (Name: HTTP Request - Download URL Bild)
• Method: GET
• URL: ={{ $json.result.sample }}
• Response Format: File
  Das Bild landet jetzt als Binary-Daten im Feld data und ist bereit zum Speichern.

3.6.11 Dateinamen vergeben

Ein Edit Fields-Node erstellt einen systematischen Dateinamen im Format YYYY-MM-DD_quelle_artikel-slug_img-01.jpg:

• Node: Edit Fields (Name: Edit Fields5)
• Include Other Input Fields: ON
• Add Field → Name: filename → Type: String → Value:

={{ 
  (String($('Execute a SQL query').item.json.original_published_at || '').substring(0,10) || '0000-00-00')
}}_{{ 
  String($('Execute a SQL query').item.json.original_source || 'unknown').toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g,'')
}}_{{ 
  String($('Execute a SQL query').item.json.original_title || 'untitled')
    .toLowerCase()
    .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-+|-+$/g, '')
    .substring(0, 80)
}}_img-01.jpg

Das Ergebnis: 2026-01-20_heise-it_openai-stellt-neues-modell-vor_img-01.jpg. Jeder Dateiname ist eindeutig, lesbar und sortierbar nach Datum.

3.6.12 Bild auf der Synology NAS speichern

• Node: Read/Write Files from Disk
• Operation: Write File to Disk
• Binary Property: data
• File Path: /data/wpmedia/raw/{{ $json.filename }}
  Damit n8n auf dieses Verzeichnis schreiben darf, muss das Volume im Docker-YAML gemountet sein. Falls noch nicht geschehen, ergänze in deiner docker-compose.yml unter volumes:

volumes:
  - /volume2/docker/n8n/app_data:/home/node/.n8n
  - /volume1/WordPress/media:/data/wpmedia    # ← diese Zeile hinzufügen

Danach den Container neu starten. Außerdem müssen die Schreibrechte für den n8n-Prozess stimmen – falls der Node einen Fehler meldet, hilft dieser SSH-Befehl auf der DiskStation

sudo chown -R 1000:1000 /volume1/WordPress/media/
sudo chmod -R 775 /volume1/WordPress/media/

3.6.13 Story in Datenbank aktualisieren

Zum Abschluss schreibt ein Postgres-Node alle erzeugten Inhalte in die ki_story-Tabelle zurück und setzt den Status auf PUBLISH_READY. Das ist das Signal für Agent 5, dass dieser Artikel zur Veröffentlichung bereit steht.

• Node: Update rows in a table
• Credential to connect with: n8n-postgres
• Operation: Update
• Schema: public
• Table: ki_story (nicht ki_artikel!)
• Mapping Column Mode: Map Each Column Manually
• Columns to match on: id

$json.fileName (mit großem N) ist der automatisch von n8n vergebene Name der gespeicherten Datei – er entspricht dem Wert aus Edit Fields5, wird aber direkt aus dem Read/Write-Node übernommen.

3.6.14 Workflow veröffentlichen

Stelle den Schedule Trigger auf 23 Stunden und aktiviere den Workflow über Publish. Agent 4 läuft täglich einmal, nimmt die beste angereicherte Story, produziert daraus einen fertigen Artikel mit eigenem Coverbild und legt beides in der Datenbank ab.

3.7 Agent 5: Veröffentlichen auf WordPress

Tanja: „Das ist der letzte Schritt, Agent 5 übergibt alles an WordPress.“
Ulf: „Und dann ist der Artikel live?“
Tanja: „Nein. Er landet als Entwurf. Du schaust drüber, gibst grünes Licht, und erst dann geht er online.“
Bernd: „Warum nicht direkt veröffentlichen?“ Dann spart man sich den Schritt.“
Tanja: „Weil, KI-Artikel manchmal Fehler enthalten. Halluzinationen. Falsche Namen. Veraltete Zahlen. Ein kurzer menschlicher Blick verhindert, dass dein Blog Unsinn veröffentlicht, während du schläfst.“
Bernd überlegt. „Ich hätte das direkt veröffentlicht.“
Tanja: „Das weiß ich.“

3.7.1 Vorbereitung in WordPress

Damit n8n Artikel und Bilder hochladen darf, braucht es ein Anwendungspasswort. Das ist sicherer als dein normales Login – es kann jederzeit widerrufen werden, ohne dass sich dein Hauptpasswort ändert.

1. Logge dich in dein WordPress-Admin ein
2. Lege unter Benutzer → Neu hinzufügen einen neuen Benutzer an, z. B. n8n-publisher
3. Weise ihm die Rolle Autor oder Redakteur zu – er braucht keine Admin-Rechte
4. Öffne das Profil des neuen Benutzers und scrolle ganz nach unten zu Anwendungspasswörter
5. Gib einen Namen ein (z. B. n8n-Diskstation) und klicke auf Neues Anwendungspasswort hinzufügen
6. Wichtig: Kopiere das angezeigte Passwort sofort (z. B. abcd efgh ijkl ...), es wird nur dieses eine Mal angezeigt
7. Notiere außerdem die Kategorie-ID deiner Ziel-Kategorie. Diese findest du in WordPress unter Beiträge -> Kategorien: Klicke die gewünschte Kategorie an und lies die ID aus der URL ab (z. B. ...tag_ID=8)

3.7.2 Den Workflow starten

1. Gehe zurück zur Workflow-Übersicht und klicke auf Create new workflow
2. Nenne ihn oben links: A5 Agent: Veröffentlichen auf WordPress
3. Klicke auf Add First Step und wähle Schedule Trigger
   • Trigger Interval: Hours
   • Hours Between Triggers: 23
   • Trigger at Minute: 0
     Für den Aufbau nutzen wir zunächst den Manual Trigger, damit wir direkt testen können.

3.7.3 Fertigen Artikel aus der Datenbank holen

• Node: Postgres – Execute a SQL query
• Credential to connect with: n8n-postgres
• Query:

SELECT
  id,
  wp_title,
  wp_content,
  wp_excerpt,
  wp_tags,
  image_file_path
FROM ki_story
WHERE status = 'PUBLISH_READY'
ORDER BY created_at DESC
LIMIT 1;

Der Status PUBLISH_READY wird von Agent 4 automatisch gesetzt. Du kannst ihn in Metabase auch manuell vergeben oder entfernen – das gibt dir volle Kontrolle darüber, welche Artikel in die Veröffentlichungswarteschlange kommen.

3.7.4 Bild von der NAS laden

Das Bild muss als Binary-Datei in den n8n-Arbeitsspeicher geladen werden, bevor es an WordPress übertragen werden kann.

• Node: Read/Write Files from Disk
• Operation: Read File(s) From Disk
• File(s) Selector: ={{ $json.image_file_path }}
  Der image_file_path aus der Datenbank enthält den vollständigen Pfad innerhalb des Docker-Containers, z. B. /data/wpmedia/raw/2026-01-20_heise-it_openai-stellt-neues-modell-vor_img-01.jpg. Dieser Pfad muss mit dem in Agent 4 gemounteten Volume übereinstimmen.

3.7.5 Bild in die WordPress-Mediathek hochladen

WordPress braucht das Bild zuerst in der Mediathek, um ihm eine interne ID zuzuweisen – diese ID wird dann beim Erstellen des Beitrags als featured_media referenziert.

• Node: HTTP Request (Name: HTTP Request)
• Method: POST
• URL: https://foundic.org/wp-json/wp/v2/media
• Authentication: Generic Credential Type → Basic Auth
• Basic Auth Credential → New Credential:
  • Username: dein n8n-Publisher-Benutzername
  • Password: das Anwendungspasswort (nicht das normale Login-Passwort!)
• Send Headers: ON

• Send Body: ON
• Body Content Type: n8n Binary File
• Input Data Field Name: data
  Wenn der Request erfolgreich ist, gibt WordPress ein JSON-Objekt zurück, das u. a. das Feld id enthält – die Medien-ID des hochgeladenen Bildes. Diese ID brauchen wir im nächsten Schritt.

3.7.6 WordPress-Beitrag erstellen

Jetzt wird der eigentliche Beitrag angelegt. Wichtig: Der Status ist bewusst auf draft gesetzt – der Artikel erscheint nicht sofort öffentlich, sondern landet zunächst als Entwurf in WordPress, wo er prüft und freigeben werden kann.

• Node: HTTP Request (Name: HTTP Request1)
• Method: POST
• URL: https://foundic.org/wp-json/wp/v2/posts
• Authentication: Generic Credential Type → Basic Auth → dasselbe Credential wie oben
• Send Body: ON
• Body Content Type: JSON
• Specify Body: Using Fields Below
  Füge folgende Body-Felder hinzu (über Add Parameter):

Das Feld featured_media mit {{ $json.id }} referenziert die Bild-ID, die WordPress im vorherigen Schritt zurückgegeben hat – das verknüpft das hochgeladene Bild automatisch als Coverbild des Beitrags.

3.7.7 Status in der Datenbank aktualisieren

Nach erfolgreicher Übergabe an WordPress wird der Status in ki_story auf PUBLISHED gesetzt, damit der Artikel beim nächsten Durchlauf nicht erneut verarbeitet wird.

• Node: Update rows in a table
• Credential to connect with: n8n-postgres
• Operation: Update
• Schema: public
• Table: ki_story
• Mapping Column Mode: Map Each Column Manually
• Columns to match on: id

3.7.8 Der Human-in-the-Loop: Freigabe in WordPress

Nachdem Agent 5 gelaufen ist, liegt der Artikel als Entwurf in WordPress. Jetzt bist du dran – und das ist gut so:

1. Logge dich in dein WordPress-Admin ein
2. Gehe zu Beiträge → Entwürfe

3. Öffne den neu erstellten Beitrag und prüfe Titel, Text, Bild und Tags
4. Falls alles passt: Klicke auf Veröffentlichen
5. Falls du Anpassungen möchtest: Bearbeite den Beitrag direkt in WordPress

Du kannst in Metabase jederzeit den aktuellen Status aller Artikel einsehen und den status-Wert manuell anpassen – z. B. um einen Artikel zurück auf ANGEREICHERT zu setzen, wenn Agent 4 ihn neu bearbeiten soll.

3.7.9 Workflow veröffentlichen

Stelle den Schedule Trigger auf 23 Stunden und aktiviere über Publish. Die gesamte Pipeline läuft jetzt automatisch:

• Alle 2 Stunden liest Agent 1 neue Artikel aus 22 RSS-Feeds ein
• Alle 4 Stunden bewertet Agent 2 die neuen Einträge
• Alle 23 Stunden reichert Agent 3 die besten Artikel mit Web-Kontext an
• Alle 23 Stunden schreibt Agent 4 den fertigen Artikel und generiert das Coverbild
• Alle 23 Stunden lädt Agent 5 den Artikel als Entwurf in WordPress hoch – und wartet auf deine Freigabe bzw. Veröffentlichung in WordPress.

4 Fazit

Einige Wochen später. Gleiches Büro. Gleicher Montag.
Ulf öffnet seinen Laptop, nicht um Feeds zu durchklicken, sondern um einen einzigen Entwurf in WordPress zu prüfen. Der Artikel ist fertig geschrieben, hat ein Coverbild, Quellen und Tags. Er liest ihn durch, nickt, klickt auf „Veröffentlichen“.
Drei Minuten. Statt einer Stunde.
Bernd schaut herüber: „Hast du das alles selbst geschrieben?“
Ulf: „Eine KI hat es geschrieben, ich hab es nur freigegeben.“
Bernd: „Und das ist… okay so?“
Tanja lehnt sich zurück: „Das ist genau der Punkt.“

Was du gebaut hast

Wenn du alle fünf Agenten eingerichtet und aktiviert hast, läuft auf deiner Synology NAS ein vollautomatischer digitaler Newsroom – rund um die Uhr, ohne dass du jeden Morgen Feeds durchklicken oder manuell recherchieren musst. MEehrere Nachrichtenquellen (RSS-Feeds) werden kontinuierlich beobachtet, jede Meldung bewertet, die relevantesten Treffer tiefenrecherchiert, ein kompletter WordPress-Artikel geschrieben und ein eigenes Coverbild generiert. Was früher Stunden an redaktioneller Routinearbeit gekostet hätte, läuft heute im Hintergrund – und landet als Entwurf in deinem WordPress, wartet auf deinen letzten Blick und einen Klick.

Das ist kein Spielzeugprojekt. Du hast dabei ein ernsthaftes Stück Software-Architektur gebaut: eine relationale Datenbank mit Statusmaschine, ein Pipeline-System mit fünf unabhängig laufenden Agenten, Qualitätsprüfungen auf mehreren Ebenen, URL-Normalisierung zur Duplikatsvermeidung und einen Wissensgraphen aus verlinkten Artikeln. Und das alles ohne eine einzige Zeile Server-Code schreiben zu müssen.

Was das System wirklich leistet – und was nicht

Es lohnt sich, ehrlich zu sein: Das System schreibt gute, strukturierte, rechtskonforme Artikel. Aber es schreibt keine großartigen Artikel. Claude produziert soliden Redaktionsjournalismus – korrekt, gut aufgebaut, mit Quellen. Was fehlt, ist die menschliche Perspektive: die unerwartete Analogie, die pointierte Meinung, der Erfahrungswert aus zehn Jahren im Thema. Das System ist ein sehr guter erster Entwurf – aber ein Entwurf.

Genau deshalb ist der Human-in-the-Loop-Schritt kein lästiges Hindernis, sondern das Herzstück des Konzepts. Der Newsroom übernimmt die Fleißarbeit. Du übernimmst das Urteilsvermögen.

Was du jetzt tun kannst

Das System ist so gebaut, dass es wächst. Ein paar naheliegende nächste Schritte:

• Mehr Quellen – du kannst beliebig viele weitere RSS-Feeds in Agent 1 einbinden, ohne den Rest des Systems anzufassen. Englischsprachige Quellen wie TechCrunch, The Verge oder MIT Technology Review würden die internationale Perspektive deutlich verbessern.
• Feinere Bewertung – der Scoring-Prompt in Agent 2 lässt sich jederzeit anpassen. Wenn du merkst, dass bestimmte Subkategorien zu oft oder zu selten auftauchen, justiere einfach die Beschreibungen oder die Schwellenwerte.
• Mehrsprachigkeit – Claude schreibt problemlos auf Englisch, wenn du den Prompt in Agent 4 entsprechend anpasst. Damit ließe sich derselbe Workflow für einen zweiten Blog in einer anderen Sprache nutzen.
• Tags automatisch anreichern – die von Claude generierten wp_tags könnten zusätzlich gegen eine feste Tag-Taxonomie in WordPress abgeglichen werden, damit keine Tippvarianten entstehen.
• Benachrichtigungen – ein zusätzlicher n8n-Workflow könnte dich per E-Mail oder Telegram benachrichtigen, sobald ein neuer Artikel als Entwurf in WordPress bereitliegt.

Das größere Bild

Dieses Projekt zeigt exemplarisch, wohin die Reise mit KI-Automatisierung geht: nicht darum, Menschen zu ersetzen, sondern darum, den eigenen Hebel zu verlängern. Eine einzelne Person kann mit diesem Setup eine Publikationsfrequenz aufrechterhalten, die früher ein kleines Redaktionsteam erfordert hätte – und das zu Betriebskosten von unter 5 Euro im Monat.

n8n ist dabei das eigentliche Geheimnis. Nicht weil es besser wäre als Zapier oder Make in jeder einzelnen Funktion, sondern weil es self-hosted läuft. Deine Workflows, deine Daten, deine Infrastruktur – auf deiner eigenen Hardware, ohne monatliche Plattformgebühren, ohne Vendor-Lock-in, ohne Datenschutzbedenken beim Verarbeiten von Artikelinhalten.

Wenn du dieses System aufgebaut hast, hast du nicht nur einen Newsroom gebaut. Du hast verstanden, wie Multi-Agenten-Systeme funktionieren, wie man KI-Outputs in echte Workflows einbettet und wie man Automatisierung so gestaltet, dass sie skalierbar, wartbar und kontrollierbar bleibt. Das sind Fähigkeiten, die weit über dieses eine Projekt hinaus nützlich sein werden.

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen und n8n wirklich zu verstehen.

Tanja ist die IT-Expertin. Sie weiß, wie n8n funktioniert, erklärt geduldig und strukturiert – und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.
Bernd ist der selbsternannte „Experte“, der alles besser weiß und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.
Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung dafür ist Tanja da.

„Und… Action!“

Ulf lehnt sich zurück und verschränkt die Arme: „Moment mal. Ich hab n8n jetzt auf meinem NAS laufen, das Ding macht seine Workflows warum soll ich mir jetzt Stress mit irgendwelchen Tunneln machen? Kann ich nicht einfach einen Port aufmachen und gut is?“
Bernd nickt selbstgefällig: „Genau! Port 5678 nach außen freigeben, fertig. Hab ich früher mit meinem alten Webserver auch so gemacht. Hat… na ja, meistens funktioniert.“
Tanja schaut skeptisch. „Bis deine IP-Adresse auf einer Bot-Liste landete und du jede Minute Login-Versuche aus Kasachstan hattest, oder?“
Bernd zuckt mit den Schultern: „War halt lebhaft.“
Tanja seufzt: „Eine Portfreigabe ist wie eine offene Tür in deinem Haus mit einem Schild dran: ‚Bitte klopfen, bevor ihr einbrecht.‘ Cloudflare Tunnel macht etwas Eleganteres: Der Tunnel baut eine Verbindung von innen nach außen auf. Niemand kann bei dir anklopfen, weil die Tür von außen gar nicht existiert.“
Ulf runzelt die Stirn: „Das klingt wie Fußballtaktik. Wir verteidigen nicht, wir haben einfach keinen Strafraum?“
Tanja: „Ziemlich genau. Und Cloudflare steht als Torwart vor dem Tunnel – und lässt nur durch, was durchkommen soll.“

1 Warum Cloudflare?

Cloudflare ist eigentlich dafür bekannt, dass es vor Websites sitzt und böswilligen Traffic abfängt, bevor er überhaupt ankommt. Ein Reverse Proxy gewissermaßen eine Art Türsteher, der entscheidet, wer rein darf und wer draußen bleiben muss.
Der Cloudflare Tunnel macht etwas Ähnliches, nur umgekehrt: Statt dass dein Server auf eingehende Verbindungen wartet (und dafür einen Port öffnen muss), baut der Tunnel eine verschlüsselte Verbindung von innen nach außen auf. Cloudflare sitzt dann vor dieser Verbindung und leitet nur durch, was durchkommen soll.

Das hat vier entscheidende Vorteile:

• Keine offenen Ports: Deine Firewall bleibt zu. Niemand kann deine NAS direkt scannen oder angreifen.
• Automatisches HTTPS: Cloudflare kümmert sich um SSL-Zertifikate. Du musst nichts erneuern, nichts konfigurieren.
• Schutz vor Bots & DDoS: Cloudflare filtert Millionen von Anfragen pro Sekunde. Deine NAS bekommt nur legitimen Traffic zu sehen.
• Login-Schutz per E-Mail / MFA: Du kannst vor n8n eine zusätzliche Authentifizierungsschicht setzen – ohne dass n8n selbst davon weiß.
• Stabile Webhook-URLs: Externe Dienste wie Stripe oder Telegram brauchen URLs, die sich nicht ändern und immer erreichbar sind. Cloudflare liefert das.

Ulf: „Klingt zu gut, um wahr zu sein. Was ist der Haken?“
Tanja: „Der Haken ist, dass du eine eigene Domain brauchst. Die muss nicht teuer sein oft reichen 10 Euro im Jahr, aber ohne Domain geht’s nicht. Cloudflare muss wissen, welche Adresse es für dich verwalten soll.“
Bernd grinst: „Ich hab mal eine Domain gekauft. bernd-ist-der-beste.de. Leider hat sie niemand besucht.“
Tanja murmelt: „Überraschung“.

2 Überblick: Die Einrichtung in vier Schritten

1. Cloudflare-Konto & Domain einrichten
2. Cloudflare Tunnel als Docker-Container auf Diskstation einrichten
3. n8n-Container auf die neue URL vorbereiten
4. Zugriff über Cloudflare Zero Trust absichern

Wir gehen bewusst Schritt für Schritt klickbar, nachvollziehbar, ohne Vorwissen vorauszusetzen.

2.1 Schritt: Cloudflare-Konto & Domain einrichten

Registrierung & Domain hinzufügen

Geh auf Cloudflare.com und erstelle einen Account, falls du noch keinen hast. Nach dem Login bzw. Registrierung klickst du auf Domains -> Onboard a domain -> Enter an existing domain und gibst deine Domain ein also etwa deine-domain.de.

Cloudflare bietet dir dann verschiedene Pläne an. Wähle den Free Plan  aus, der reicht vollkommen aus.

Tanja nickt. „Gute Frage. Im Moment noch gar nichts. Du sagst Cloudflare nur: ‚Hey, ich hab diese Domain, kannst du sie für mich verwalten?‘ Aber die Kontrolle bekommst du erst, wenn du die Nameserver änderst. Das kommt jetzt.“

Nameserver ändern

Jetzt kommt der entscheidende Schritt: Cloudflare muss die Kontrolle über deine Domain übernehmen. Dafür musst du die Nameserver ändern.
Was sind Nameserver? Stell dir vor, das Internet ist eine riesige Stadt, und deine Domain ist eine Adresse. Nameserver sind das Telefonbuch sie entscheiden, welche IP-Adresse hinter einer Domain steckt. Wenn jemand deine-domain.deaufruft, fragt sein Browser die Nameserver: „Wo finde ich die?“
Cloudflare zeigt dir auf der Seite „Change your nameservers“ oder unter Configure DNS -> DNS -> Records -> Cloudfare Nameservers zwei Adressen an, etwa (der Name vor dem ersten Punkt kann anders sein):

• aurora.ns.cloudflare.com
• ben.ns.cloudflare.com

Diese beiden Nameserver musst du bei deinem Domain-Hoster eintragen. Wo genau das ist, hängt vom Anbieter ab. Schau unter Domainverwaltung -> DNS -> NS-Record oder unter Manage Domain -> Tools -> Nameserver. Trage dort die beiden Cloudflare-Nameserver ein und lösche die alten.

Ulf: „Warte mal. Ich lösche die alten? Was passiert denn dann mit meiner Website?“
Tanja: „Kurzzeitig kann es sein, dass deine Domain nicht erreichbar ist. Das nennt sich DNS-Propagierung, die neuen Nameserver müssen sich erstmal im Internet verbreiten. Dauert meistens ein paar Minuten, kann aber bis zu 24 Stunden dauern.“
Bernd grinst: „Bei mir hat’s drei Tage gedauert. Aber ich hab auch vergessen, auf ‚Speichern‘ zu klicken.“

Die Änderung kann bis zu 24 Stunden dauern meistens geht’s schneller. Auf der Cloudflare-Plattform siehst du unter Overview -> Check Nameservers, ob die Umstellung abgeschlossen ist.

E-Mail-Verifizierung

Irgendwann in diesem Prozess, oft während du auf die Nameserver-Prüfung wartest, wirst du von Cloudfare aufgefordert, deine E-Mail-Adresse zu bestätigen. Klick einfach den Link in der Mail, die du bekommst. Ohne diese Verifizierung geht es nicht weiter. Danach kannst Du ersten Tunnel anlegen.

Ulf genervt: „Warum schicken die mir jetzt eine Mail?“
Tanja: „Weil sie sicherstellen wollen, dass du nicht irgendeine Domain registrierst, die dir nicht gehört. Wenn jemand google.de bei Cloudflare anmelden könnte, ohne Besitzer zu sein, hätten wir ein Problem.“
Bernd nickt: „Hab ich auch mal versucht. Hat nicht geklappt.“

Ersten Tunnel anlegen

Sobald die Domain eingerichtet ist, kannst du den ersten Tunnel anlegen. Geh auf Account Home -> Zero Trust (nicht im Menü sondern rechts auf der Seite) -> Networks -> Add Tunnels -> Create a tunnel (Alternativ: Zero Trust -> Networks -> Connectors -> Tunnels).

Wähle Select Cloudflared als Tunnel-Typ, gib einen frei wählbaren Namen ein (z. B. n8n-tunnel).

Auf der nächsten Seite zeigt Cloudflare dir ein langes Token. Den brauchst du gleich, kopiere diesen. Du bekommst es später nicht mehr zu sehen.

Ulf skeptisch: „Wie lang ist das Ding?“
Tanja: „Lang! Sieht aus wie eine Passwort-Explosion. Aber genau das macht ihn sicher. Kopier ihn in eine Textdatei, du brauchst ihn im nächsten Schritt.“

Klicke auf Next und fülle folgende Felder aus:

• Subdomain: n8n (frei wählbar)
• Domain: Wähle deine Domain aus der Liste
• Type: HTTP
• URL: localhost:5678(das ist der lokale Port von n8n auf deiner DiskStation)

Ulf: „Was ist denn jetzt eine Subdomain?“
Tanja: „Eine Subdomain ist wie ein Zimmer in deinem Haus. Deine Domain ist das Haus deine-domain.de. Die Subdomain ist ein bestimmter Raum darin n8n.deine-domain.de. Das gibt dir die Möglichkeit, für n8n eine eigene Adresse zu haben, ohne dass du gleich eine neue Domain kaufen musst.“
Bernd nickt weise: „Ich hab mal admin.bernd-ist-der-beste.de angelegt. Dann hab ich das Passwort vergessen.“

Eine Subdomain ist sinnvoll, weil sie einen klar abgegrenzten technischen Zugriffspunkt schafft, über den du Sicherheit, Zugriffsregeln und Webhooks unabhängig von der Hauptdomain steuern kannst ohne andere Dienste oder Inhalte deiner Domain zu beeinflussen.
Klicke auf Save tunnel. Fertig. Der Tunnel ist angelegt, allerdings noch nicht aktiv, weil der Cloudflared-Container auf deiner Diskstation noch fehlt. Den richten wir jetzt ein.

2.2 Schritt: Cloudflare Tunnel als Docker-Container auf Diskstation einrichten

Ulf: „Okay. Jetzt wird’s ernst. Wir basteln am NAS rum.“
Tanja: „Richtig, aber keine Panik. Wir laden nur einen Container herunter und starten ihn. Das ist weniger kompliziert, als es klingt.“
Bernd grinst: „Ich hab mal einen Container gestartet. Der hat dann alle anderen Container gekillt.“
Tanja: „Weil du vergessen hast, das Netzwerk richtig zu setzen. Deshalb machen wir’s jetzt Schritt für Schritt.“

Container herunterladen & starten

Öffne den Container Manager auf deiner Synology und gehe zu Registrierung.

• Container Manager → Registrierung
• Image suchen: cloudflare/cloudflared
• Tag: latest herunterladen

Ulf: „Was ist denn ein Image?“
Tanja: „Ein Image ist wie ein Bauplan. Der Container ist das fertige Haus, das nach diesem Bauplan gebaut wird. Du lädst den Bauplan herunter, und im nächsten Schritt baust du das Haus.“

Container erstellen

Sobald das Image heruntergeladen ist, klickst du es an und wählst Ausführen. Jetzt kommt der Assistent, der dich durch die Einrichtung führt.
Wichtig: Folgende Einstellungen sind entscheidend:

• Automatischen Neustart aktivieren: Setzt du ein Häkchen. Damit startet der Container automatisch neu, falls dein NAS mal neu startet.
• Netzwerk: Wähle host (nicht bridge!). Das ist wichtig, damit der Container auf localhost:5678 zugreifen kann – also auf deinen n8n-Container.

Ulf: „Warum host?“
Tanja: „Weil der Cloudflare-Container mit deinem n8n-Container sprechen muss. Wenn du bridge wählst, sieht der Cloudflare-Container localhost:5678 nicht weil localhost dann nur den Container selbst meint, nicht dein NAS. Mit hostteilen sich alle Container das gleiche Netzwerk.“
Bernd nickt: „Hab ich auch mal falsch gemacht. Der Container hat dann mit sich selbst geredet.“

Jetzt kommt der entscheidende Schritt: der Ausführungsbefehl.

• Ausführungsbefehl setzen: tunnel run --token <DEIN_TOKEN_VON_OBEN_EINGEBEN>

Ersetze <DEIN_TOKEN_VON_OBEN> mit dem langen Token, das du vorhin aus Cloudflare kopiert hast.

Ulf: „Moment, ich soll jetzt diesen ellenlangen Code da reinpasten? Ohne Leerzeichen? Ohne dass ich mich vertippe?“
Tanja: „Genau, deshalb: Kopieren, nicht abtippen. Ein einziger falscher Buchstabe, und der Container startet zwar, verbindet sich aber nicht mit Cloudflare.“

Klicke auf Weiter und dann auf Fertig. Der Container startet. Wenn alles geklappt hat, sollte er unter Container mit grünem Status laufen.

Der Moment der Wahrheit

Jetzt der Moment der Wahrheit: Öffne einen Browser und gib https://n8n.deine-domain.de ein. Du solltest die n8n-Anmeldeseite sehen über HTTPS, ohne dass du irgendwelche Zertifikate installiert hast.

Ulf starrt auf den Bildschirm: „Das… das hat einfach funktioniert?“
Tanja lächelnd: „Willkommen in der Welt der Cloudflare-Magie“.

Falls nicht, prüfe:

• Läuft der n8n-Container?
• Läuft der Cloudflared-Container?
• Steht im Tunnel die richtige URL (localhost:5678)?
• Ist das Token korrekt eingegeben (ohne Leerzeichen am Anfang/Ende)?

Bernd kratzt sich am Kopf: „Bei mir stand da ‚Bad Gateway‘. Ich hab dann einfach alles gelöscht und neu angefangen.“
Tanja: „Das war vermutlich das Token. Einmal Leerzeichen zu viel, und Cloudflare versteht nur Bahnhof.“

2.3 Schritt: n8n-Container auf die neue URL vorbereiten

Bis hierhin funktioniert n8n zwar, aber es weiß noch nicht, dass es jetzt über eine neue URL erreichbar ist. Das mag nach einem Detailproblem klingen, ist aber entscheidend: Webhooks also Benachrichtigungen von externen Diensten wie Stripe, Telegram oder GitHub brauchen eine Rückmelde-Adresse. Wenn n8n denkt, es läuft unter http://localhost:5678, schickt es diese falsche Adresse an externe Dienste. Die können dann nicht zurückrufen.

Ulf: „Moment, was sind Webhooks noch mal?“
Tanja: „Stell dir vor, du bestellst eine Pizza, Du gibst dem Lieferdienst deine Adresse, damit er weiß, wo er klingeln soll. Ein Webhook ist genau das n8n gibt einem externen Dienst eine Adresse, an die dieser eine Nachricht schicken kann, wenn etwas passiert. Zum Beispiel: ‚Hey n8n, jemand hat gerade bezahlt, mach was mit dieser Info.'“
Bernd nickt: „Ich hab mal einen Webhook eingerichtet. Der hat dann an localhost gesendet. Hat nicht funktioniert.“
Tanja murmelt: „Überraschung“.

Du musst n8n also mitteilen: „Du bist jetzt unter https://n8n.deine-domain.de erreichbar.“
Wie du das machst, hängt davon ab, wie du n8n ursprünglich eingerichtet hast. Zwei Varianten:

Variante A: Container manuell erstellt (über Container Manager)

Wenn du den n8n-Container manuell über den Container Manager angelegt hast (nicht per Docker Compose), musst du die Umgebungsvariablen anpassen. Leider lässt Synology keine nachträgliche Bearbeitung von Containern zu – du musst den Container duplizieren.

1. Gehe zu Container, wähle deinen n8n-Container aus und klicke auf Aktion → Stopp.
2. Klicke dann auf Aktion → Duplizieren.
3. Im neuen Container-Assistenten ergänze unter Umgebung folgende Variablen:
   • N8N_HOST: n8n.Deine_Domain.de
   • N8N_PROTOCOL: https
   • WEBHOOK_URL: https://n8n.Deine_Domain.de/
   Ulf: „Warum steht da jetzt https?“
   Tanja: „Weil Cloudflare das HTTPS-Zertifikat übernimmt. Dein n8n selbst spricht zwar nur HTTP, aber nach außen – für die Welt – ist es HTTPS. Deshalb muss n8n wissen: ‚Hey, wenn du Webhooks registrierst, sag den Diensten, dass sie https:// verwenden sollen, nicht http://.'“

• Falls vorhanden:
  • N8N_SECURE_COOKIE=true -> entfernen, da HTTPS jetzt extern kommt
    Da du jetzt ein echtes HTTPS-Zertifikat von Cloudflare hast, kannst du die Zeile N8N_SECURE_COOKIE=true stehen lassen (falls vorhanden) – oder sie setzen, falls sie noch fehlt. Das sorgt dafür, dass Cookies nur über verschlüsselte Verbindungen gesendet werden.

4. Starte den neuen Container.

Variante B: n8n über Docker Compose (Projekt)

Wenn du n8n per Docker Compose eingerichtet hast (eine detaillierte Beschreibung findest Du unter https://www.foundic.org/n8n-selbst-hosten-synology-nas-docker-installation/), ist die Anpassung eleganter:

1. Stoppe das Projekt im Container Manager.
2. Wenn du den gleichen Projektnamen verwenden willst, lösche das alte Projekt.
3. Erstelle ein neues Projekt und wähle den gleichen Ordner-Pfad. Synology lädt automatisch die vorhandene compose.yaml.
4. Ergänze in der compose.yaml unter services → n8n → environment folgende drei Zeilen (nach N8N_SECURE_COOKIE)
5. Sowie ändere N8N_SECURE_COOKIE auf true, da HTTPS jetzt extern kommt

    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=db
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n_db
      - DB_POSTGRESDB_USER=n8n_admin
      - DB_POSTGRESDB_PASSWORD=<POSTGRES_PASSWORD>
      - N8N_ENCRYPTION_KEY=<DEIN_ENCRYPTION_KEY>
 .    # --- NEUE VARIABLEN auf true ändern ---
      - N8N_SECURE_COOKIE=true
      # --- NEUE VARIABLEN FÜR CLOUDFLARE ---
      - N8N_HOST=n8n.Deine_Domain.de
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.Deine_Domain.de/

Ulf: „Warum ist das jetzt eleganter?“
Tanja: „Weil du die Datei einfach bearbeitest, statt den ganzen Container zu duplizieren. Du änderst drei Zeilen, speicherst, fertig. Kein Klickmarathon.“

Jetzt sollte alles wie gewünscht laufen. n8n ist über das Internet erreichbar, kennt seine eigene URL und kann Webhooks korrekt registrieren.

2.4 Schritt: Zugriff über Cloudflare Zero Trust absichern

Ulf: „Moment mal“, sagt Ulf. „Jetzt ist mein n8n öffentlich im Internet? Kann da jetzt jeder drauf?“
Tanja: „Genau. Jeder, der die URL kennt, kann theoretisch auf die Anmeldeseite zugreifen. n8n selbst hat zwar eine Benutzeranmeldung, aber es gibt keinen Schutz davor, dass jemand hundert Passwörter pro Minute ausprobiert oder nach Schwachstellen sucht.“
Bernd nickt weise: „Hab ich auch mal erlebt. Irgendwann kamen die Login-Versuche schneller, als ich ‚Stopp‘ sagen konnte.“

Cloudflare bietet eine elegante Lösung: Access Control. Das ist eine zusätzliche Authentifizierungsschicht vorn8n. Wenn jemand https://n8n.deine-domain.de aufruft, prüft Cloudflare erst, ob die E-Mail-Adresse erlaubt ist – und schickt dann einen 6-stelligen Code per Mail. Erst mit dem richtigen Code kommt man überhaupt zur n8n-Anmeldeseite.

Tanja: „Das ist wie ein Vorzimmer. Bevor du ins Büro kommst, musst du dich erst bei der Empfangsdame ausweisen.“

Access Appliction einrichten

Gehe auf der Cloudflare-Plattform zu Account Home -> Zero Trust (nicht im Menü sondern rechts auf der Seite) -> Go to Zero Trust -> Access Control -> Applications -> Add an application -> Typ: Self-hosted

Einstellungen:

• Application Name: n8n (frei wählbar)
• Session Duration: 6 hours (so lange bleibt der Zugang gültig)
• Subdomain: n8n (wie oben)
• Domain: Wähle deine Domain aus

Ulf: Was ist eine Session?“
Tanja: „Eine Session ist wie ein Tagespass. Wenn du dich einmal authentifiziert hast, musst du nicht jedes Mal neu den Code eingeben. Nach 6 Stunden läuft der Pass ab, und du musst dich neu anmelden.“

Anschließend muss Du eine Policy anlegen -> Add a policy

• Policy name: n8n_zugriff(frei wählbar)
• Action: Allow
• Include -> Selectore: eMails (auswählen),
• Value: eMail-Adresse(n) eintragen

Klicke auf Save policy und dann auf Save application

Wichtig: Webhooks ausnehmen

Ulf: „Warte mal, wenn jetzt jeder diesen Code braucht,was ist mit den Webhooks? Die kommen doch von außen?“
Tanja: „Genau das Problem. Wenn Stripe, Telegram oder GitHub einen Webhook an n8n schicken, werden sie von Cloudflare Access blockiert. Die haben ja keine E-Mail-Adresse und können keinen Code eingeben.“
Bernd nickt: „Bei mir hat Stripe dann irgendwann aufgegeben. Dachte, mein Server wär tot.“

Die Lösung: Du legst eine zweite Subdomain an, nur für Webhooks. Die schützt du anders.

Gehe zurück zu Networking → Tunnels, öffne deinen Tunnel und füge eine zweite Route hinzu: 
– Subdomain: n8n-webhook 

• Domain: Deine Domain 
  – Type: HTTP 
  – URL: localhost:5678 `

Speichere das. Jetzt ist n8n unter zwei URLs erreichbar: 

• https://n8n.deine-domain.de(geschützt durch Access, für dich)
  – https://n8n-webhook.deine-domain.de (öffentlich zugänglich, für Webhooks) 

Ulf: „Ist das nicht unsicher?“
Tanja: „Ein bisschen. Aber die Webhook-URL kennt nur, wer sie von dir bekommt. Und externe Dienste validieren oft ihre eigenen Webhooks, Stripe schickt zum Beispiel eine Signatur mit, die du in n8n prüfen kannst.“

Für die Webhook-URL musst du keine Access Policy anlegen. Oder du legst eine an, die nur den Pfad /webhook/ durchlässt (je nachdem, wie paranoid du bist). In n8n selbst musst du dann bei jedem Webhook-Trigger darauf achten, dass du die Webhook-Subdomain verwendest, also: https://n8n-webhook.deine-domain.de/webhook/...

Der finale Test

Wenn du nun https://n8n.deine-domain.de aufrufst, gelangst du nicht direkt auf den n8n-Login, sondern Cloudflare schiebt eine Cloudflare Access-Seite dazwischen, auf der du eine deiner bei Cloudflare hinterlegten E-Mail-Adressen eingibst. An diese bekommst du dann einen 6-stelligen Code gesendet, den du zur Freigabe benötigst.

Ulf: „Das ist ja wie beim Online-Banking“
Tanja: „Genau, und genau deshalb ist es sicher.“

3 Fazit

Du hast ein n8n, das über das Internet erreichbar ist, ohne offene Ports, ohne manuelle SSL-Zertifikate, ohne dass du deine Router-Konfiguration auch nur angeschaut hast. Cloudflare sitzt als Türsteher davor, filtert Bots, schützt vor DDoS und lässt nur dich rein.

Webhooks funktionieren, externe Dienste können mit n8n sprechen, und du kannst von überall auf deine Automatisierungen zugreifen, vom Café, vom Flughafen, vom Sofa aus.

Das ist der Moment, in dem aus einem lokalen Experiment eine brauchbare Infrastruktur wird. Keine Enterprise-Lösung, klar – aber eine, die zuverlässig läuft, ohne dass du dich jede Woche um irgendwelche Updates oder Sicherheitslücken kümmern musst.

Ulf lehnt sich zurück. „Okay, ich geb’s zu. Das war einfacher, als ich dachte.“
Bernd nickt. „Ich hab immer noch keine Ahnung, was ich da gemacht hab. Aber es läuft.“
Tanja lächelt. „Genau das ist der Punkt.“

Cloudflare macht das Hosting nicht überflüssig. Aber es macht es zugänglich auch für Leute, die keine Systemadministratoren sind, sondern einfach nur Workflows bauen wollen, die funktionieren.

Hast du Verbesserungsvorschläge für diese Anleitung oder foundic.org? Ich freue mich über dein Feedback in den Kommentaren!

In diesem Beitrag zeige ich Schritt für Schritt, wie du n8n selbst hostest – sauber gekapselt in Containern, optional mit einer stabilen PostgreSQL-Datenbank. Keine Vorkenntnisse nötig, nur Neugier.

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen und n8n wirklich zu verstehen.

Tanja ist die IT-Expertin. Sie weiß, wie n8n funktioniert, erklärt geduldig und strukturiert – und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.
Bernd ist der selbsternannte „Experte“, der alles besser weiß – und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.
Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung – dafür ist Tanja da.

„Und… Action!“

Montagmorgen, 8:47 Uhr. Bernd betritt das Büro mit zwei Kaffees und einem selbstzufriedenen Grinsen.
Bernd: „Leute, ich hab’s gecheckt. Automatisierung ist die Zukunft. Hab gestern Abend so ein Tool entdeckt – n8n oder so. Läuft auf meinem Laptop. Hab schon drei Workflows gebaut. Einer davon sortiert meine E-Mails. Na ja, er hat alle in den Spam verschoben, aber das Prinzip steht.“
Tanja blickt nicht mal von ihrem Bildschirm auf.
Tanja: „Bernd, läuft das Tool noch?“
Bernd: „Äh… hab den Laptop zugemacht.“
Tanja: „Dann läuft’s nicht mehr.“
Bernd: „Aber… ich hab doch auf Speichern geklickt!“
Ulf gähnt. „Alter, können wir das nicht einfach in die Cloud packen? So wie bei Netflix? Immer an, immer da.“
Tanja dreht sich um. „Können wir. Kostet dann halt 20 bis 50 Euro im Monat, je nachdem wie viele Workflows du baust. Oder…“ – sie zeigt auf ein unauffälliges Kästchen unter ihrem Schreibtisch – „…du nimmst das Ding, das bei dir eh schon läuft und Staub fängt.“
„Meine Synology?“ Ulf schaut skeptisch. „Die kann doch nur Filme speichern.“
Tanja: „Filme, Backups, Fotos… und jetzt eben auch deine Automatisierung. Kostet dich keinen Cent extra. Läuft 24/7. Und deine Daten bleiben bei dir, nicht bei irgendeinem Anbieter, der sie sich für Werbung anschaut.“
Bernd unterbricht: „Klingt kompliziert.“
„Ist es nicht“, sagt Tanja. „Du klickst dich durch ein paar Einstellungen, startest zwei Container, fertig. Dauert keine halbe Stunde.“
Bernd: „Container? Wie… Schiffscontainer?“
Ulf lacht. „Bro, die hat grade gesagt ‚halbe Stunde‘. Das kriegen sogar wir hin.“

1 Was ist n8n?

n8n ist eine Open-Source-Plattform für Workflow-Automatisierung. Stell dir vor, du baust mit Legosteinen eine Maschine – nur dass die Bausteine keine Räder oder Motoren sind, sondern Apps, Dienste und Daten.
Du verbindest zum Beispiel:

• Gmail mit Google Sheets
• Eine Wetter-API mit Slack
• Einen Webhook mit einer KI, die dir automatisch E-Mails zusammenfasst

Das Ganze passiert über eine visuelle Oberfläche: Du ziehst Kästen auf eine Arbeitsfläche, verbindest sie mit Pfeilen, stellst Bedingungen ein. Fertig ist der Workflow.
Der entscheidende Unterschied zu anderen Tools:
n8n ist Low-Code, aber nicht No-Code. Das heißt:

• Einsteiger klicken ihre Workflows zusammen, ohne eine Zeile Code zu schreiben.
• Fortgeschrittene können jederzeit JavaScript oder Python einbauen, wenn’s kompliziert wird.
• Du kannst KI-Modelle direkt einbinden OpenAI, Anthropic Claude, oder sogar lokale Modelle über Ollama.

Typische Einsätze:

• E-Mails automatisch verarbeiten (z. B. Rechnungen rausfiltern und in eine Datenbank packen)
• APIs miteinander verbinden (z. B. neue Trello-Karten automatisch in Notion übertragen)
• Dateien analysieren, transformieren, weiterleiten (z. B. PDFs automatisch per KI zusammenfassen lassen)
• Benachrichtigungen, Reports, Webhooks orchestrieren
  Und das Wichtigste: n8n gehört dir. Keine fremde Cloud. Kein Lock-in. Deine Daten, deine Kontrolle.

Ulf: „Okay, aber warum sollte ich mir den Stress antun? Es gibt doch bestimmt auch einfachere Tools.“
Tanja: „Gibt es. Zapier zum Beispiel. Macht ungefähr das Gleiche. Kostet dich aber ab einem gewissen Punkt richtig Geld – 20, 50, 100 Euro im Monat, je nachdem wie viele Workflows du baust und wie oft die laufen. n8n kostet dich: nichts. Null Euro. Läuft auf deiner eigenen Hardware.“
Bernd: „Und wenn ich die Hardware nicht habe?“
Tanja: „Dann mietest du dir einen Server für 5 Euro im Monat. Immer noch billiger. Aber die meisten von uns haben schon eine Synology rumstehen. Die ist perfekt dafür.“
Ulf: „Was kann n8n denn, was Zapier nicht kann?“
Tanja: „Alles anpassen. Eigene Nodes schreiben. Lokale Datenbanken anbinden. KI-Modelle laufen lassen, die nicht in der Cloud hängen. Und du kannst die Workflows als Code exportieren und weitergeben – Open Source eben.“

1.1 Erweiterte Funktionen und Integrationsmöglichkeiten

n8n ist kein einfaches „Wenn-Dann“-Tool. Es ist eine echte Automatisierungs-Plattform mit über 400 vorgefertigten Integrationen:

• Apps und Dienste: Google Sheets, Slack, Notion, GitHub, Trello, Airtable, WordPress…
• Datenbanken: MySQL, PostgreSQL, MongoDB, Redis
• KI-Dienste: OpenAI, Anthropic Claude, Hugging Face, Ollama (für lokale Modelle)
• Trigger-Typen:
  • Zeitbasiert (Cron-Jobs): „Jeden Montag um 9 Uhr“
  • Webhooks: „Sobald jemand ein Formular abschickt“
  • Manuell: „Nur wenn ich auf ‚Start‘ drücke“
  • Externe Ereignisse: „Wenn ein neuer Eintrag in der Datenbank auftaucht“
    Das Debugging läuft in Echtzeit: Du siehst genau, welche Daten in jeden Baustein reingehen und wieder rauskommen. Wenn ein Workflow nicht funktioniert, kannst du jeden einzelnen Schritt nachvollziehen.
    Und falls eine Integration fehlt? n8n hat eine riesige Community mit tausenden selbst gebauten Nodes. Und es gibt eine Template-Datenbank: Fertige Workflows, die du einfach per Copy & Paste importieren kannst. Brauchst du einen PDF-Zusammenfasser mit KI? Gibt’s schon. E-Mail-Router? Auch da. CRM-Synchronisation? Läuft.
    Du musst nicht alles selbst bauen. Du kannst auf vorhandene Lösungen aufbauen.

Bernd: „Moment. Wenn das so einfach ist, warum macht das nicht jeder?“
Tanja: „Weil die meisten denken, Automatisierung ist kompliziert. Und weil viele nicht wissen, dass ihre NAS mehr kann als Filme speichern.“
Ulf: „Aber was mache ich konkret damit? Gib mir ein Beispiel, das nicht nerdy klingt.“
Tanja: „Okay. Du bekommst jeden Tag E-Mails von Kunden mit Anfragen. Manche davon sind dringend, manche nicht. n8n liest die E-Mails, analysiert sie mit einer KI, sortiert sie nach Priorität und schickt dir nur die wichtigen als Push-Nachricht aufs Handy. Der Rest landet automatisch in Notion mit einer Zusammenfassung.“
Ulf: „Das geht?“
Tanja: „Das geht. Und dauert ungefähr 15 Minuten, wenn du das Template aus der Community nimmst.“

1.2 Praxisbeispiele für n8n-Workflows

Damit du dir besser vorstellen kannst, was n8n in der Praxis leistet, hier ein paar konkrete Szenarien:

1. Synchronisation zwischen Systemen: Du pflegst Kundendaten in einem CRM (z. B. HubSpot), willst sie aber auch in Google Sheets haben, weil dein Team dort besser arbeitet. n8n synchronisiert beide Systeme automatisch: Neue Einträge im CRM landen in der Tabelle, Änderungen in der Tabelle werden zurück ins CRM geschrieben.
2. Automatisierte Benachrichtigungen: Sobald ein bestimmtes Ereignis eintritt – ein neuer Lead, ein abgeschlossener Deal, ein Fehler in einem System – schickt n8n dir eine Nachricht. Slack, E-Mail, Telegram, was auch immer du nutzt.
3. KI-gestützte Datenverarbeitung: Du lädst ein Dokument hoch. n8n schickt es an ein KI-Modell (z. B. Claude), lässt es zusammenfassen, extrahiert wichtige Fakten und speichert das Ergebnis in einer Datenbank. Alles automatisch, sobald die Datei landet.
4. Content-Verwaltung: Neue Blogposts aus einem RSS-Feed werden automatisch in Notion gespeichert, analysiert und mit passenden Tags versehen. Am Ende der Woche bekommst du eine Zusammenfassung der interessantesten Artikel.
   Das sind keine Science-Fiction-Szenarien. Das sind Workflows, die Leute heute schon nutzen. Und du kannst sie dir fertig aus der Community holen.

2 Warum n8n selber hosten?

Selbsthosting ist kein Selbstzweck. Es ist eine bewusste Entscheidung mit klaren Vorteilen:

1. Datenhoheit: Deine Workflows, deine Zugangsdaten, deine Logs – alles bleibt lokal. Kein Drittanbieter kann mitlesen, keine Cloud-Firma hat Zugriff. Wenn du sensible Daten verarbeitest (Kundendaten, Finanzen, interne Prozesse), ist das ein echter Vorteil.
2. Kostenkontrolle: Keine nutzungsabhängigen Preise. Kein „Du hast dein Limit erreicht, zahl jetzt mehr“-Popup. Du zahlst einmal für die Hardware (die du eh schon hast) und dann: nichts mehr.
3. Erweiterbarkeit: Du kannst eigene Datenbanken anbinden, lokale KI-Modelle laufen lassen, eigene Skripte schreiben. Bei Cloud-Diensten bist du auf das beschränkt, was der Anbieter dir gibt.
4. Lernkurve: Du verstehst, wie Systeme wirklich laufen. Nicht nur „Ich klicke hier, es passiert Magie“, sondern: „Ich verstehe, was ein Container ist, wie Datenbanken funktionieren, wie Netzwerke kommunizieren.“ Das ist Wissen, das dir langfristig hilft.
   Und: Eine Synology NAS eignet sich dafür überraschend gut. Zuverlässig, stromsparend, immer verfügbar. Wahrscheinlich läuft sie bei dir eh schon 24/7 für Backups und Medien. Jetzt machst du einfach mehr daraus.

Bernd: „Aber ich hab keine Lust, mich mit Servern rumzuschlagen. Ich will einfach nur, dass es funktioniert.“
Tanja: „Dann nimm die Cloud-Variante von n8n. Kostet dich 20 Euro im Monat, funktioniert sofort. Aber: Du gibst Kontrolle ab. Und du zahlst für jede Ausführung, jeden Workflow, jede Integration.“
Ulf: „Und wenn ich’s selbst hoste, zahl ich nix?“
Tanja: „Du zahlst Strom. Vielleicht 2 bis 3 Euro im Monat, wenn die NAS eh läuft. Und einmalig ein bisschen Zeit für die Einrichtung. Danach: läuft.“
Bernd: „Wie viel Zeit?“
Tanja: „Wenn du alles zum ersten Mal machst? Eine Stunde. Wenn du dieser Anleitung folgst? Dreißig Minuten.“
Ulf: „Okay. Und was brauche ich dafür?“

2.1 n8n selber hosten vs. gehostete Lösung

Lass uns das kurz gegenüberstellen, damit du eine informierte Entscheidung treffen kannst:

Für viele ist die Cloud-Variante der schnellste Einstieg. Aber langfristig und gerade wenn du mehr Kontrolle willst ist Self-Hosting die bessere Wahl.

2.2 Voraussetzungen

Diese Anleitung basiert auf folgender Ausstattung:

• Synology DiskStation DS1621+
• CPU-Architektur: x86_64 (Intel/AMD)
• DSM 7.2 oder neuer
• Mindestens 2 GB RAM (empfohlen: 4 GB oder mehr)
  Die Schritte funktionieren auch auf anderen x86-Synology-Modellen. Wenn du eine ältere oder ARM-basierte NAS hast, kann es sein, dass bestimmte Docker-Images nicht laufen. Prüf im Zweifel vorher die Kompatibilität.
  Du brauchst keine Vorkenntnisse in Linux, Datenbanken oder Netzwerktechnik. Du musst nur bereit sein, ein paar Einstellungen durchzuklicken und zu verstehen, was du da tust.

Ulf: „Moment. Was ist x86? Ist das wichtig?“
Tanja: „Das ist die Prozessor-Architektur. Also die Sprache, die dein Chip versteht. Die meisten Synology-Modelle mit Intel- oder AMD-Prozessoren sind x86. Wenn du eine ganz alte oder billige NAS hast, kann es sein, dass sie ARM nutzt – dann laufen manche Docker-Images nicht.“
Bernd: „Woher weiß ich, was ich habe?“
Tanja: „Systemsteuerung → Info-Center. Steht da. Oder einfach das Modell googeln.“
Ulf: „Und die 4 GB RAM – ist das Pflicht?“
Tanja: „Nein. n8n läuft auch mit 2 GB. Aber wenn du PostgreSQL nutzen willst – die bessere Datenbank – dann solltest du 4 GB haben. Sonst wird’s eng.“

2.2 Grundbegriffe (kurz erklärt)

Bevor wir loslegen, klären wir zwei Begriffe, die dir immer wieder begegnen werden:

• Docker / Container Stell dir einen Container vor wie eine Werkzeugkiste. In der Kiste ist alles drin, was ein Programm braucht: Code, Bibliotheken, Einstellungen. Du kannst die Kiste öffnen, das Programm läuft. Du kannst sie schließen, das Programm stoppt. Und vor allem: Die Kiste ist sauber getrennt vom Rest deines Systems. Wenn in der Kiste was kaputtgeht, bleibt der Rest unbeschädigt.

Docker ist das System, das diese Kisten verwaltet. Auf der Synology heißt es jetzt Container Manager.

• Volume Ein Volume ist ein gemappter Ordner. Stell dir vor, du arbeitest in deinem Büro (dem Container), aber alle wichtigen Unterlagen liegen in einem Aktenschrank im Keller (der NAS). Der Container greift auf diesen Ordner zu, liest und schreibt Dateien aber die Dateien selbst bleiben außerhalb des Containers gespeichert.

Warum ist das wichtig? Weil Container vergesslich sind. Wenn du einen Container löschst, sind alle Daten darin weg. Aber wenn die Daten in einem Volume liegen, bleiben sie erhalten. Du kannst den Container neu starten, updaten, löschen die Daten sind sicher.

Bernd: „Also ist ein Container wie eine virtuelle Maschine?“
Tanja: „Ähnlich, aber viel schlanker. Eine VM simuliert einen kompletten Computer inklusive Betriebssystem. Ein Container teilt sich das Betriebssystem mit dem Host, ist aber trotzdem isoliert. Deshalb startet ein Container in Sekunden, eine VM braucht Minuten.“
Ulf: „Und wenn ich den Container lösche, sind meine Workflows weg?“
Tanja: „Nur wenn du kein Volume nutzt. Deshalb mappen wir gleich einen Ordner auf der NAS. Dann bleiben deine Daten auch nach einem Neustart oder Update erhalten.“

2.4 SQLite oder PostgreSQL? Eine bewusste Entscheidung

n8n kann mit zwei verschiedenen Datenbanken arbeiten:

• SQLite ist eine eingebettete Datenbank. Sie wird automatisch mit n8n installiert, braucht keine zusätzliche Konfiguration. Alles läuft in einer einzigen Datei. Einfach, unkompliziert, sofort startklar. Wann nutzt du SQLite?
  • Wenn du n8n zum ersten Mal ausprobierst
  • Wenn du nur ein bis fünf einfache Workflows hast
  • Wenn du keine Lust auf zusätzliche Komplexität hast
  • Wenn du n8n nur privat nutzt
• PostgreSQL ist eine ausgewachsene relationale Datenbank. Sie läuft in einem eigenen Container, braucht eigene Einstellungen, eigene Ports. Klingt kompliziert – ist es aber nicht. Und sie ist stabiler, schneller und besser für den produktiven Einsatz. Wann nutzt du PostgreSQL?
  • Wenn du n8n ernsthaft nutzen willst (mehrere Workflows, zeitgesteuerte Prozesse)
  • Wenn du langfristig Daten speichern und analysieren willst
  • Wenn du mindestens 4 GB RAM hast
  • Wenn du irgendwann skalieren willst (mehr Workflows, mehr Daten, mehr Komplexität)

Faustregel: Unter 4 GB RAM → SQLite ab 4 GB RAM → PostgreSQL
Diese Anleitung zeigt dir beide Wege. Du entscheidest. Und du kannst später jederzeit wechseln (mit etwas Aufwand, aber es geht).

Ulf: „Also wenn ich’s einfach halten will, nehme ich SQLite?“
Tanja: „Genau. Läuft sofort, keine zusätzliche Konfiguration. Aber wenn du merkst, dass n8n langsamer wird oder du viele Workflows hast, wechselst du zu PostgreSQL.“
Bernd: „Ich nehme natürlich PostgreSQL. Klingt professioneller.“
Tanja: „Bernd, du hast 2 GB RAM.“
Bernd: „Ach, das reicht schon.“
Tanja: „Nein. Das wird Probleme geben. Nimm SQLite. Oder rüste das RAM auf.“
Ulf: „Ich hab 8 GB. Was nehme ich?“
Tanja: „PostgreSQL. Kein Zweifel.“

3 Die Installationsschritte von n8n

Jetzt wird’s konkret. Wir gehen Schritt für Schritt durch die Installation. Du musst nichts überspringen, nichts raten, nichts voraussetzen. Einfach mitmachen.

Der Überblick:

1. Vorbereitung der DiskStation
2. PostgreSQL Image herunterladen (optional, nur wenn du PostgreSQL nutzt)
3. PostgreSQL Datenbank einrichten (optional)
4. Projekt-Variante mit Docker Compose (Alternative für Fortgeschrittene)
5. n8n Image herunterladen
6. n8n Container konfigurieren
7. Erster Login in n8n

Wenn du SQLite nutzt, überspringst du die Schritte 2 und 3. Wenn du Docker Compose nutzt, überspringst du 2, 3, 5 und 6 und springst direkt zu Schritt 4.
Klingt kompliziert? Ist es nicht. Los geht’s.

3.1 Vorbereitung der DiskStation

Bevor wir n8n starten können, muss die NAS vorbereitet werden. Drei Dinge sind wichtig: den Container Manager installieren, Ordner für die Daten anlegen, Berechtigungen setzen.

Container Manager installieren

Öffne das Paket-Zentrum auf deiner DiskStation. Suche nach Container Manager und klick auf Installieren.

Der Container Manager ist das, was früher „Docker“ hieß. Ein Werkzeug, um Software in isolierten Umgebungen sogenannten Containern laufen zu lassen.
Warum Container? Weil sie sauber getrennt vom Rest des Systems sind. Wenn ein Container abstürzt, crasht nicht die ganze NAS. Wenn du ein Update machst, betrifft es nur den Container. Wenn du n8n deinstallierst, bleiben keine Dateireste zurück.
Container sind wie Mini-Computer in deinem Computer: eigenes Dateisystem, eigenes Netzwerk, eigene Prozesse. Aber sie teilen sich die Hardware mit dem Host. Das macht sie schlank und schnell.

Ulf: „Also ist das wie eine virtuelle Maschine?“
Tanja: „Ähnlich, aber viel effizienter. Eine VM braucht ein komplettes Betriebssystem. Ein Container nutzt das Betriebssystem der NAS mit. Deshalb startet ein Container in Sekunden.“
Bernd: „Und wenn ich den Container lösche, ist alles weg?“
Tanja: „Der Container ja. Aber die Daten nicht wenn du sie in einem Volume speicherst. Deshalb legen wir jetzt Ordner an.“

Ordnerstruktur in File Station anlegen

Öffne die File Station auf deiner DiskStation. Navigiere zum Ordner docker (wurde automatisch angelegt, als du den Container Manager installiert hast). Erstelle einen neuen Unterordner namens n8n.
Dein Pfad sollte jetzt so aussehen: /volume1/docker/n8n

Warum brauchen wir das?

n8n muss Daten speichern: Workflows, Einstellungen, Logs, hochgeladene Dateien. Ohne einen festen Speicherort gehen diese Daten bei jedem Neustart verloren. Der Ordner /docker/n8n ist dieser Speicherort – ein Volume, das zwischen der NAS und dem Container gemappt wird.
Falls du PostgreSQL nutzen willst, leg jetzt schon zwei zusätzliche Unterordner an:

• /docker/n8n/app_data – für n8n-Konfiguration und hochgeladene Dateien
• /docker/n8n/postgres_data – für die Datenbank selbst

Deine Struktur sieht dann so aus:

/docker
  └── n8n
      ├── app_data
      └── postgres_data

Falls du SQLite nutzt, reicht der Hauptordner /docker/n8n.

n8n braucht einen Ort, um Daten zu speichern Workflows, Einstellungen, Logs. Das passiert über Volumes, also gemappte Ordner zwischen der DiskStation und dem Container. Ohne diese Ordner gehen bei einem Neustart alle Daten verloren.
Im gemeinsamen Ordner docker (der automatisch bei der Installation des Container Managers angelegt wurde) erstellt man einen Unterordner n8n.
Falls du dich für PostgreSQL entschieden hast, lege zusätzlich zwei Unterordner an:

• /docker/n8n/app_data – für n8n-Konfiguration und verarbeitete Dateien
• /docker/n8n/postgres_data – für die Datenbank selbst

Ulf: „Warum heißt der Ordner docker? Ich dachte, es heißt jetzt Container Manager?“
Tanja: „Synology hat umbenannt, aber der Ordner heißt intern immer noch docker. Das ist nur ein Name. Wichtig ist, dass du deine Daten dort ablegst.“
Bernd: „Kann ich den Ordner auch woanders hinlegen?“
Tanja: „Kannst du. Aber dann musst du später die Pfade anpassen. Bleib beim Standard, das macht’s einfacher.“

Tipp: Dateikomprimierung deaktivieren
Falls du auf deinem Volume die Dateikomprimierung aktiviert hast (das ist eine Synology-Funktion, um Speicherplatz zu sparen), solltest du sie für den Ordner postgres_data deaktivieren.
Warum? Weil Datenbanken permanent auf ihre Dateien zugreifen lesen, schreiben, ändern. Komprimierung verlangsamt diesen Prozess massiv. PostgreSQL wird träge, Workflows laufen langsamer, manchmal gibt’s sogar Timeouts.
So deaktivierst du die Komprimierung:

1. Rechtsklick auf den Ordner postgres_data → Eigenschaften
2. Tab Allgemein → Checkbox Komprimierung aktivieren deaktivieren
3. Speichern

Für app_data und n8n ist Komprimierung unkritisch. Aber für Datenbanken: niemals.

Berechtigungen prüfen

Rechtsklick auf den Ordner /docker/n8n → Eigenschaften → Tab Berechtigungen

Wichtig: Die Gruppe Everyone braucht Lese- und Schreibrechte.
Warum? Weil der Container unter einem anderen Benutzer läuft als du. Wenn die Berechtigungen nicht stimmen, kann n8n nicht auf den Ordner zugreifen und startet entweder gar nicht oder wirft kryptische Fehlermeldungen.
Falls die Berechtigung noch nicht gesetzt ist:

1. Klick auf Bearbeiten
2. Wähle die Gruppe Everyone
3. Setze die Haken bei Lesen und Schreiben
4. Auf Unterordner anwenden aktivieren
5. Speichern

Bernd: „Everyone? Das klingt unsicher. Kann dann nicht jeder auf meine Daten zugreifen?“
Tanja: „Everyone bedeutet hier: alle Benutzer auf dieser NAS. Nicht jeder im Internet. Solange deine NAS nicht öffentlich erreichbar ist, ist das kein Problem.“
Ulf: „Und wenn ich’s doch sicherer haben will?“
Tanja: „Dann erstellst du einen speziellen Benutzer für Docker, gibst nur dem die Rechte und passt die Container-Config an. Aber das ist für den Anfang Overkill.“

Häufige Fehler & Lösungen beim Container-Start

Einer der häufigsten Fehler beim Start von n8n ist diese Meldung: Error: permission denied open '/home/node/.n8n/config

Das bedeutet: Der Container hat keine Schreibrechte auf den Ordner.
Lösung 1 (über die UI): Geh zurück zu Eigenschaften → Berechtigungen und prüf, ob Everyone wirklich Lese- und Schreibrechte hat. Falls nicht: setzen, speichern, Container neu starten.
Lösung 2 (über SSH, die „Brechstange“): Falls die UI nicht hilft, öffne eine SSH-Verbindung zur NAS und gib ein:
bash

sudo chmod -R 777 /volume1/docker/n8n

Das gibt allen Benutzern volle Rechte auf den Ordner. Das ist nicht besonders elegant, aber es funktioniert. Im produktiven Einsatz solltest du die Rechte später auf den spezifischen Docker-User einschränken aber für den Anfang ist das okay.

Bernd: „Warum brauche ich SSH? Kann ich das nicht einfach in der Oberfläche machen?“
Tanja: „In den meisten Fällen ja. Aber manchmal sind die Rechte so verbockt, dass du per Terminal ran musst. Das ist dann der sichere Weg.“
Ulf: „Okay, Ordner sind da, Rechte sind gesetzt. Was jetzt?“
Tanja: „Jetzt holen wir uns die Software. Entweder PostgreSQL – oder direkt n8n, wenn du SQLite nimmst.“

3.2 PostgreSQL Image herunterladen (optional, nur wenn du PostgreSQL nutzt)

Wenn du SQLite nutzt, überspring diesen Schritt und geh direkt zu Schritt 3.5. Wenn du lieber Docker Compose nutzen willst, spring direkt zu Schritt 3.4.
Für PostgreSQL brauchen wir zuerst das Image eine Art Vorlage für den Container. Synology lädt diese Images aus einer öffentlichen Registrierung herunter (dem „Docker Hub“).
Öffne den Container Manager → Tab Registrierung
In der Suchleiste: Tipp postgres ein.
Es erscheinen mehrere Ergebnisse. Du willst das offizielle Image, erkennbar am grünen „Docker Official Image“-Badge.
Klick darauf → Download
Jetzt musst du einen Tag auswählen. Ein Tag ist eine Versionsnummer.
Wähl 16. Das ist die aktuelle stabile Version (Stand Januar 2025) und wird längerfristig unterstützt.

Der Download läuft ein paar Minuten. Du siehst den Fortschritt im Tab Image. Sobald der Download fertig ist, kannst du weitermachen.

Ulf: „Warum nicht einfach latest nehmen? Dann hab ich immer die neueste Version.“
Tanja: „Weil latest gefährlich ist. Wenn PostgreSQL ein großes Update macht zum Beispiel von Version 16 auf 17, kann es sein, dass deine Datenbank nicht mehr kompatibel ist. Plötzlich startet nichts mehr, und du weißt nicht warum. Mit einer festen Version bist du sicher.“
Bernd: „Aber dann muss ich doch später manuell updaten?“
Tanja: „Ja. Aber lieber kontrolliert updaten als ungewollt kaputt updaten.“

3.3 PostgreSQL Datenbank einrichten (optional)

Jetzt konfigurieren wir den PostgreSQL-Container. Das ist der Teil, den viele als kompliziert empfinden aber wenn du weißt, was jede Einstellung bedeutet, ist es easy.

Schritt 1: Allgemeine Einstellungen

Container-Name: n8n-postgres
Das ist einfach der Name, unter dem der Container später läuft. Du kannst ihn frei wählen, aber nimm was Sinnvolles. Wenn du irgendwann mehrere Datenbanken hast, willst du nicht raten müssen, welche zu n8n gehört.
Ressourcenbeschränkung: Nicht aktivieren (vorerst)
Du kannst Container auf eine bestimmte Menge RAM oder CPU beschränken. Das macht Sinn, wenn du viele Container laufen hast und die NAS nicht überlasten willst. Aber für den Anfang: lass es aus. Falls PostgreSQL später zu viel frisst, stellst du Mittel ein und setzt das RAM-Limit auf 2048 MB oder 4096 MB.
Automatischen Neustart: Aktivieren
Das ist wichtig. Wenn die NAS neu startet wegen eines Updates, eines Stromausfalls, was auch immer – soll PostgreSQL automatisch wieder hochfahren. Sonst steht n8n plötzlich ohne Datenbank da und du wunderst dich, warum nichts mehr geht.
Web-Portal via Web Station einrichten: Nicht aktivieren
Das ist eine Synology-Komfortfunktion, um Container über eine schicke Weboberfläche erreichbar zu machen. Brauchen wir hier nicht. PostgreSQL hat eh keine Web-UI.
Klick auf Weiter.

Schritt 2: Port-Einstellungen

PostgreSQL läuft standardmäßig auf Port 5432. Aber: Wenn du mehrere Datenbanken auf der NAS hast, kann es sein, dass dieser Port schon belegt ist.
Deshalb mappen wir:

• Lokaler Port: 5433
• Container-Port: 5432
• Typ: TCP

Das bedeutet: Intern im Container läuft PostgreSQL auf 5432 (wie üblich). Aber von außen also von der NAS oder von n8n aus greifst du über 5433 zu.

Wichtig: Prüf, ob der Port in der Firewall freigegeben ist. Geh dazu in die Systemsteuerung → Sicherheit → Firewall → Regeln bearbeiten. Falls eine Firewall aktiv ist, füg eine Regel hinzu, die Port 5433 für lokale Verbindungen zulässt.
Klick auf Weiter.

Ulf: „Warum ist der Port überhaupt wichtig? Kann ich da nicht einfach irgendwas eintragen?“
Tanja: „Ein Port ist wie eine Tür in einem Gebäude. Jede Anwendung braucht ihre eigene Tür, damit die Daten wissen, wo sie hin müssen. Wenn zwei Anwendungen dieselbe Tür nutzen wollen, gibt’s Ärger.“
Bernd: „Und wenn ich nicht weiß, ob ein Port frei ist?“
Tanja: „Dann probier’s einfach aus. Wenn der Container nicht startet und eine Fehlermeldung kommt wie ‚Port already in use‘, nimm einen anderen.“

Schritt 3: Volume-Einstellungen

Hier passiert die Magie: Du verbindest den Container mit einem Ordner auf der NAS.
Klick auf Ordner hinzufügen → Wähl /docker/n8n/postgres_data
Im Feld Mount-Pfad trägst du ein: /var/lib/postgresql/data
Das bedeutet: Alles, was PostgreSQL im Container unter /var/lib/postgresql/data speichert (also die gesamte Datenbank), landet tatsächlich auf der NAS unter /docker/n8n/postgres_data.
Warum ist das wichtig? Weil Container flüchtig sind. Wenn du den Container löschst, sind alle Daten darin weg. Aber wenn die Daten auf der NAS liegen, bleiben sie erhalten. Du kannst den Container updaten, neu starten, löschen – die Datenbank bleibt.
Klick auf Weiter.

Bernd: „Kann ich auch mehrere Volumes haben?“
Tanja: „Klar. Aber PostgreSQL braucht nur eins. Für n8n brauchen wir später ein zweites.“

Schritt 4: Umgebungsvariablen

Umgebungsvariablen sind Konfigurationseinstellungen, die dem Container mitteilen, wie er sich verhalten soll. Für PostgreSQL sind drei wichtig:
Klick auf + Hinzufügen und trag folgendes ein:

Wichtig: Schreib das Passwort irgendwo auf. Du brauchst es gleich, wenn wir n8n konfigurieren.
Klick auf Weiter.

Ulf: „Kann ich das Passwort auch einfach lassen? Also leer?“
Tanja: „Nein. PostgreSQL startet ohne Passwort gar nicht erst. Und selbst wenn – das wäre ein riesiges Sicherheitsrisiko.“
Bernd: „Und wenn ich das Passwort vergesse?“
Tanja: „Dann kannst du dich nicht mehr in die Datenbank einloggen. Musst alles neu aufsetzen. Also: Passwort-Manager.“

Schritt 5: Netzwerk

Hier bleibt alles auf Standard.
Das Netzwerk heißt bridge – das ist das Default-Netzwerk, in dem alle Container miteinander kommunizieren können.
Klick auf Weiter.

Schritt 6: Zusammenfassung

Synology zeigt dir jetzt eine Übersicht aller Einstellungen. Prüf nochmal:

• Container-Name: n8n-postgres
• Automatischer Neustart: aktiviert
• Port: 5433 → 5432
• Volume: /docker/n8n/postgres_data → /var/lib/postgresql/data
• Umgebungsvariablen: User, Passwort, DB-Name gesetzt
  Alles korrekt? Klick auf Fertig.
  Der Container startet. Nach ein paar Sekunden sollte er im Tab Container als läuft angezeigt werden.

Ulf: „Woher weiß ich, ob PostgreSQL wirklich funktioniert?“
Tanja: „Du kannst die Logs checken. Geh in den Container Manager, klick auf den Container n8n-postgres, dann auf Details → Log. Da solltest du eine Zeile sehen wie: database system is ready to accept connections. Dann läuft’s.“
Bernd: „Und wenn da ein Fehler steht?“
Tanja: „Dann lies die Fehlermeldung. Meist ist es ein Problem mit den Berechtigungen oder den Umgebungsvariablen. Geh die Schritte nochmal durch.“

3.4 Projekt-Variante mit Docker Compose (Alternative)

Docker Compose ist eine Methode, um mehrere Container mit einer einzigen Konfigurationsdatei zu starten. Statt jeden Container einzeln zu konfigurieren, schreibst du alles in eine Datei und fertig.
Warum solltest du Docker Compose nutzen?

• Wiederholbar: Du kannst die Konfiguration speichern, sichern, auf andere Systeme übertragen.
• Einfache Wartung: Alle Dienste (n8n, PostgreSQL) werden gemeinsam gestartet und gestoppt.
• Skalierbar: Wenn du später noch Redis, einen Reverse-Proxy oder andere Dienste hinzufügen willst, erweiterst du einfach die Datei.
  Für wen ist Docker Compose?
  Für alle, die gerne Code statt UI nutzen. Wenn du lieber Einstellungen in einer Textdatei pflegst als durch Menüs zu klicken, ist das dein Weg.

Schritt 1: Projekt erstellen

Öffne den Container Manager → Tab Projekt → Erstellen
Projektname: n8n-stack (oder wie auch immer du es nennen willst)
Pfad: /volume1/docker/n8n
Quelle: „docker-compose.yml erstellen“
Jetzt öffnet sich ein Texteditor. Lösch alles, was da steht, und füg folgenden Code ein:

version: '3.8'

services:
  db:
    image: postgres:16
    container_name: n8n-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=n8n_admin
      - POSTGRES_PASSWORD=Dein_Postgress_Passwort
      - POSTGRES_DB=n8n_db
    volumes:
      - /volume1/docker/n8n/postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U n8n_admin -d n8n_db"]
      interval: 5s
      timeout: 5s
      retries: 5
    networks:
      - n8n-network

  n8n:
    image: n8nio/n8n:latest
    container_name: n8n-app
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=db
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n_db
      - DB_POSTGRESDB_USER=n8n_admin
      - DB_POSTGRESDB_PASSWORD=Dein_Postgress_Passwort
      - N8N_ENCRYPTION_KEY=Dein_Encryption_Key
      - N8N_SECURE_COOKIE=false
      - WEBHOOK_URL=https://n8n.deine-domain.xyz/
    volumes:
      - /volume1/docker/n8n/app_data:/home/node/.n8n
    depends_on:
      db:
        condition: service_healthy
    networks:
      - n8n-network

networks:
  n8n-network:
    driver: bridge

Was passiert hier?

• Wir definieren zwei Dienste: db (PostgreSQL) und n8n (n8n selbst).
• Beide laufen im selben Netzwerk (n8n-network), können also miteinander kommunizieren.
• n8n wartet, bis PostgreSQL bereit ist (depends_on mit service_healthy).
• Alle Einstellungen, die wir vorher einzeln geklickt haben, stehen jetzt in dieser Datei.
  Was musst du anpassen?

1. Passwort: Ersetze Dein_Postgress_Passwort durch dein eigenes sicheres Passwort (mindestens 20 Zeichen, zufällig generiert).
2. Encryption Key: Ersetze Dein_Encryption_Key durch einen zufälliges Passwort Deiner Wahl.  Ohne N8N_ENCRYPTION_KEY riskierst du bei Neuinstallation oder Umzug unlesbare Secrets.
3. Webhook URL: Wenn du später Cloudflare oder eine eigene Domain nutzen willst, trag die hier ein. Vorerst kannst du das auch weglassen oder auf http://DEINE-NAS-IP:5678/ setzen.
   Klick auf Weiter, dann auf Fertig.
   Das System lädt jetzt beide Images herunter (falls noch nicht geschehen) und startet die Container. Das kann ein paar Minuten dauern.

Ulf: „Okay, das sieht kompliziert aus. Muss ich das alles verstehen?“
Tanja: „Nicht jedes Detail. Aber du solltest grob wissen, was passiert: Zwei Container werden gestartet, beide bekommen ihre Einstellungen, beide können miteinander reden. Fertig.“
Bernd: „Und wenn ich was ändern will?“
Tanja: „Dann gehst du zurück zum Projekt, klickst auf Bearbeiten, änderst die Datei und startest neu. Alles zentral.“

Schritt 2: Prüfen, ob alles läuft

Geh in den Container Manager → Tab Container
Du solltest jetzt zwei Container sehen:

• n8n-postgres – Status: läuft
• n8n-app – Status: läuft
  Zusätzlich sollte mach ein paar Sekunden auf Cloudflare der Tunnel als „Healthy“ angezeigt werden. Jetzt ist n8n über die Domain erreichbar: https://n8n.deine-domain.xyz
  Falls einer nicht läuft, klick drauf und schau ins Log. Meist ist es ein Tippfehler in der YAML-Datei oder ein Problem mit den Berechtigungen.
  Wenn beide laufen, kannst du direkt zu Schritt 3.7 springen.

Tanja: „Docker Compose ist mein bevorzugter Weg. Einmal richtig aufgesetzt, läuft’s. Und wenn ich das Setup auf eine andere NAS übertragen will, kopiere ich einfach die Datei.“
Ulf: „Aber ich muss doch auch die Ordner mitnehmen, oder?“
Tanja: „Klar. Ordner kopieren, docker-compose.yml anpassen, starten. Aber das ist immer noch schneller als alles neu zu klicken.“

3.5 n8n Image herunterladen

Wenn du Docker Compose genutzt hast, überspring diesen Schritt. Jetzt holen wir uns n8n selbst. Auch hier brauchen wir zuerst das Image.
Öffne den Container Manager → Tab Registrierung
In der Suchleiste: Tipp n8nio/n8n ein.
Das offizielle n8n-Image erscheint. Klick darauf → Download
Wähl den Tag latest.

Bei n8n ist latest okay, weil die Entwickler sehr sauber versionieren und Updates meist problemlos laufen. Wenn du es sicherer haben willst, wähl eine feste Version (z. B. 1.70.0 oder was auch immer aktuell ist).
Der Download läuft ein paar Minuten. Sobald er fertig ist, geht’s weiter.

Bernd: „Warum heißt das Image n8nio/n8n? Das klingt komisch.“
Tanja: „Das ist die Namenskonvention auf Docker Hub. n8nio ist der Herausgeber, n8n ist das Produkt. So wie postgres für PostgreSQL.“

3.6 n8n Container konfigurieren

Jetzt kommt der längste Schritt aber auch der wichtigste. Hier stellst du ein, wie n8n laufen soll.
Die wichtigsten Einstellungen:

Geh in den Container Manager → Tab Image Such das Image n8nio/n8n:latest → Klick drauf → Ausführen
Es öffnet sich wieder der Assistent. Wir gehen Schritt für Schritt durch.

Schritt 1: Allgemeine Einstellungen

Container-Name: n8n-app
Ressourcenbeschränkung: Nicht aktivieren (vorerst)
n8n ist normalerweise sparsam. Aber wenn du viele Workflows parallel laufen lässt oder große Dateien verarbeitest, kann es RAM ziehen. Falls nötig, stell später Mittel ein und begrenze auf 2–4 GB.
Automatischen Neustart: Aktivieren
Wie bei PostgreSQL: Wenn die NAS neu startet, soll n8n automatisch wieder hochfahren.
Web-Portal via Web Station einrichten: Nicht aktivieren
Brauchen wir nicht. n8n hat eine eigene Web-UI.
Klick auf Weiter.

Schritt 2: Port-Einstellungen

n8n läuft standardmäßig auf Port 5678. Das ist auch der Port, über den du später im Browser zugreifst.
Trag ein:

• Lokaler Port: 5678
• Container-Port: 5678
• Typ: TCP

Wichtig: Prüf die Firewall. Geh in die Systemsteuerung → Sicherheit → Firewall → Regeln bearbeiten und stell sicher, dass Port 5678 für lokale Verbindungen freigegeben ist.
Klick auf Weiter.

Schritt 3: Volume-Einstellungen

Hier unterscheiden wir uns jetzt je nachdem, ob du SQLite oder PostgreSQL nutzt.
Für SQLite:

• Klick auf Ordner hinzufügen → Wähl /docker/n8n
• Im Feld Mount-Pfad: /home/node/.n8n
  Für PostgreSQL:
• Klick auf Ordner hinzufügen → Wähl /docker/n8n/app_data
• Im Feld Mount-Pfad: /home/node/.n8n
  Das bedeutet: Alle Daten, die n8n im Container unter /home/node/.n8n speichert (Workflows, Einstellungen, Logs), landen auf der NAS unter /docker/n8n bzw. /docker/n8n/app_data.
  Klick auf Weiter.

Zusätzlich für PostgreSQL:
Falls du PostgreSQL nutzt, kommen jetzt noch ein paar Variablen dazu:

Ulf: „Warum muss ich die IP der NAS eintragen? Ich dachte, die Container laufen doch auf derselben Maschine?“
Tanja: „Tun sie. Aber jeder Container hat sein eigenes Netzwerk. Wenn n8n localhost anspricht, meint es seinen eigenen Container nicht die NAS. Deshalb musst du die NAS-IP angeben.“
Bernd: „Und wenn ich die IP nicht weiß?“
Tanja: „Dann guck in die Systemsteuerung → Netzwerk → Netzwerkschnittstelle. Da steht’s.“

Schritt 5: Netzwerk

Auch hier bleibt alles auf Standard: bridge.
Klick auf Weiter.

Schritt 6: Zusammenfassung

Synology zeigt dir nochmal alle Einstellungen. Prüf:

• Container-Name: n8n-app
• Automatischer Neustart: aktiviert
• Port: 5678 → 5678
• Volume: richtig gemappt
• Umgebungsvariablen: alles gesetzt
  Alles korrekt? Klick auf Fertig.
  Der Container startet.

Tanja: „Und jetzt die spannende Frage: Läuft’s?“
Ulf: „Woher weiß ich das?“
Tanja: „Öffne deinen Browser und gib ein: http://DEINE-NAS-IP:5678„

3.7 Erster Login in n8n

Öffne deinen Browser. Tipp ein: http://DEINE-NAS-IP:5678 (ersetze DEINE-NAS-IP durch die tatsächliche IP, z. B. http://192.168.178.50:5678)
Nach ein paar Sekunden sollte sich die n8n-Oberfläche öffnen.://DEINE-NAS-IP:5678

Du siehst jetzt ein Formular: Set up owner account
Hier erstellst du deinen Admin-Account:

• E-Mail: Deine echte E-Mail-Adresse (wichtig für den Lizenzschlüssel)
• Vorname / Nachname: Kann auch ein Pseudonym sein
• Passwort: Wieder: mindestens 20 Zeichen, zufällig, sicher
  Klick auf Sign up.

n8n schickt dir jetzt eine E-Mail mit einem kostenlosen Lizenzschlüssel. Der schaltet ein paar zusätzliche Features frei (Community-Support, Templates, etc.). Du brauchst ihn nicht zwingend, aber es lohnt sich.
Sobald die E-Mail da ist:

• Geh in n8n → Settings → Usage & Plan
• Trag den Lizenzschlüssel ein
• Speichern
  Fertig. n8n ist betriebsbereit.

Ulf: „Und jetzt? Was mache ich als Erstes?“
Tanja: „Schau dich um. Klick auf Workflows → New Workflow. Zieh ein paar Nodes auf die Fläche. Probier rum. Das ist der beste Weg, um zu lernen.“
Bernd: „Ich hab hier eine Fehlermeldung: ‚Your n8n server is configured to use a secure cookie…‘ Was soll das?“

Tanja: „Das bedeutet, dass N8N_SECURE_COOKIE auf true steht, aber du kein HTTPS nutzt. Geh zurück in den Container, setz die Variable auf false, starte den Container neu. Dann geht’s.“
Bernd: „Und später wieder auf true?“
Tanja: „Genau. Sobald du Cloudflare oder ein SSL-Zertifikat hast.“

4 Fazit

Wenn du n8n selber hosten möchtest und zusätzlich sicheren externen Zugriff brauchst, empfehle ich dir den Artikel n8n mit Cloudflare Tunnel absichern – die perfekte Ergänzung zu dieser Anleitung.

Tanja lehnt sich zurück.
„So. Dein n8n läuft jetzt auf deiner Synology NAS. Du hast die volle Kontrolle, du zahlst nichts extra, und du kannst loslegen.“
Ulf: „Und jetzt baue ich Workflows?“
Tanja: „Genau. Fang klein an. Verbinde zwei Apps. Lass dir eine Benachrichtigung schicken, wenn etwas passiert. Probier die KI-Integration aus. Und wenn du nicht weiterkommst, schau in die Template-Datenbank. Da ist für fast alles schon was dabei.“
Bernd: „Ich hab schon eine Idee. Ich will, dass n8n automatisch meine E-Mails…“
Tanja: „Bernd. Bitte. Fang mit was Einfachem an. Sonst sitzt du morgen wieder hier und fragst, warum alles in Flammen steht.“
Ulf: „Und wenn ich Fragen habe?“
Tanja: „Dann schreib sie in die Kommentare unter diesem Artikel. Oder schau in die n8n-Community. Oder probier einfach. Das Schöne an Containern: Du kannst nichts kaputt machen. Schlimmstenfalls startest du neu.“

Du hast es geschafft.
Du hast n8n selber hosten auf deiner Synology NAS erfolgreich umgesetzt. PostgreSQL läuft (falls du dich dafür entschieden hast). Du hast einen Admin-Account und kannst loslegen.
Der nächste Schritt: Workflows bauen.

Automatisiere etwas, das dich nervt
Und wenn du Verbesserungsvorschläge für diese Anleitung hast – oder Ideen für Workflows, die ich testen soll – schreib’s in die Kommentare.
Viel Erfolg. Und: Hab Spaß. Automatisierung ist kein Hexenwerk. Es ist Lego für Erwachsene.

Die Anleitung richtet sich an alle, die:

• WordPress eigenständig betreiben möchten
• Wert auf Datenschutz (DSGVO), Sicherheit und Nachhaltigkeit legen
• ihre Website langfristig erweitern wollen (Blog, Projekte, Downloads, Formulare)

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen und WordPress wirklich zu verstehen.

Tanja ist die IT-Expertin in dieser Geschichte. Sie weiß, wie WordPress funktioniert, erklärt geduldig und strukturiert – und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.
Bernd ist der selbsternannte „Experte“, der alles besser weiß – und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.
Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung – dafür ist Tanja da.

„Und… Action!“

Tanja: „Okay, heute richten wir eine WordPress-Website ein. Von Null auf Live.“
Bernd: „WordPress? Das ist doch dieser kostenlose Blog-Kram, oder? Installier ich in fünf Minuten.“
Ulf: „Ich hab gehört, das ist kompliziert. Braucht man da nicht so… Server und Datenbanken?“
Tanja: „Genau die richtige Einstellung, Ulf. Ja, wir brauchen ein paar technische Grundlagen. Aber keine Panik – wir gehen Schritt für Schritt durch. Und Bernd: Wenn du in fünf Minuten fertig bist, hast du garantiert etwas übersehen.“

1 Warum WordPress?

Bernd: „Warum nicht einfach WIX? Da klickst du dir was zusammen und fertig.“
Tanja: „Weil du bei WIX.com in einer Mietswohnung lebst. Bei WordPress gehört dir das Haus.“
Und das ist kein Marketing-Spruch. WordPress ist nicht ohne Grund das weltweit meistgenutzte Content-Management-System. Laut aktuellen Marktanalysen laufen über 40 % aller Websites auf WordPress. Es ist sowohl einsteigerfreundlich als auch langfristig skalierbar.
Verglichen mit anderen Content-Management-Systemen wie Joomla (komplexere Bedienung für Anfänger) oder TYPO3 (eher für große Enterprise-Projekte geeignet), punktet WordPress vor allem mit der mit Abstand größten Community und der umfangreichsten Auswahl an Plugins.
Ulf: „Plugins? Was ist das?“
Tanja: „Denk an Plugins wie an Werkzeuge in deinem Werkzeugkasten. Du hast eine Grundausstattung – deine Website. Und dann fügst du Werkzeuge hinzu: einen Spamfilter, ein Backup-Tool, ein Suchmaschinen-Optimierungs-Kit. Jedes Plugin erfüllt eine bestimmte Aufgabe.“
Genau diese Erweiterbarkeit macht den Unterschied. Während Baukastensysteme wie Wix oder Squarespace durch ihre intuitive Drag-and-Drop-Oberfläche überzeugen, sind sie bei der Suchmaschinenoptimierung und bei individuell angepassten Funktionen meist schnell am Limit. WordPress schafft hier genau die richtige Mischung aus hoher Flexibilität und gleichzeitig guter Bedienbarkeit.

WordPress.org eignet sich ideal, wenn du:

• Inhalte künftig selbst unkompliziert pflegen möchtest
• Die Website flexibel erweitern willst (Unterseiten, Formulare, Downloads)
• Unabhängig von Baukasten-Anbietern bleiben möchtest
• Eine professionelle und kosteneffiziente Lösung suchst
  Der Mehrwert gegenüber Abo-Baukästen zeigt sich konkret in drei Bereichen:
• Trennung von Inhalt und Design: Themes jederzeit wechselbar – als würdest du die Tapete wechseln, ohne die Möbel neu kaufen zu müssen
• Große Plugin-Auswahl: SEO, Sicherheit, Performance, Shop
• Volle Datenhoheit: Eigene Datenbank, eigener Server

Bernd: „Aber bei Wix bezahle ich doch nur 15 Euro im Monat.“
Tanja: „Ja, solange du bleibst. Versuch mal, deine Inhalte umzuziehen. Viel Spaß dabei. Bei WordPress zahlst du fürs Hosting – etwa 5 bis 10 Euro im Monat – und behältst alles unter Kontrolle.“
Genau das ist der Punkt: Als Open-Source-CMS läuft WordPress bei vielen Hostern und lässt sich bei Bedarf problemlos umziehen. Langfristig fallen im Wesentlichen nur Kosten für Hosting und Domain an.
Ulf: „Verstanden. Aber wo fange ich konkret an?“
Tanja: „Gute Frage. Ich zeige dir 5 Schritte, mit denen du den Überblick behältst:“

1. Die richtige WordPress‑Plattform wählen
2. WordPress manuell installieren
3. Grundlegende Seiten & Design einrichten
4. Inhalte strukturieren und veröffentlichen
5. Weitere Plugins und Tools einrichten

2 Die richtige WordPress‑Plattform wählen

Ulf: „Moment. Es gibt verschiedene WordPress-Versionen?“
Tanja: „Zwei Hauptvarianten. WordPress.com und WordPress.org. Der Unterschied ist riesig.“

2.1 WordPress.com vs. WordPress.org

Kostenlose Plattformen wie WordPress.com ermöglichen einen schnellen Einstieg ohne technische Vorkenntnisse.

Vorteile:

• Schneller Start ohne technischen Aufwand
• Hosting inklusive

Nachteile:

• Stark eingeschränkte Design- und Funktionsmöglichkeiten
• Kaum Kontrolle über Plugins, SEO und Daten
• Risiko: Kontosperrung oder Löschung möglich

Bernd: „Klingt doch super. Einfach, schnell, kostenlos.“
Tanja: „Bis WordPress.com deine Seite offline nimmt, weil du gegen irgendeine Nutzungsbedingung verstoßen hast. Oder bis du merkst, dass du keine Plugins installieren kannst. Dann sitzt du in der Falle.“ Im Gegensatz dazu steht WordPress.org (self-hosted):

Vorteile:

• Das „echte“ WordPress mit voller Kontrolle
• Freie Wahl bei Themes, Plugins und Einstellungen
• Du entscheidest, was passiert

Nachteile:

• Eigene Verantwortung für Updates, Sicherheit und Backups
• Benötigt eigenes Webhosting (kostenpflichtig)

Fazit: Wenn du deine Website langfristig betreiben oder ausbauen möchtest, ist WordPress.org die deutlich nachhaltigere Lösung.

Ulf: „Okay, ich will die Kontrolle. Aber was ist Hosting?“
Tanja: „Hosting ist der Speicherplatz, auf dem deine Website liegt. Stell dir vor, deine Website ist ein Haus. Das Hosting ist das Grundstück, auf dem es steht.“

2.2 Hosting-Optionen

Es gibt zwei Hosting-Modelle:

Klassisches Webhosting:

• Volle Kontrolle
• Günstig
• Technische Verantwortung liegt bei dir

Managed WordPress-Hosting:

• Updates, Backups, Sicherheit inklusive
• Weniger technischer Aufwand
• Höhere Kosten und teilweise eingeschränkte Konfigurationsfreiheit

Bernd: „Managed klingt doch entspannt.“
Tanja: „Ja, aber du zahlst das Drei- bis Fünffache. Und für Anfänger reicht klassisches Hosting völlig aus.“

Ich habe mich für ein klassisches Webhosting bei STRATO entschieden, weil meine Domain dort bereits lag. Es ist nicht zwingend der „beste“ Hoster, aber für meine Zwecke die pragmatischste Lösung ohne Umzugsstress.

3 WordPress manuell installieren

Ulf: „Manuell? Gibt’s da nicht so einen ‚1-Klick-Installer‘?“
Tanja: „Gibt’s. Nutzen wir aber nicht.“
Bernd: „Warum nicht? Ist doch viel schneller!“
Tanja: „Weil du dann nicht verstehst, was passiert. Wenn später etwas schiefgeht, stehst du da und weißt nicht, wo du anfangen sollst. Wir machen das richtig – einmal, von Grund auf.“
Ich verzichte bewusst auf „1-Click-Installationen“, die einige Hosting-Anbieter anbieten, um:

• Dateirechte und Struktur vollständig zu verstehen
• maximale Kontrolle über Sicherheit und Updates zu behalten
• später problemlos migrieren zu können

Bevor du WordPress installieren kannst, brauchst du eine Domain (deine Webadresse). Die Domain kannst du gemeinsam mit einem Hosting-Paket bei vielen Anbietern kaufen.

Technische Mindestanforderungen, damit du das richtige Paket beim WebHoster auswählst:

• PHP-Version: Mindestens 7.4, besser 8.2 oder höher für maximale Geschwindigkeit und Sicherheit
• Datenbank: MySQL ab Version 8.0 oder MariaDB ab Version 10.6
• Arbeitsspeicher (PHP Memory Limit): Mindestens 256 MB, damit auch umfangreiche Plugins flüssig laufen

Diese Anforderungen erfüllen nahezu alle modernen Webhoster.

Der folgende Installations-Prozess (entspricht dem offiziellen WordPress‑Standard):

1. Datenbank anlegen: SQL-Datenbank (z. B. MariaDB) im Hoster-Panel erstellen
2. WordPress herunterladen: Aktuelles Paket von WordPress.org laden
3. WordPress hochladen (FTP): Mit FileZilla Dateien auf den Server laden
4. WordPress installieren: Installationsassistent im Browser folgen
5. Sicherheit erhöhen: Plugins wie Wordfence installieren

3.1 Datenbank anlegen

Ulf: „Datenbank? Klingt nach IT-Keller.“
Tanja: „Eine Datenbank ist wie ein digitales Aktenschrank-System. Deine Website speichert dort alle Beiträge, Kommentare, Einstellungen. Ohne Datenbank keine WordPress-Website.“
So gehst du vor:

1. Bei deinem Hosting-Anbieter einloggen
2. SQL Datenbank erstellen (z.B. MariaDB 10)
3. Zugangsdaten notieren:
   • Datenbankname
   • Benutzername
   • Passwort
   • Datenbank Server / Host
     Wichtig: Schreib dir diese Zugangsdaten auf. Du brauchst sie später bei der Installation.

3.2 WordPress herunterladen

Bernd: „Kann ich mir WordPress nicht einfach irgendwo runterladen?“
Tanja: „Kannst du. Aber dann riskierst du, dir eine manipulierte Version einzufangen. Geh immer zur offiziellen Quelle.“
So gehst du vor:

1. Offizielle Quelle: WordPress.org
2. Lade die ZIP-Datei über „Get WordPress“ herunter
3. Entpacke die ZIP-Datei lokal auf deinem Computer
   Wichtig: Nur von der offiziellen Quelle herunterladen, um saubere Originaldateien zu erhalten und manipulierte Dateien zu vermeiden.

3.3 WordPress hochladen (FTP)

Ulf: „FTP? Was ist das jetzt wieder?“
Tanja: „File Transfer Protocol. Ein Weg, um Dateien von deinem Computer auf den Server zu schieben. Stell dir vor, du schickst einen Umzugswagen mit Möbeln von deinem Haus zu einem anderen Haus. FTP ist der Umzugswagen.“
So gehst du vor:

1. FTP-Zugangsdaten im Hosting-Anbieter Portal abrufen z.B. unter SFTP & SSH bei STRATO
   • Server / Host („sftp://“ muss bei FileZilla vor Server stehen)
   • Port
   • Benutzername
   • Passwort
2. SFTP-Zugang aktivieren für sicheren Upload
3. FTP‑Client (z.B. FileZilla) installieren. Über FileZilla kannst Du den Client kostenlos herunterladen (für macOS, Windows oder Linux)
4. Zielordner anlegen: Erstelle im Root-Verzeichnis des Servers einen neuen Ordner (z.B. /foundic/)
   • Damit deine Domain später direkt auf dieses Verzeichnis zeigen kann
   • In FileZilla: Rechtsklick → „Verzeichnis erstellen“
5. Alle entpackten WordPress-Dateien hochladen: Ziehe alle entpackten WordPress-Dateien per Drag & Drop in den neuen Ordner
   • Dauer: ca. 3-10 Minuten je nach Verbindung
6. Struktur prüfen: Dein Verzeichnis sollte nun enthalten:
   • /wp-admin/
   • /wp-content/
   • /wp-includes/
   • Dateien wie index.php, wp-login.php, wp-config-sample.php

7. Domain verbinden: In der Domainverwaltung die Domain auf das Stammverzeichnis setzen
   • Bei STRATO: Paket-Verwaltung → Domains → Domain auswählen → „Verwalten“
   • Unter „Ziel der Domain“ auf „Intern“ umstellen
   • Pfad eingeben: /foundic/ (dein angelegter Ordner)
   • Speichern – die Domain zeigt nun auf dein WordPress-Verzeichnis

Falls der Installationsassistent einmal hakt: Du kannst die Datei wp-config-sample.php manuell in wp-config.php umbenennen und deine Datenbankdaten direkt dort eintragen, bevor du sie per FTP hochlädst.

3.4 WordPress installieren

Tanja: „Jetzt kommt der entspannte Teil. WordPress macht den Rest fast von allein.“
Bernd: „Hätte man das nicht gleich so machen können?“
Tanja: „Bernd, wir haben gerade die Grundmauern gelegt. Jetzt kommt der Innenausbau.“
So gehst du vor:

1. Öffne deinen Browser und rufe deine Domain auf (z.B. https://foundic.org)
2. Der Installationsassistent startet automatisch
3. Wähle die Sprache aus
4. Gib die Datenbankdaten aus Schritt 1 ein
5. Lege einen neuen WordPress-Admin-Benutzer an
   • Sicherheitshinweis: Verwende ein neues, starkes Passwort
6. Melde dich erstmalig an über https://deine-domain.de/wp-login.php
   Erste Einstellungen nach der Installation
7. Updates prüfen Dashboard → Aktualisierungen: Prüfe, ob WordPress und Plugins aktuell sind
8. Permalinks optimieren Einstellungen → Permalinks → „Beitragsname“ auswählen
   • Bessere Lesbarkeit für Besucher
   • Verbessert SEO (Suchmaschinenoptimierung)

Ulf: „Permalinks? Was ist das?“
Tanja: „Die URLs deiner Beiträge. Standardmäßig sieht das so aus: deine-seite.de/?p=123. Mit Permalinks wird daraus: deine-seite.de/mein-erster-beitrag. Viel lesbarer, besser für Google.“

9. Unnötige Plugins entfernen Plugins → Deaktivieren und löschen von:
   • „Hello Dolly“
   • „Akismet“ (falls nicht benötigt)
   • Je weniger Plugins, desto schneller und sicherer
10. Öffentlichen Namen festlegen Benutzer → Dein Profil → Spitznamen eintragen → Als „Öffentlicher Name“ auswählen

3.5 Sicherheit erhöhen

Bernd: „Sicherheit? Wer will denn meine Website hacken?“
Tanja: „Niemand persönlich. Aber es gibt automatisierte Bots, die täglich tausende WordPress-Seiten durchscannen und versuchen, sich einzuloggen. Wenn du keine Sicherheitsvorkehrungen triffst, bist du ein leichtes Ziel.“
So gehst du vor:

1. Plugin „Wordfence Security“ installieren
   • Plugin installieren und aktivieren
   • Kostenlose Lizenz unter wordfence.com
   • Brute-Force-Protection in der Free-Version auf 100% setzen

Ulf: „Brute-Force? Klingt nach Einbrecher.“
Tanja: „Ist es auch. Brute-Force heißt: Ein Bot probiert tausende Passwörter durch, bis er reinkommt. Wordfence blockt solche Versuche.“

2. Plugin “ UpdraftPlus“ für Backups
   • Plugin installieren und aktivieren
   • Einstellungen → Rhythmus und Speicherort wählen (z.B. Google Drive)
3. Plugin Antispam Bee
   • Datenschutzfreundliche, lokale Spam-Lösung (keine Datenübertragung in die USA)
   • Meine Einstellungen:
     • Kommentare nur in Deutsch und Englisch zulassen
     • Spam nach 30 Tagen automatisch löschen
     • Spam-Zähler im Dashboard aktivieren
4. Plugins WPS Hide Login
   • Verändert die Standard-Login-URL von /wp-login.php zu einer individuellen URL (z.B. /mein-geheimer-login)
   • Einstellungen → Allgemein → WPS Hide Login

Bernd: „Warum die Login-URL verstecken?“
Tanja: „Weil jeder Bot weiß, dass WordPress-Seiten unter /wp-login.php erreichbar sind. Wenn du die URL änderst, laufen die meisten Angriffe ins Leere.“

5. HTTPS prüfen Einstellungen → Allgemein: Stelle sicher, dass beide URLs mit https:// beginnen:
   • WordPress-Adresse (URL)
   • Website-Adresse (URL).

4 Grundlegende Seiten & Design einrichten

Tanja: „Technik steht. Jetzt kommt die Optik.“
Ulf: „Endlich! Ich will, dass das Ding gut aussieht.“
Bernd: „Ich nehm einfach irgendein Theme. Sind doch eh alle gleich.“
Tanja: „Falsch. Es gibt Themes, die sind schnell, sauber und anpassbar. Und es gibt Themes, die sind vollgestopft mit unnötigem Code, verlangsamen deine Seite und sind ein Albtraum, wenn du etwas ändern willst.“
Ich nutze das Astra Theme, da es schnell und extrem anpassbar ist.
Die ersten Seiten:

1. Das Design wählen (Theme): Astra-Theme installieren und DSGVO-konform konfigurieren
2. Rechtliche Pflichtseiten erstellen: Impressum und Datenschutzseite erstellen
3. „Test-Daten“ entfernen: aus WordPress

4.1 Das Design (Theme) wählen

Theme installieren Design → Themes → Theme hinzufügen → „Astra“ suchen → Installieren und aktivieren

Meine Astra-Einstellungen:

DSGVO-Warnung zu Google Fonts: Wenn Google Fonts aus den USA geladen werden, wird die IP-Adresse des Besuchers übertragen (Urteil LG München I, 20.01.2022, Az. 3 O 17493/20). Prüfe deine Seite mit dem Google Fonts Checker wie https://sicher3.de/google-fonts-checker/.

Notwendige Anpassungen:

1. DSGVO-konforme Schriften
   • Astra → Dashboard → Einstellungen → Leistung → „Google Fonts lokal laden“ aktivieren

Ulf: „Warum lokal laden?“
Tanja: „Weil Google Fonts standardmäßig von Google-Servern geladen werden. Dabei wird die IP-Adresse deiner Besucher an Google übertragen – ein DSGVO-Verstoß. Wenn du die Schriften lokal lädst, bleiben die Daten bei dir.“

2. Container-Layout
   • Design → Customizer → Global → Container: „Box-Layout“, 1200px / 1000px
3. Farbschema
   • Design → Customizer → Global → Farben
     • Akzent: #111827(Edles Schwarz)
     • Links: #2563EB(Modernes Blau), #1D4ED8 (leicht stärkeres Blau)
     • Überschriften: #111827(Edles Schwarz)
     • Website-Hintergrund: #F5F6F7(Hellgrau)
     • Hintergrund des Inhalts: #FFFFFF(Weiß)
4. Schriftzeichen
   • Design → Customizer → Global → Typografie
     • Schrift für die Überschrift: Inter, Sans-Serif / 15px / 800
     • H1-Schrift: 30px (von 64px)
     • H2-Schrift 27px (von 48px)
     • H3-Schrift 24px (von 24px)
     • H4-Schrift 21 px (von 20px)
5. Header anpassen
   • Design → Customizer → Header
     • Website-Titel: FOUNDIC.org
     • Titelfarbe: #2563EB(dezentes Blau), #1D4ED8(leicht stärkers Blau)
     • Rand oben: 1px, Farbe #E0E0E0(leichtes Grau)
     • Astra Logo kann entfernt werden und später eigenes ergänzt werden
6. Footer anpassen
   • Design → Customizer → Footer
     • Rand oben: 1px, Farbe #E0E0E0(leichtes Grau)
7. Zusätzliches CSS
   • Das „Feintuning“ über CSS Code:

/* 1. Synchronisation: Gleicher Zeilenabstand für Absätze und Listenpunkte */
.entry-content p, 
.entry-content ul li, 
.entry-content ol li {
    line-height: 1.6; /* Gleicht den Zeilenabstand an */
    margin-bottom: 0;   /* Entfernt den extra Platz zwischen den einzelnen Listenpunkten */
}

/* 2. Absatz-Design: Festlegen des Standard-Abstands nach einem Textblock */
.entry-content p {
    margin-bottom: 1em; /* Dies ist dein "normaler" Textabstand zwischen Absätzen */
}

/* 3. Listen-Reset: Theme-eigene Abstände der Liste nach oben/unten entfernen */
.entry-content ul, 
.entry-content ol {
    margin-top: 0;
    margin-bottom: 1em; /* Gleicher Abstand nach der Liste wie nach einem Absatz */
}

/* 4. Präzisions-Korrektur: Abstand VOR dem Start der Liste */
/* Wenn eine Liste direkt auf einen Absatz folgt, wird der Abstand so reduziert, 
   dass er optisch exakt dem Abstand zwischen zwei Text-Absätzen entspricht. */
.entry-content p + ul, 
.entry-content p + ol {
    margin-top: -0.5em; /* Verringert den Abstand zum Einleitungstext */
}

/* 5. Interner Listen-Abstand: Polsterung der Listenpunkte neutralisieren */
.entry-content li {
    padding-bottom: 0;
    margin-top: 0;
}

Ulf: „Warum so viel CSS-Gefrickel?“ 
Tanja: „Weil WordPress-Themes oft eigene Abstände mitbringen, die nicht immer harmonisch aussehen. Mit diesem Code sorgen wir dafür, dass Listen und Absätze optisch gleichmäßig wirken – wie in einem professionell gesetzten Buch.“

4.2 Rechtliche Pflichtseiten erstellen

Bernd: „Braucht man das wirklich?“
Tanja: „Ja. In Deutschland ist ein Impressum gesetzlich vorgeschrieben. Ohne Impressum riskierst du Abmahnungen. Und die kosten schnell mehrere hundert Euro.“
Jeder Internetauftritt in Deutschland benötigt ein Impressum und eine Datenschutzerklärung.

4.2.1 Impressum erstellen

Stelle sicher, dass dein Impressum folgende Angaben enthält, um rechtssicher zu sein:

• Vollständiger Name und Anschrift (kein Postfach)
• Schnelle Kontaktmöglichkeit (E-Mail-Adresse und Telefonnummer)
• Bei Unternehmen: Rechtsform, Vertretungsberechtigte und Registernummer/Registergericht
• Falls vorhanden: Umsatzsteuer-Identifikationsnummer (USt-IdNr.)
• Für journalistische Inhalte: Name eines inhaltlich Verantwortlichen

Ich bin folgendermaßen vorgegangen:

1. Entwurf mit https://www.e-recht24.de -> Impressumsgenerator erstellt
2. WordPress: Seiten → Seite hinzufügen
3. Titel: „Impressum“
4. Text einfügen und veröffentlichen

4.2.2 Datenschutzerklärung erstellen

1. Erstelle einen Entwurf mit zum Beispiel einem Datenschutz-Generator von https://datenschutz-generator.de/
2. Erwähne alle installierten Plugins (Wordfence, UpdraftPlus, Antispam Bee, WPS Hide Login)
3. Gib deinen Hoster an
4. WordPress: Seiten → Seite hinzufügen
5. Titel: „Datenschutz“
6. Text einfügen und veröffentlichen

4.2.3 Footer-Menü Impressum und Datenschutz aufnehmen

1. Design → Menüs → „Neues Menü erstellen“
2. Name: „Footer“
3. Seiten hinzufügen: Impressum und Datenschutz
4. Position: „Footer-Menü“ auswählen
5. Menü speichern

6. Copyright-Zeile anpassen: Design → Customizer → Footer → Copyright
7. Ersetze „Powered by…“ durch:
   <span style="font-size: 12pt;">Copyright [copyright] [current_year] [site_title] | <a href="/impressum/">Impressum</a>&nbsp;| <a href="/datenschutz/">Datenschutz</a></span>

4.3 „Test-Daten“ entfernen

WordPress liefert Beispiel-Inhalte mit, die gelöscht werden sollten:

• Seiten → Alle Beispiel-Seiten in den Papierkorb
• Beiträge → Alle Beispiel-Beiträge in den Papierkorb

Bernd: „Warum löschen? Vielleicht brauche ich die noch.“
Tanja: „Du brauchst sie nicht. Das sind nur Platzhalter. Wenn du sie nicht löschst, tauchen sie in deinem Archiv auf – und das sieht unprofessionell aus.“

5 Inhalte strukturieren und veröffentlichen

Ulf: „Jetzt geht’s los! Ich will Artikel schreiben!“
Tanja: „Moment. Bevor du losschreibst, müssen wir die Struktur klären. WordPress unterscheidet zwischen Seiten und Beiträgen. Das ist wichtig.“
Ulf: „Wo ist der Unterschied?“
Tanja: „Seiten sind für statische Inhalte – Impressum, Datenschutz, Über uns. Die erstellst du einmal und änderst sie selten. Sie stehen immer an derselben Stelle, tauchen nicht chronologisch auf und haben kein Datum. Beiträge dagegen sind dein Blog. Sie erscheinen chronologisch auf deiner Startseite, werden in Kategorien sortiert und signalisieren Google: Diese Seite lebt, hier passiert was.“
Ulf: „Also Seiten wie Regale im Laden, Beiträge wie wöchentliche Angebote?“
Tanja: „Perfekte Analogie. Genau so. Die Regale bleiben, die Angebote wechseln.“

Diese Trennung ist ein zentraler Vorteil gegenüber vielen Baukästen – und entscheidend für dein SEO-Ranking. Suchmaschinen bevorzugen frischen Content, und Beiträge liefern genau das.

Mein Ziel ist es, dass alle Beiträge chronologisch auf der Startseite erscheinen und zusätzlich in Kategorien organisiert werden.

• Startseiten-Einstellung: Einstellungen → Lesen → „Deine letzten Beiträge“ auswählen → Änderungen speichern

Die Checkliste für die Installation:

1. Kategorien anlegen: Kategorien „Redaktionelle Beiträge“ und „Projekt“ anlegen
2. Menü korrekt verlinken: Kategorien im Menü zuordnen und sortieren
3. Dein erster Beitrag: Beiträge erstellen, kategorisieren und Bilder hinzufügen
4. Eine einfache Suche installieren: Suchfunktion im Header einrichten, optional Relevanssi-Plugin

5.1 Kategorien anlegen

Beiträge → Kategorien → Neue Kategorien erstellen:

• „Redaktionelle Beiträge“ (Titelform: beitraege)
• „Projekt“ (Titelform: projekte)
• Standard-Kategorie „Allgemein“ umbenennen in „Startseite“

Ulf: „Titelform? Was ist das?“
Tanja: „Das ist der Teil, der in der URL auftaucht. Aus ‚Redaktionelle Beiträge‘ wird in der URL ‚beitraege‘. Sieht sauberer aus und ist besser für SEO.“

5.2 Menü korrekt verlinken

Ulf: „Ich hab Kategorien angelegt. Wie kommen die jetzt ins Menü?“
Tanja: „Gute Frage. WordPress fügt Kategorien nicht automatisch ins Menü ein – das musst du manuell machen.“
Bernd: „Warum nicht automatisch? Wäre doch praktisch.“
Tanja: „Weil du vielleicht nicht alle Kategorien im Menü haben willst. Du behältst die Kontrolle.“

Design → Menüs → Kategorien → „Alle anzeigen“

• Kategorien auswählen und „Zum Menü hinzufügen“
• Per Drag & Drop sortieren
• Menü speichern

5.3 Dein erster Beitrag

Ulf: „Okay, jetzt will ich endlich schreiben!“
Tanja: „Los geht’s. Der Beitrags-Editor heißt übrigens Gutenberg – benannt nach dem Erfinder des Buchdrucks.“
Bernd: „Warum so kompliziert? Einfach Text reinhauen und fertig.“
Tanja: „Fast. Aber ein paar Dinge solltest du beachten, damit der Beitrag auch richtig kategorisiert wird.“

Beiträge → Beitrag hinzufügen (im Beitrags-Editor auch „Gutenberg“ genannt)

• Titel eingeben
• Text schreiben
• Kategorie auswählen (rechte Seitenleiste weiter unten)
• Optional: Beitragsbild festlegen (rechte Seitenleiste → Beitragsbild)
• Veröffentlichen (siehe https://www.foundic.org/mein-erster-beitrag-mit-dummy-text/)

Beitrags-Layout anpassen von Raster zu Liste: Design → Customizer → Inhaltstypen → Blog/Archive → Blog-Layout: „Liste“ für vertikale Anordnung

Beitragsbild zusätzlich auf Einzelseite anzeigen: Design → Customizer → Inhaltstypen → Einzelbeitrag → Struktur → „Beitragsbild“ aktivieren

Bernd: „Warum das Beitragsbild zweimal einstellen?“
Tanja: „Einmal für die Übersicht (deine Startseite) und einmal für den einzelnen Beitrag. Manche Themes zeigen das Bild nicht automatisch im Beitrag selbst – dann musst du es explizit aktivieren.“

5.4 Eine einfache Suche installieren

Basis-Suche aktivieren

1. Design → Customizer → Header
2. Im Header-Builder auf ein „+“ klicken
3. Lupe (Suche) auswählen und platzieren
4. Veröffentlichen

Erweiterte Suche mit Plugin Relevanssi (Optional)

1. Plugin „Relevanssi – A Better Search“ installieren
2. Einstellungen → Indexierung → „Index aufbauen“
3. Der Index wird automatisch bei neuen Beiträgen aktualisiert
4. Suchergebnisse werden nach Relevanz sortiert und Begriffe hervorgehoben

Ulf: „Warum brauche ich Relevanssi? Die Standard-Suche funktioniert doch.“
Tanja: „Die Standard-WordPress-Suche ist simpel. Sie findet nur exakte Begriffe. Relevanssi durchsucht auch Synonyme, gewichtet Überschriften höher und hebt Suchbegriffe hervor. Für Besucher ist das viel hilfreicher.“

6 Weitere Plugins und Tools einrichten

Bernd: „Ich installiere einfach alle Plugins, die gut klingen.“
Tanja: „Bitte nicht. Jedes Plugin ist zusätzlicher Code, der geladen werden muss. Zu viele Plugins machen deine Seite langsam und unsicher. Die Faustregel lautet: so wenig wie möglich, aber so viele wie nötig.“

Bei Plugins gilt die Faustregel: so wenig wie möglich, aber so viele wie nötig. Zu viele Plugins können Sicherheit und Performance verschlechtern.

Bereits installierten Plugins:

• Sicherheit: Wordfence Security (Brute-Force-Schutz).
• Backup: UpdraftPlus (Speichert Backups direkt in Google Drive).
• Spam-Schutz: Antispam Bee (Datenschutzfreundlich, da lokal).
• Login-Schutz: WPS Hide Login (ändert die Adminzugangs-URL).

Zusätzlich empfehlen ich folgende Plugins:
WP Fastest Cache

• Verbessert die Ladegeschwindigkeit durch Caching
• Installation: Plugin installieren → Aktivieren → WP Fastest Cache → Einstellungen → „Cache-System“ aktivieren → Submit

Ulf: „Caching? Was macht das?“
Tanja: „Stell dir vor, du kopierst ein Dokument, statt es jedes Mal neu zu schreiben. Caching speichert eine fertige Version deiner Website und liefert diese aus – statt sie jedes Mal neu zu berechnen. Das macht deine Seite deutlich schneller.“

Rank Math SEO

Ulf: „SEO? Das ist doch, damit man bei Google gefunden wird, oder?“
Tanja: „Genau. Rank Math hilft dir, deine Seite für Suchmaschinen zu optimieren – Meta-Daten, Seitenstruktur, SEO-Signale. Alles an einem Ort.“
Bernd: „Ich nehm einfach den Advanced Mode. Klingt professioneller.“
Tanja: „Bernd, ausnahmsweise liegst du richtig – Advanced Mode ist am Ende wichtig. Aber du musst die Installation im einfachen Modus machen, sonst fehlen dir später Funktionen. Also:
Setup im einfachen Modus, dann auf Advanced umschalten.“

• Optimiert WordPress-Websites technisch und inhaltlich für Suchmaschinen, indem es Meta-Daten, Seitenstruktur und SEO-Signale zentral steuert.
• Installation: Plugin installieren → Aktivieren → Setup-Assistent
• Modus „Einfach“
• Google-Dienste überspringen
• Wichtige erste Einstellung: Rank Math SEO -> Dashboard -> oben rechts „Advanced Mode“, damit hast Du später im Editor mehr Möglichkeiten Rank Math SEO pro Seite und Beitrag anzupassen.

Folgende Plugins stehen auf meiner ToDo Liste für später:

• Cookie-Consent-Tool wie Complianz oder Borlabs, bevor ich Google Analytics & AdSense installiere
• Inhaltsverzeichnis-Plugin wie Easy Table of Contents
• Bildoptimierungs-Plugin wie Shortpixel Optimizer
• KI-Plugins wie Jetpack AI oder spezielle SEO-KI-Erweiterungen

Bernd: „KI-Plugins? Schreibt mir die KI dann meine Artikel?“
Tanja: „Teilweise. KI kann dir helfen, Überschriften zu optimieren, Meta-Beschreibungen zu generieren oder Texte zu überarbeiten. Aber die Verantwortung bleibt bei dir.“

7 Fazit

Ulf: „Das war’s? Meine Website steht?“
Tanja: „Ja. Du hast jetzt eine voll funktionsfähige WordPress-Website. Mit eigener Domain, eigenem Design, Sicherheitsmaßnahmen und rechtlichen Pflichtseiten.“
Bernd: „Hätte ich doch gleich Wix genommen.“
Tanja: „Bernd, du hast jetzt volle Kontrolle. Du kannst Plugins installieren, Themes wechseln, deine Seite migrieren, wann immer du willst. Bei Wix wärst du in einem goldenen Käfig.“
Ulf: „Ehrlich gesagt dachte ich, das wird viel komplizierter.“
Tanja: „Genau das ist der Punkt. WordPress wirkt am Anfang einschüchternd, aber wenn du die Grundlagen einmal verstanden hast, läuft alles flüssig. Und das Beste: Du bist nicht abhängig von einem Anbieter.“

Hast du Fragen zur Installation oder steckst bei einem Schritt fest? Oder hast du Verbesserungsvorschläge für diese Anleitung oder foundic.org? Ich freue mich über dein Feedback in den Kommentaren!