1345 lines
54 KiB
Markdown
1345 lines
54 KiB
Markdown
# Kapitel 10 – n8n (Free)
|
||
|
||
## Einleitung
|
||
|
||
Mit dem Tool **n8n** (gesprochen: „n‑n“) führst du eine zentrale Komponente für Automatisierungen in dein UCC-System ein. Das Ziel ist, wiederkehrende Aufgaben wie Erinnerungen, Uploads oder Social-Media-Posts nicht manuell erledigen zu müssen – sondern automatisiert, nachvollziehbar und kontrolliert im Hintergrund ablaufen zu lassen.
|
||
|
||
n8n ist eine sogenannte Low-Code-Automatisierungsplattform. Du erstellst Abläufe („Workflows“) visuell, indem du vordefinierte Funktionen – sogenannte „Nodes“ – miteinander verbindest. Es gibt Nodes für Zeitpläne, HTTP-Requests, Datenbanken, Social Media, Kalender, E-Mail, Twitch, Discord und viele weitere Dienste. Gleichzeitig kannst du eigene JavaScript-Logik ergänzen, wenn du mehr Kontrolle brauchst.
|
||
|
||
Im Gegensatz zu externen Diensten wie Zapier, Make oder IFTTT läuft n8n vollständig lokal – in einem eigenen Container auf deinem Server. Das bedeutet:
|
||
|
||
- keine Daten verlassen dein Netzwerk,
|
||
- keine Anmeldung oder Drittanbieter-Abhängigkeit,
|
||
- keine Einschränkungen bei der Anpassung.
|
||
|
||
[!NOTE]
|
||
Wir verwenden in diesem Tutorial ausschließlich die kostenfreie **Community Edition** von n8n. Diese wird lokal installiert, läuft dauerhaft im eigenen Container und stellt alle für den Einstieg relevanten Funktionen bereit.
|
||
|
||
Dieses Kapitel behandelt ausschließlich die Grundlagen:
|
||
- Installation von n8n auf einem dedizierten Ubuntu-Container,
|
||
- Konfiguration und Start als systemweiter Dienst,
|
||
- Integration über Nginx Proxy Manager mit Subdomain und HTTPS,
|
||
- Erstellung eines ersten produktiven Workflows (Stream-Reminder + Social Post).
|
||
|
||
Das hier erstellte Setup bildet die technische Basis für spätere Erweiterungen, z. B. das automatische Auslesen von Twitch-Kalenderdaten (ICS-Dateien), das Erzeugen und Planen von Social-Media-Inhalten oder automatisierte Uploads in deine Nextcloud. Diese folgen im Premium-Kapitel.
|
||
|
||
Wie immer setzen wir kein technisches Vorwissen voraus. Alles, was du für dieses Kapitel brauchst, hast du in den vorherigen Schritten bereits eingerichtet: Proxmox, LXC, Proxy, Domain und grundlegende Netzwerkstruktur. Wenn du diesen Abschnitt erfolgreich abgeschlossen hast, kannst du erste Automatisierungen vollständig eigenständig umsetzen – mit deinem eigenen System und ohne Drittanbieter.
|
||
|
||
---
|
||
|
||
## Voraussetzungen & Ressourcen
|
||
|
||
Bevor du mit der Installation von n8n beginnst, solltest du sicherstellen, dass dein System korrekt vorbereitet ist. In diesem Abschnitt definieren wir die nötigen Ressourcen für den LXC-Container und klären, welche technischen Voraussetzungen erfüllt sein müssen, damit alle späteren Schritte funktionieren.
|
||
|
||
### Container-Ressourcen
|
||
|
||
Für den n8n-Container legen wir folgende Ausstattung fest:
|
||
|
||
* **CPU: 2 vCPUs**
|
||
Zwei virtuelle Prozessoren reichen für die Ausführung typischer n8n‑Workflows im Hintergrund.
|
||
Falls du später viele parallele Abläufe oder aufwendige API-Abfragen nutzen möchtest, kannst du die CPU-Zahl bei Bedarf erhöhen.
|
||
|
||
* **RAM: 2 GB**
|
||
Der Node.js-Prozess von n8n benötigt vergleichsweise wenig Arbeitsspeicher.
|
||
Mit 2 GB läuft das System auch bei mehreren gleichzeitig aktiven Workflows stabil.
|
||
Nur bei sehr großen Datenverarbeitungen (z. B. viele gleichzeitige Uploads oder komplexe Datenmanipulationen) kann mehr RAM sinnvoll sein.
|
||
|
||
* **Speicherplatz: 10 GB**
|
||
Dieser Platz reicht für die Grundinstallation, Logdateien und temporäre Workflow-Daten.
|
||
Da n8n keine großen Medien speichert, ist der Speicherbedarf überschaubar.
|
||
Wenn du viele eigene Skripte oder große JSON-Daten verarbeitest, kannst du den Container später vergrößern.
|
||
|
||
* **Betriebssystem: Ubuntu 24.04 LTS (64‑Bit)**
|
||
Wir setzen hier auf Ubuntu, da es moderne Pakete für Node.js bereitstellt und sich gut für die manuelle Installation eignet.
|
||
Zudem verwenden wir Node.js ≥ 18.x, was unter Ubuntu besonders gut unterstützt wird.
|
||
|
||
* **Netzwerk: Feste IP-Adresse per DHCP-Reservierung**
|
||
Wie in Kapitel 1 beschrieben, richtest du im Router eine DHCP-Reservierung für den Container ein.
|
||
So bleibt er immer unter derselben Adresse erreichbar und kann später korrekt im Proxy Manager eingebunden werden.
|
||
|
||
[!TIP]
|
||
Plane beim Erstellen des Containers genug Reserven ein – auch wenn n8n anfangs wenig verbraucht.
|
||
Gerade wenn du das System später für Uploads, VOD-Verarbeitung oder komplexe Kalenderanalysen nutzt, steigen RAM- und CPU-Anforderungen deutlich.
|
||
|
||
### Technische Voraussetzungen
|
||
|
||
Dieses Kapitel baut auf der bestehenden UCC-Grundstruktur auf. Folgende Komponenten solltest du bereits eingerichtet haben:
|
||
|
||
* **Proxmox läuft stabil** (Kapitel 1)
|
||
Der LXC-Container für n8n wird direkt dort erstellt und verwaltet.
|
||
|
||
* **Nginx Proxy Manager ist eingerichtet** (Kapitel 3)
|
||
Darüber wird n8n später mit Subdomain, HTTPS und Zertifikat erreichbar gemacht.
|
||
|
||
* **Domain oder DynDNS-Adresse ist vorhanden** (Kapitel 4)
|
||
Für die öffentliche Erreichbarkeit und Let's Encrypt brauchst du eine gültige Subdomain, z. B. `n8n.deinprojekt.de`.
|
||
|
||
* **Zugriff auf das Container-Terminal**
|
||
Du benötigst entweder direkten Zugriff über die Proxmox-Konsole oder per SSH auf den Container.
|
||
|
||
[!IMPORTANT]
|
||
Wenn du n8n nur im lokalen Netzwerk einsetzen möchtest, kannst du den Container auch ohne Domain und HTTPS betreiben. Die Anleitung funktioniert in diesem Fall ebenfalls – du musst später lediglich eigene Proxy-Regeln anpassen.
|
||
|
||
### Software und Versionen
|
||
|
||
In diesem Kapitel installierst du alle benötigten Komponenten manuell – ohne Docker, vollständig nachvollziehbar:
|
||
|
||
* **Node.js** – ab Version 18.x (erforderlich für aktuelle n8n-Releases)
|
||
* **npm** – Node Package Manager, wird automatisch mit Node.js installiert
|
||
* **n8n** – Automatisierungstool, wird systemweit per `npm install -g` eingerichtet
|
||
* **PM2** – Prozessmanager, sorgt für dauerhaften Hintergrundbetrieb und Autostart
|
||
|
||
Alle Schritte erfolgen in der richtigen Reihenfolge und mit ausführlichen Erklärungen – du brauchst keine Vorkenntnisse im Umgang mit Node.js oder JavaScript.
|
||
|
||
[!TIP]
|
||
Die direkte Installation ohne Docker erhöht die Transparenz. Du behältst volle Kontrolle über die Dateien, Logs und Prozesse – und kannst das System bei Bedarf gezielt sichern oder migrieren.
|
||
|
||
---
|
||
|
||
## Schritt 1 – Grundsystem aktualisieren
|
||
|
||
Bevor wir mit der Installation von n8n beginnen, sorgen wir dafür, dass das Betriebssystem im Container auf dem neuesten Stand ist.
|
||
Das ist wichtig, um Fehler durch veraltete Pakete zu vermeiden und eine stabile Grundlage für die weiteren Schritte zu schaffen.
|
||
|
||
Öffne dazu in Proxmox die **Shell** des n8n-Containers.
|
||
Wähle in der linken Seitenleiste den Container aus und klicke auf **Shell**.
|
||
|
||
👉 Screenshot geeignet: Proxmox – Container ausgewählt und Konsole geöffnet
|
||
|
||
Gib anschließend den folgenden Befehl ein, um alle Paketlisten zu aktualisieren und die verfügbaren Updates zu installieren.
|
||
Starte danach den Container neu, damit die Aktualisierungen aktiv werden:
|
||
|
||
```bash
|
||
apt update && apt upgrade -y
|
||
reboot
|
||
```
|
||
|
||
[!NOTE]
|
||
Führe diesen Schritt auch dann durch, wenn der Container gerade erst erstellt wurde.
|
||
Ein aktuelles Grundsystem verhindert spätere Konflikte bei der Installation von Node.js und n8n.
|
||
|
||
## Schritt 2 – Node.js & n8n installieren
|
||
|
||
Nach dem Update ist das System bereit für die Installation der benötigten Software.
|
||
n8n basiert auf Node.js, daher müssen wir zunächst Node.js und den zugehörigen Paketmanager **npm** einrichten.
|
||
Anschließend installieren wir n8n selbst sowie den Prozessmanager **PM2**, damit n8n dauerhaft im Hintergrund laufen kann.
|
||
|
||
### Benutzer wechseln
|
||
|
||
Wir installieren n8n nicht mit Administrator-Rechten, sondern unter einem eigenen Benutzerkonto.
|
||
Melde dich daher mit dem Benutzer an, den du in Schritt 1 erstellt hast:
|
||
|
||
```bash
|
||
su - n8nuser
|
||
```
|
||
|
||
👉 Screenshot geeignet: Konsole – Anmeldung als Benutzer `n8nuser`
|
||
|
||
### Node.js installieren
|
||
|
||
Zuerst fügen wir das offizielle NodeSource-Repository hinzu, um die aktuelle Version (mindestens 18.x) zu erhalten, und installieren dann Node.js und npm:
|
||
|
||
```bash
|
||
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
|
||
sudo apt install -y nodejs
|
||
```
|
||
|
||
Prüfe nach der Installation die Versionen:
|
||
|
||
```bash
|
||
node -v
|
||
npm -v
|
||
```
|
||
|
||
Die angezeigten Versionsnummern sollten mindestens `v18.x` für Node.js und eine aktuelle npm-Version zeigen.
|
||
|
||
[!NOTE]
|
||
Falls eine deutlich ältere Version angezeigt wird, wiederhole die Installation oder kontrolliere die Repository-Adresse.
|
||
|
||
### n8n und PM2 installieren
|
||
|
||
Installiere nun n8n und den Prozessmanager PM2 global über npm:
|
||
|
||
```bash
|
||
sudo npm install -g n8n pm2
|
||
```
|
||
|
||
Mit PM2 stellst du sicher, dass n8n auch nach einem Neustart automatisch startet.
|
||
|
||
Überprüfe anschließend, ob n8n korrekt installiert wurde:
|
||
|
||
```bash
|
||
n8n --version
|
||
```
|
||
|
||
Die Ausgabe zeigt die aktuell installierte n8n-Version an.
|
||
|
||
[!TIP]
|
||
PM2 sorgt dafür, dass n8n später automatisch als Hintergrunddienst läuft.
|
||
Die Konfiguration dafür nehmen wir im nächsten Schritt vor.
|
||
|
||
## Schritt 3 – n8n als Dienst einrichten und starten
|
||
|
||
Damit n8n nicht nur manuell über die Konsole gestartet werden kann, richten wir den automatischen Start mit **PM2** ein.
|
||
So läuft n8n dauerhaft im Hintergrund und wird bei jedem Neustart des Containers automatisch geladen.
|
||
|
||
### n8n erstmals starten
|
||
|
||
Starte n8n zunächst einmalig, um sicherzustellen, dass es fehlerfrei läuft:
|
||
|
||
```bash
|
||
n8n
|
||
```
|
||
|
||
Die Konsole zeigt nun Startmeldungen von n8n an und wartet anschließend auf Anfragen.
|
||
Beende den Prozess wieder mit der Tastenkombination `Strg + C`.
|
||
|
||
👉 Screenshot geeignet: Konsole – n8n erfolgreich gestartet und wartet auf Anfragen
|
||
|
||
### PM2 einrichten
|
||
|
||
Mit PM2 starten wir n8n als Hintergrundprozess:
|
||
|
||
```bash
|
||
pm2 start n8n
|
||
```
|
||
|
||
Damit n8n automatisch beim Systemstart geladen wird, registriere den PM2-Startdienst:
|
||
|
||
```bash
|
||
pm2 startup
|
||
sudo env PATH=$PATH:/usr/bin pm2 startup systemd -u n8nuser --hp /home/n8nuser
|
||
pm2 save
|
||
```
|
||
|
||
* `pm2 startup` zeigt den notwendigen Befehl für den Autostart an.
|
||
* Mit `pm2 save` speicherst du die aktuelle PM2-Prozessliste.
|
||
|
||
### Dienststatus prüfen
|
||
|
||
Überprüfe, ob n8n nun im Hintergrund läuft:
|
||
|
||
```bash
|
||
pm2 list
|
||
```
|
||
|
||
Die Ausgabe sollte den Prozess `n8n` mit dem Status **online** anzeigen.
|
||
|
||
[!NOTE]
|
||
Ab diesem Punkt läuft n8n automatisch im Hintergrund und wird bei jedem Neustart des Containers selbstständig gestartet.
|
||
|
||
## Schritt 4 – n8n im Nginx Proxy Manager einbinden
|
||
|
||
Öffne den **Nginx Proxy Manager** und lege einen neuen Proxy-Host für n8n an.
|
||
|
||
1) **Anmelden** im NPM-Dashboard
|
||
👉 Screenshot geeignet: NPM – Dashboard nach Login
|
||
|
||
2) Klicke auf **Add Proxy Host**
|
||
|
||
3) Trage im Reiter **Details** folgende Werte ein:
|
||
|
||
| Feld | Wert / Auswahl |
|
||
|--------------------------------|------------------------------------------|
|
||
| **Domain Names** | `n8n.deinedomain.tld` |
|
||
| **Scheme** | `http` |
|
||
| **Forward Hostname / IP** | IP-Adresse des n8n-Containers |
|
||
| **Forward Port** | `5678` |
|
||
| **Block Common Exploits** | aktivieren |
|
||
| **Websockets Support** | aktivieren |
|
||
|
||
👉 Screenshot geeignet: Formular „Add Proxy Host“ mit IP des n8n-Containers und Port 5678
|
||
|
||
4) Wechsle zu **SSL** und setze:
|
||
|
||
| Feld | Einstellung |
|
||
|-----------------------------------|----------------------------|
|
||
| **Request a new SSL Certificate** | aktivieren |
|
||
| **Force SSL** | aktivieren |
|
||
| **HTTP/2 Support** | aktivieren |
|
||
|
||
👉 Screenshot geeignet: SSL-Tab mit aktivierter Option „Force SSL“
|
||
|
||
5) Klicke **Save**, um den Proxy-Host anzulegen.
|
||
|
||
Nach wenigen Sekunden ist n8n über die gewählte Subdomain erreichbar, z. B.:
|
||
`https://n8n.deinedomain.tld`
|
||
|
||
👉 Screenshot geeignet: Browser – n8n-Anmeldeseite über die Subdomain aufgerufen
|
||
|
||
[!TIP]
|
||
Falls der Zugriff auch von außen möglich sein soll, muss im Router Port 443 auf den NPM-Host weitergeleitet werden.
|
||
|
||
## Schritt 5 – Vorbereitung: X-App und Credentials anlegen
|
||
|
||
In diesem Schritt richten wir die Verbindung zwischen **n8n** und **X (ehemals Twitter)** ein, damit später automatisch Beiträge gepostet werden können.
|
||
|
||
### 5.1 – X-Entwicklerkonto erstellen und Free-Plan aktivieren
|
||
1) Gehe zu [https://developer.x.com/](https://developer.x.com/) und melde dich mit deinem normalen X-Account an.
|
||
2) Öffne im linken Menü **Products → X API**.
|
||
3) Scrolle zu **API Tiers & Pricing** und wähle **Free**.
|
||
4) Klicke auf **„Sign Up for Free Account“** (der Button ist etwas unscheinbar).
|
||
5) Im Formular die **Use Cases** eintragen – mindestens 250 Zeichen.
|
||
Beispiel (englisch, ausreichend allgemein):
|
||
> We use the API to read and write posts programmatically in order to build community engagement and automate simple posting flows for our streams.
|
||
6) Alle Häkchen für die Bedingungen setzen und die Anmeldung abschließen.
|
||
|
||
👉 Screenshot geeignet: Developer-Portal mit ausgewähltem Free-Plan
|
||
|
||
[!NOTE]
|
||
Mit dem Free-Plan steht genau **eine App** zur Verfügung.
|
||
Dieser Plan erlaubt bis zu **500 Posts (Write) und 100 gelesene Posts (Read) pro Monat** – für Streaming-Ankündigungen reicht das in der Regel völlig aus.
|
||
|
||
### 5.2 – Überblick im Developer-Dashboard
|
||
Nach der Anmeldung erscheint im **Dashboard → Projects & Apps** automatisch ein erstes Projekt mit einer App.
|
||
|
||
👉 Screenshot geeignet: Dashboard mit Projekt-Kachel und Post-Limit-Anzeige
|
||
|
||
### 5.3 – Keys und Tokens vorbereiten
|
||
1) Klicke in der App-Kachel auf das **Zahnrad-Symbol → Keys and Tokens**.
|
||
2) Hier später **API Key & Secret** sowie **Bearer Token** generieren – diese brauchen wir gleich in n8n.
|
||
|
||
👉 Screenshot geeignet: Bereich „Keys and Tokens“ vor dem Generieren der Keys
|
||
|
||
[!WARNING]
|
||
Diese Schlüssel sind vertraulich und dürfen nicht öffentlich geteilt oder im Code abgelegt werden.
|
||
Speichere sie sicher ab.
|
||
|
||
### 5.4 – n8n-Credentials anlegen
|
||
1) Öffne in **n8n** das linke Menü **Credentials → + Neu**.
|
||
2) Wähle **„X OAuth 2.0 API“** als Typ.
|
||
3) Kopiere im geöffneten Fenster die angezeigte **OAuth Redirect URL** – diese wird gleich im Developer-Portal benötigt.
|
||
4) Lasse dieses Credentials-Fenster in n8n geöffnet.
|
||
|
||
👉 Screenshot geeignet: n8n – neues Credentials-Fenster mit sichtbarer Redirect-URL
|
||
|
||
[!TIP]
|
||
Die Redirect-URL immer aus dem geöffneten n8n-Fenster kopieren, nicht manuell eintippen.
|
||
|
||
### 5.5 – User-Authentication in X einrichten
|
||
1) Zurück im **Developer-Portal → Projects & Apps → App Details** wechseln.
|
||
2) Bei **User Authentication Settings** auf **„Set Up“** klicken.
|
||
3) **App Permissions:** „Read and Write“ auswählen.
|
||
4) **Type of App:** „Web App, Automated App or Bot“ auswählen.
|
||
5) Bei **Callback URL** die zuvor aus n8n kopierte Redirect-URL einfügen.
|
||
6) Bei **Homepage URL** die eigene Domain (z. B. `https://deinedomain.tld`) angeben.
|
||
7) **Save** klicken und die folgende Warnung bestätigen.
|
||
|
||
👉 Screenshot geeignet: Formular „User Authentication Settings“ mit ausgewählter Berechtigung „Read and Write“ und Callback-URL
|
||
|
||
[!IMPORTANT]
|
||
Falls die Berechtigung nicht auf „Read and Write“ steht, können später keine Posts veröffentlicht werden.
|
||
|
||
### 5.6 – Client-Daten in n8n eintragen und Account verknüpfen
|
||
1) Nach dem Speichern erscheinen im Developer-Portal **Client ID** und **Client Secret**.
|
||
2) Zurück in das noch geöffnete Credentials-Fenster in n8n wechseln.
|
||
3) **Client ID** und **Client Secret** dort eintragen.
|
||
4) Auf **„Account verknüpfen“** klicken.
|
||
5) Es öffnet sich ein Pop-up-Fenster mit der X-Login-Seite.
|
||
6) Mit dem normalen X-Konto anmelden und die App **autorisieren**.
|
||
|
||
[!WARNING]
|
||
Falls statt „Authorize App“ das X-Dashboard erscheint, das Fenster schließen und den Schritt „Account verknüpfen“ in n8n erneut ausführen.
|
||
|
||
👉 Screenshot geeignet: Pop-up mit X-Login und „Authorize App“
|
||
|
||
Damit sind die **X-Credentials** in n8n eingerichtet und einsatzbereit.
|
||
|
||
### 5.7 – Twitch-Auth-Credentials anlegen
|
||
|
||
Damit n8n die geplanten Streams abrufen kann, brauchen wir eine eigene **Twitch-Anwendung** mit User-Token (Authorization-Code-Flow).
|
||
Die benötigte **OAuth-Redirect-URL** kommt direkt aus n8n, deshalb beginnen wir dort.
|
||
|
||
#### 5.7.1 – Redirect-URL aus n8n kopieren
|
||
1) n8n öffnen → links **Credentials → + Neu**.
|
||
2) **„Twitch OAuth2 API“** als Typ auswählen.
|
||
3) Im sich öffnenden Fenster die angezeigte **OAuth Redirect URL** vollständig kopieren.
|
||
4) Fenster offenlassen, da wir gleich hierher zurückkehren.
|
||
|
||
👉 Screenshot geeignet: n8n – neues Twitch-Credential mit sichtbarer Redirect-URL
|
||
|
||
[!TIP]
|
||
Die Redirect-URL immer direkt aus n8n kopieren, nicht manuell eintippen – sonst schlägt die Authentifizierung fehl.
|
||
|
||
#### 5.7.2 – Neue Anwendung in der Twitch-Developer-Console anlegen
|
||
1) Twitch-Developer-Console öffnen: [https://dev.twitch.tv/console/apps](https://dev.twitch.tv/console/apps).
|
||
2) Mit dem Twitch-Konto anmelden, das später für die Streams genutzt wird.
|
||
3) Auf **„Register Your Application“** klicken
|
||
*(in der deutschen Oberfläche: **„Deine Anwendung registrieren“**).*
|
||
4) Einen aussagekräftigen Namen vergeben, z. B. `n8n-stream-schedule`.
|
||
5) Unter **OAuth Redirect URLs** die zuvor aus n8n kopierte URL einfügen.
|
||
6) Unter **Category** „Application Integration“ auswählen.
|
||
7) Bei **Public / Öffentlich** die Option **„Öffentlich“** aktivieren.
|
||
8) Auf **Create** klicken.
|
||
|
||
👉 Screenshot geeignet: Twitch-Developer-Console – Formular „Register Your Application / Deine Anwendung registrieren“ mit eingetragener Redirect-URL und aktivierter Option „Öffentlich“
|
||
|
||
[!IMPORTANT]
|
||
Die Redirect-URL muss exakt der aus n8n entsprechen, sonst schlägt die spätere Verknüpfung fehl.
|
||
|
||
#### 5.7.3 – Client-ID und Secret sichern
|
||
1) Nach dem Erstellen erscheint die Anwendung in der Übersicht.
|
||
2) Auf **Manage** klicken.
|
||
3) Die **Client ID** kopieren.
|
||
4) Über **New Secret** einen neuen **Client Secret** erzeugen und kopieren.
|
||
5) Beide Werte sicher speichern.
|
||
|
||
👉 Screenshot geeignet: Twitch-Developer-Console – App-Details mit sichtbarer Client ID und Button „New Secret“
|
||
|
||
[!WARNING]
|
||
Der Client Secret ist nur einmal sichtbar. Nicht öffentlich teilen und sicher aufbewahren.
|
||
|
||
#### 5.7.4 – Credential in n8n fertigstellen
|
||
1) Zurück zu n8n in das noch geöffnete Credential-Fenster wechseln.
|
||
2) Folgende Felder ausfüllen:
|
||
* **Client ID:** Wert aus der Twitch-Anwendung einfügen
|
||
* **Client Secret:** Wert aus der Twitch-Anwendung einfügen
|
||
* **Auth URL:** `https://id.twitch.tv/oauth2/authorize`
|
||
* **Access Token URL:** `https://id.twitch.tv/oauth2/token`
|
||
* **Grant Type:** `Authorization Code`
|
||
* **Scope:** `user:read:broadcast`
|
||
* **Auth URI Query Parameters:** leer lassen
|
||
* **Authentication:** `Body`
|
||
3) Auf **„Account verknüpfen“** klicken.
|
||
4) Im neuen Fenster mit dem Twitch-Konto anmelden und die Anwendung **autorisieren**.
|
||
5) Falls statt „Authorize App“ das Twitch-Dashboard erscheint, Fenster schließen und den Vorgang **„Account verknüpfen“** erneut ausführen.
|
||
|
||
👉 Screenshot geeignet: Twitch – OAuth-Freigabeseite mit „Authorize App“
|
||
|
||
[!NOTE]
|
||
Der Scope `user:read:broadcast` erlaubt n8n, die geplanten Streams des angegebenen Kanals über die Helix-API abzurufen.
|
||
|
||
### 5.8 – Hinweis zu Access Tokens
|
||
|
||
Mit den bisher eingerichteten **Credentials** für X und Twitch sind zwar die Schnittstellen verbunden, aber das reicht für den geplanten Workflow noch nicht aus.
|
||
Viele API-Endpunkte – insbesondere bei Twitch – benötigen zusätzlich einen **Access Token** (Bearer-Token) für jeden Abruf.
|
||
|
||
Zwar kann dieser Token theoretisch auch manuell über die Developer-Seiten erzeugt und in n8n eingetragen werden, doch solche Tokens laufen nach kurzer Zeit ab (bei Twitch z. B. meist nach 60 Tagen oder früher).
|
||
Ein händisches Nachtragen würde bedeuten, dass der Workflow regelmäßig ausfällt und manuell nachgepflegt werden muss.
|
||
|
||
[!IMPORTANT]
|
||
Wir werden deshalb im **Verlauf des Workflows** einen eigenen Node hinzufügen, der den Access Token automatisch anfordert und bei Bedarf erneuert.
|
||
So bleibt der Workflow stabil und benötigt keine manuelle Pflege.
|
||
|
||
### 5.9 – Nextcloud-Credentials anlegen
|
||
|
||
**Zweck:**
|
||
Damit n8n automatisch auf Dateien in deiner Nextcloud zugreifen kann (z. B. für vorbereitete Posts oder temporäre Daten), benötigen wir ein eigenes App-Passwort und ein passendes Credential in n8n.
|
||
|
||
#### In Nextcloud: App-Passwort erstellen
|
||
|
||
1) Melde dich in deiner **Nextcloud** an.
|
||
2) Öffne oben rechts das **Benutzermenü → Einstellungen**.
|
||
3) Wähle im linken Menü den Punkt **Sicherheit** (engl. „Security“).
|
||
4) Scrolle nach unten bis zum Bereich **App-Passwörter**.
|
||
5) Vergib unter „Neues App-Passwort“ einen Namen, z. B. `n8n`.
|
||
6) Klicke auf **App-Passwort erstellen**.
|
||
7) Kopiere den angezeigten Schlüssel sofort – er wird nur einmal angezeigt.
|
||
👉 Screenshot geeignet: Nextcloud – Bereich *Sicherheit / App-Passwörter*
|
||
|
||
[!IMPORTANT]
|
||
Nur dieses **App-Passwort** wird in n8n verwendet, **nicht** dein normales Login-Passwort.
|
||
Das App-Passwort kann bei Bedarf jederzeit widerrufen oder neu erstellt werden.
|
||
|
||
#### In n8n: Credential hinzufügen
|
||
|
||
1) Öffne in n8n oben links **+ → Credentials → Nextcloud**.
|
||
2) Trage folgende Werte ein:
|
||
|
||
| Feld | Wert / Beschreibung |
|
||
|------|---------------------|
|
||
| **Name** | `Nextcloud` |
|
||
| **Base URL** | `https://deine-domain.tld` *(ohne `/remote.php/...`)* |
|
||
| **Username** | dein Nextcloud-Benutzername |
|
||
| **Password** | das zuvor erstellte App-Passwort |
|
||
|
||
3) Klicke auf **Save**.
|
||
👉 Screenshot geeignet: n8n – Nextcloud-Credential mit Base URL und App-Passwort
|
||
|
||
[!NOTE]
|
||
Das Credential „Nextcloud“ wird später in Schritt **6.13** verwendet, um Dateien wie `posts.txt` automatisiert aus der Cloud zu laden und lokal zu verarbeiten.
|
||
|
||
## Schritt 6 – Workflow in n8n aufbauen
|
||
|
||
In diesem Schritt erstellen wir den eigentlichen Workflow in **n8n**.
|
||
Wir fügen die benötigten Nodes hinzu und konfigurieren sie so, dass der Workflow regelmäßig die geplanten Twitch-Streams prüft und bei Bedarf automatisch Ankündigungen auf X erstellt.
|
||
|
||
### 6.1 – Cron Trigger (Workflow alle 30 Minuten starten)
|
||
|
||
**Zweck:**
|
||
Der Cron-Trigger ist der Startpunkt des Workflows.
|
||
Er sorgt dafür, dass alle 30 Minuten geprüft wird, ob ein geplanter Stream in Kürze startet.
|
||
|
||
**Node-Typ:** `Schedule Trigger`
|
||
**Name:** `Cron – Workflow alle 30 Minuten starten`
|
||
|
||
**Einstellungen im Node:**
|
||
- **Trigger Interval:** `Minutes`
|
||
- **Minutes Between Triggers:** `30`
|
||
|
||
👉 Screenshot geeignet: n8n – Schedule Trigger mit „Trigger Interval: Minutes“ und Wert „30“
|
||
|
||
[!NOTE]
|
||
Die Zeitzone wird nicht im Node eingestellt.
|
||
Sie richtet sich nach der **Workflow-Zeitzone** (oben rechts im Workflow → *Settings → Time Zone*).
|
||
Ist dort nichts gesetzt, gilt die Zeitzone des Servers, auf dem n8n läuft.
|
||
|
||
[!TIP]
|
||
Die Intervalldauer (hier 30 Minuten) kann bei Bedarf angepasst werden. Für Ankündigungen kurz vor dem Stream reicht ein Intervall von 30 Minuten in der Regel aus.
|
||
|
||
### 6.2 – Code Node: Access Token prüfen
|
||
|
||
**Zweck:**
|
||
Dieser Node prüft bei jedem Durchlauf, ob bereits ein gültiger Twitch-Access-Token vorhanden ist und wie lange er noch gültig ist.
|
||
Wenn kein Token existiert oder die Restlaufzeit unter 24 Stunden liegt, markieren wir das für die nächste Stufe (Token erneuern).
|
||
|
||
**Node-Typ:** `Code`
|
||
**Programmiersprache:** `JavaScript`
|
||
**Name:** `Code – Access Token prüfen`
|
||
|
||
**Einstellungen:**
|
||
- **Language:** `JavaScript`
|
||
- Den folgenden Code einfügen:
|
||
|
||
```javascript
|
||
// Liest gespeicherten Token aus den globalen Workflow-Daten
|
||
const sd = $getWorkflowStaticData('global');
|
||
const token = sd.twitch_token || '';
|
||
const expISO = sd.twitch_expires_at || '';
|
||
const expMs = expISO ? new Date(expISO).getTime() : 0;
|
||
|
||
const now = Date.now();
|
||
const msLeft = expMs ? (expMs - now) : 0;
|
||
const hoursLeft = msLeft > 0 ? (msLeft / (1000*60*60)) : 0;
|
||
|
||
// true, wenn kein Token vorhanden ist oder wenn er in <24h abläuft
|
||
const needsRefresh = !token || !expMs || hoursLeft < 24;
|
||
|
||
return [{
|
||
json: {
|
||
needsRefresh,
|
||
token,
|
||
expires_at: expISO,
|
||
hoursLeft: Number(hoursLeft.toFixed(2))
|
||
}
|
||
}];
|
||
```
|
||
|
||
👉 Screenshot geeignet: n8n – Code-Node mit eingefügtem JavaScript-Code
|
||
|
||
[!NOTE]
|
||
Dieser Node speichert nichts, sondern liefert nur Statusdaten (`needsRefresh`, `hoursLeft`, `expires_at`).
|
||
Die tatsächliche Erneuerung des Tokens erfolgt später im Workflow.
|
||
|
||
### 6.3 – IF Node: Access Token erneuern?
|
||
|
||
**Zweck:**
|
||
Dieser Node prüft, ob aus dem vorherigen Code-Node das Flag `needsRefresh` auf **true** steht.
|
||
Nur in diesem Fall wird im nächsten Schritt ein neuer Access-Token angefordert.
|
||
|
||
**Node-Typ:** `IF`
|
||
**Name:** `IF – Access Token erneuern?`
|
||
|
||
**Einstellungen:**
|
||
- **Conditions:**
|
||
- `{{$json.needsRefresh}}`
|
||
- `is true` *(Type: Boolean)*
|
||
|
||
👉 Screenshot geeignet: n8n – IF-Node mit Bedingung `{{$json.needsRefresh}}` → `is true (Boolean)`
|
||
|
||
[!IMPORTANT]
|
||
Stelle sicher, dass der Vergleichs-Typ auf **Boolean** gesetzt ist, sonst wird der Wert eventuell als Text interpretiert und die Abfrage funktioniert nicht korrekt.
|
||
|
||
[!NOTE]
|
||
- **TRUE-Pfad:** Token wird im nächsten Schritt erneuert.
|
||
- **FALSE-Pfad:** Es wird mit dem bestehenden Token fortgefahren.
|
||
|
||
### 6.4 – HTTP Request: Neuen Twitch-Access-Token anfordern *(TRUE-Pfad)*
|
||
|
||
**Zweck:**
|
||
Fordert über die Twitch-API einen neuen Access-Token an, wenn der IF-Node festgestellt hat, dass keiner vorhanden ist oder der aktuelle bald abläuft.
|
||
|
||
**Node-Typ:** `HTTP Request`
|
||
**Name:** `HTTP – Access Token anfordern`
|
||
|
||
**Einstellungen:**
|
||
- **Method:** `POST`
|
||
- **URL:** `https://id.twitch.tv/oauth2/token`
|
||
- **Send Body:** aktivieren
|
||
- **Content Type:** `Form-URL-Encoded`
|
||
- **Body Parameters:**
|
||
- `client_id` → Wert aus den in n8n hinterlegten Twitch-Credentials
|
||
- `client_secret` → Wert aus den Twitch-Credentials
|
||
- `grant_type` → `client_credentials`
|
||
|
||
👉 Screenshot geeignet: n8n – HTTP-Request-Node mit konfigurierten Body-Parametern
|
||
|
||
[!NOTE]
|
||
Der Node gibt als Antwort ein JSON-Objekt mit `access_token` und `expires_in` zurück.
|
||
Diese Werte werden im nächsten Node gespeichert.
|
||
|
||
### 6.5 – Code Node: Neuen Access-Token speichern *(TRUE-Pfad)*
|
||
|
||
**Zweck:**
|
||
Speichert den vom HTTP-Request erhaltenen Twitch-Access-Token und dessen Ablaufzeitpunkt in den globalen Workflow-Daten.
|
||
So bleibt der Token auch für spätere Workflow-Durchläufe verfügbar.
|
||
|
||
**Node-Typ:** `Code`
|
||
**Programmiersprache:** `JavaScript`
|
||
**Name:** `Code – Access Token speichern`
|
||
|
||
**Einstellungen:**
|
||
- **Language:** `JavaScript`
|
||
- Den folgenden Code einfügen:
|
||
|
||
```javascript
|
||
// Speichert neuen Token + Ablaufzeit in Workflow-Static-Data
|
||
const sd = $getWorkflowStaticData('global');
|
||
|
||
const access = $json.access_token;
|
||
const ttlSec = Number($json.expires_in || 0);
|
||
|
||
// Ablaufzeitpunkt berechnen und speichern
|
||
const expISO = new Date(Date.now() + ttlSec * 1000).toISOString();
|
||
|
||
sd.twitch_token = access;
|
||
sd.twitch_expires_at = expISO;
|
||
|
||
// Optional: verbleibende Stunden ausgeben
|
||
const msLeft = (new Date(expISO).getTime() - Date.now());
|
||
const hoursLeft = msLeft / (1000 * 60 * 60);
|
||
|
||
return [{
|
||
json: {
|
||
token: access,
|
||
expires_at: expISO,
|
||
hoursLeft: Number(hoursLeft.toFixed(2))
|
||
}
|
||
}];
|
||
```
|
||
|
||
👉 Screenshot geeignet: n8n – Code-Node mit eingefügtem JavaScript-Code
|
||
|
||
[!NOTE]
|
||
Dieser Node speichert den neuen Token und gibt ihn zusätzlich mit seiner Restlaufzeit (`hoursLeft`) aus, sodass nachfolgende Nodes die Werte sofort verwenden können.
|
||
|
||
### 6.6 – Set Node: Token aus Cache bereitstellen *(FALSE-Pfad)*
|
||
|
||
**Zweck:**
|
||
Wenn der IF-Node feststellt, dass der vorhandene Token noch gültig ist, brauchen wir keinen neuen anzufordern.
|
||
Dieser Node liest die bereits gespeicherten Token-Daten aus den globalen Workflow-Daten und stellt sie den nachfolgenden Nodes zur Verfügung.
|
||
|
||
**Node-Typ:** `Set`
|
||
**Name:** `Set – Token aus Cache bereitstellen`
|
||
|
||
**Einstellungen:**
|
||
- **Mode:** `Add Field`
|
||
- **Felder hinzufügen:**
|
||
- `token` → `{{$json.token}}`
|
||
- `expires_at` → `{{$json.expires_at}}`
|
||
- `hoursLeft` → `{{$json.hoursLeft}}`
|
||
|
||
👉 Screenshot geeignet: n8n – Set-Node mit eingetragenen drei Feldern (token, expires_at, hoursLeft)
|
||
|
||
[!NOTE]
|
||
Der Set-Node wird nur im **FALSE-Pfad** des IF-Nodes ausgeführt.
|
||
Er sorgt dafür, dass auch ohne Erneuerung dieselben Felder (`token`, `expires_at`, `hoursLeft`) für die nächsten Schritte bereitstehen.
|
||
|
||
### 6.7 – Merge Node: Token-Ströme zusammenführen
|
||
|
||
**Zweck:**
|
||
Führt die beiden möglichen Pfade aus dem IF-Node wieder zusammen:
|
||
- TRUE-Pfad: liefert den **neu angeforderten Token** aus dem Code-Node „Access Token speichern“.
|
||
- FALSE-Pfad: liefert den **bereits vorhandenen Token** aus dem Set-Node „Token aus Cache bereitstellen“.
|
||
|
||
So steht dem Workflow anschließend unabhängig vom Pfad derselbe Datensatz für die weiteren Schritte zur Verfügung.
|
||
|
||
**Node-Typ:** `Merge`
|
||
**Name:** `Merge – Token zusammenführen`
|
||
|
||
**Einstellungen:**
|
||
- **Mode:** `Append`
|
||
- **Number of Inputs:** `2`
|
||
|
||
👉 Screenshot geeignet: n8n – Merge-Node mit „Mode: Append“ und „Number of Inputs: 2“
|
||
|
||
[!NOTE]
|
||
Da jeweils nur einer der beiden Pfade aktiv ist, genügt der Append-Modus, um den ausgegebenen Datensatz an den Hauptfluss zurückzugeben.
|
||
|
||
### 6.8 – HTTP Request: Twitch-Termine laden
|
||
|
||
**Zweck:**
|
||
Dieser Node ruft über die Twitch-Helix-API den aktuellen Stream-Zeitplan des Kanals ab, um zu prüfen, ob innerhalb der nächsten 30 Minuten ein Stream startet.
|
||
|
||
**Node-Typ:** `HTTP Request`
|
||
**Name:** `HTTP – Twitch-Termine laden`
|
||
|
||
#### Twitch-User-ID ermitteln (ohne Programmierung)
|
||
Die `broadcaster_id` ist eine **numerische ID**, die jedem Twitch-Kanal zugeordnet ist.
|
||
Du brauchst diese Zahl (nicht den Kanalnamen), um die API-Abfrage auszuführen.
|
||
|
||
**So findest du sie leicht:**
|
||
|
||
1) Öffne im Browser die Seite
|
||
[https://streamscharts.com/tools/convert-username](https://streamscharts.com/tools/convert-username)
|
||
2) Gib deinen Twitch-Kanalnamen ein (z. B. `bratonien_tv`).
|
||
3) Klicke auf **Convert**.
|
||
4) Die angezeigte Zahl unter „Channel ID“ ist deine `broadcaster_id`.
|
||
5) Kopiere diese Zahl und trage sie später im HTTP-Request-Node in das Feld **broadcaster_id** ein.
|
||
|
||
👉 Screenshot geeignet: StreamsCharts-Tool mit eingegebenem Kanalnamen und angezeigter Channel-ID
|
||
|
||
[!TIP]
|
||
Dieses Tool verwendet offiziell die Twitch-API, du brauchst dort keine eigenen Entwickler-Anmeldungen.
|
||
|
||
#### Einstellungen im Node
|
||
- **Method:** `GET`
|
||
- **URL:** `https://api.twitch.tv/helix/schedule`
|
||
- **Send Query:** aktivieren
|
||
- **Query Parameters:**
|
||
- `broadcaster_id` → `<Twitch-User-ID>` des Kanals
|
||
- `start_time` → `{{$now.toUTC().startOf('day').toISO()}}`
|
||
- **Send Headers:** aktivieren
|
||
- **Header Parameters:**
|
||
- `Authorization` → `Bearer {{$json.token}}`
|
||
- `Client-ID` → `<deine Client-ID aus Twitch-Credentials>`
|
||
|
||
👉 Screenshot geeignet: n8n – HTTP-Request-Node mit eingetragenen Query- und Header-Parametern
|
||
|
||
[!NOTE]
|
||
Die `broadcaster_id` ist die eindeutige numerische ID des Kanals.
|
||
Der Header **Authorization** enthält den Access-Token aus dem Merge-Node.
|
||
Der Header **Client-ID** ist zwingend erforderlich, sonst verweigert die Helix-API den Zugriff.
|
||
|
||
### 6.8 – HTTP Request: Twitch-Termine laden
|
||
|
||
**Zweck:**
|
||
Dieser Node ruft über die Twitch-Helix-API den aktuellen Stream-Zeitplan des Kanals ab, um zu prüfen, ob innerhalb der nächsten 30 Minuten ein Stream startet.
|
||
|
||
**Node-Typ:** `HTTP Request`
|
||
**Name:** `HTTP – Twitch-Termine laden`
|
||
|
||
#### Twitch-User-ID ermitteln (ohne Programmierung)
|
||
Die `broadcaster_id` ist eine **numerische ID**, die jedem Twitch-Kanal zugeordnet ist.
|
||
Du brauchst diese Zahl (nicht den Kanalnamen), um die API-Abfrage auszuführen.
|
||
|
||
**So findest du sie leicht:**
|
||
|
||
1) Öffne im Browser die Seite
|
||
[https://streamscharts.com/tools/convert-username](https://streamscharts.com/tools/convert-username)
|
||
2) Gib deinen Twitch-Kanalnamen ein (z. B. `bratonien_tv`).
|
||
3) Klicke auf **Convert**.
|
||
4) Die angezeigte Zahl unter „Channel ID“ ist deine `broadcaster_id`.
|
||
5) Kopiere diese Zahl und trage sie später im HTTP-Request-Node in das Feld **broadcaster_id** ein.
|
||
|
||
👉 Screenshot geeignet: StreamsCharts-Tool mit eingegebenem Kanalnamen und angezeigter Channel-ID
|
||
|
||
[!TIP]
|
||
Dieses Tool verwendet offiziell die Twitch-API und erfordert keine eigenen Entwickler-Anmeldungen.
|
||
|
||
#### Einstellungen im Node
|
||
- **Method:** `GET`
|
||
- **URL:** `https://api.twitch.tv/helix/schedule`
|
||
- **Authentication:** `Generic Credential Type`
|
||
- **Generic Auth Type:** `OAuth2 API` → wähle hier die zuvor in n8n angelegten **Twitch-Credentials** aus
|
||
- **Send Query Parameters:** aktivieren
|
||
- **Query Parameters:**
|
||
- **Name:** `broadcaster_id` → `<deine Twitch-User-ID>`
|
||
- **Name:** `start_time` → `{{ $now.toUTC().startOf('day').toISO() }}`
|
||
- **Send Headers:** aktivieren
|
||
- **Header Parameters:**
|
||
- **Name:** `Client-ID` → `<deine Client-ID aus den Twitch-Credentials>`
|
||
|
||
👉 Screenshot geeignet: n8n – HTTP-Request-Node mit allen sichtbaren Parametern wie auf den beiden Referenz-Screenshots
|
||
|
||
[!NOTE]
|
||
Der Access-Token wird über die ausgewählte OAuth2-Credential automatisch mitgesendet.
|
||
Zusätzlich ist nur der **Client-ID**-Header notwendig.
|
||
Die Option **Never Error** bleibt deaktiviert, da sie hier nicht benötigt wird.
|
||
|
||
### 6.9 – Code-Node: „Parse ICS“
|
||
|
||
**Zweck:**
|
||
Dieser Node verarbeitet die Antwort des Nodes **„Twitch-Termine laden“**.
|
||
Er liest das JSON aus der Helix-API und erzeugt für jedes Stream-Segment ein einheitliches Objekt mit Start- und Endzeit, Titel, Beschreibung und einer Hash-ID.
|
||
So können wir die Termine später leichter filtern und weiterverarbeiten.
|
||
|
||
**Node-Typ:** `Code`
|
||
**Name:** `Parse ICS`
|
||
|
||
👉 Screenshot geeignet: n8n – geöffneter Code-Node mit eingefügtem Skript
|
||
|
||
#### Node-Einstellungen
|
||
- **Programming Language:** `JavaScript`
|
||
- Weitere Einstellungen bleiben auf Standard.
|
||
|
||
#### Eingabe
|
||
Der Node erwartet die Antwort des HTTP-Requests **„Twitch-Termine laden“**.
|
||
Der Inhalt liegt meist als Text-String in `items[0].json.body` vor.
|
||
|
||
#### Code-Inhalt
|
||
Kopiere den folgenden Code komplett in das Editorfeld des Code-Nodes:
|
||
|
||
```
|
||
/**
|
||
* INPUT: items[0].json ODER items[0].json.body (String) vom HTTP Request /helix/schedule
|
||
* OUTPUT: pro Segment ein Item in folgendem Schema:
|
||
* { uid, cancelled, title, description, startIso, endIso, tz, hash }
|
||
*/
|
||
|
||
const input = items[0]?.json ?? {};
|
||
let payload;
|
||
|
||
if (typeof input.body === 'string') {
|
||
// HTTP-Node hat "Response Format: Text" -> JSON-String in body
|
||
try { payload = JSON.parse(input.body); }
|
||
catch (e) { throw new Error('HTTP body ist kein gültiges JSON'); }
|
||
} else if (input.data) {
|
||
// HTTP-Node hat "Response Format: JSON"
|
||
payload = input;
|
||
} else if (typeof input === 'string') {
|
||
payload = JSON.parse(input);
|
||
} else {
|
||
throw new Error('Unerwartete Eingabeform. Erwartet JSON oder body-String.');
|
||
}
|
||
|
||
const segments = Array.isArray(payload.data?.segments) ? payload.data.segments : [];
|
||
|
||
// Hash für eindeutige Segmentkennung
|
||
function hashHex(s) {
|
||
let h = 5381;
|
||
for (let i = 0; i < s.length; i++) h = ((h << 5) + h) ^ s.charCodeAt(i);
|
||
return (h >>> 0).toString(16).padStart(8, '0');
|
||
}
|
||
|
||
function buildTitle() { return 'Streamtime'; }
|
||
|
||
function buildDesc(seg) {
|
||
const lines = [];
|
||
if (seg.title) lines.push(`Originaltitel: ${seg.title}`);
|
||
if (seg.category?.name) lines.push(`Kategorie/Game: ${seg.category.name}`);
|
||
return lines.join('\n');
|
||
}
|
||
|
||
const tz = 'Europe/Berlin';
|
||
|
||
const out = segments.map(seg => {
|
||
const startIso = seg.start_time; // ISO-UTC laut Twitch
|
||
const endIso = seg.end_time;
|
||
const title = buildTitle();
|
||
const description = buildDesc(seg);
|
||
const hash = hashHex(`${title}|${startIso}|${endIso}|${description}`);
|
||
|
||
return {
|
||
json: {
|
||
uid: seg.id,
|
||
cancelled: Boolean(seg.canceled_until),
|
||
title, description,
|
||
startIso, endIso, tz,
|
||
hash
|
||
}
|
||
};
|
||
});
|
||
|
||
return out;
|
||
```
|
||
|
||
[!NOTE]
|
||
- `tz` ist fest auf `Europe/Berlin` gesetzt, kann aber bei Bedarf angepasst werden.
|
||
- Das Feld `cancelled` wird genutzt, um abgesagte Streams zu kennzeichnen.
|
||
- Jeder Stream-Eintrag erhält einen Hash, der später als eindeutiger Schlüssel dient.
|
||
|
||
### 6.10 – Code-Node: „Nächstes Event finden“
|
||
|
||
**Zweck:**
|
||
Dieser Node wählt aus allen vom **„Parse ICS“**-Node gelieferten Terminen den **nächsten bevorstehenden Stream** aus.
|
||
Er liefert das Start-Datum und die relevanten Infos des nächsten Events als einzelnes Item.
|
||
|
||
**Node-Typ:** `Code`
|
||
**Name:** `Nächstes Event finden`
|
||
|
||
👉 Screenshot geeignet: n8n – geöffneter Code-Node mit dem folgenden Script
|
||
|
||
#### Node-Einstellungen
|
||
- **Programming Language:** `JavaScript`
|
||
- Alle weiteren Optionen bleiben auf Standard.
|
||
|
||
#### Eingabe
|
||
Dieser Node erwartet als Input die komplette Liste der Stream-Segmente aus dem Node **„Parse ICS“**.
|
||
|
||
#### Code-Inhalt
|
||
Kopiere den folgenden Code vollständig in das Code-Feld:
|
||
|
||
```
|
||
/**
|
||
* INPUT: Array von Items aus "Parse ICS"
|
||
* OUTPUT: nur das nächste bevorstehende Event
|
||
*/
|
||
|
||
const now = Date.now();
|
||
|
||
const upcoming = items
|
||
.map(i => i.json)
|
||
.filter(e => !e.cancelled && new Date(e.startIso).getTime() > now)
|
||
.sort((a, b) => new Date(a.startIso) - new Date(b.startIso));
|
||
|
||
if (upcoming.length === 0) {
|
||
return [{ json: { message: 'Kein bevorstehender Stream gefunden' } }];
|
||
}
|
||
|
||
const next = upcoming[0];
|
||
|
||
return [{
|
||
json: {
|
||
uid: next.uid,
|
||
title: next.title,
|
||
kategroie: next.kategorie,
|
||
description: next.description,
|
||
startIso: next.startIso,
|
||
endIso: next.endIso,
|
||
tz: next.tz,
|
||
hash: next.hash
|
||
}
|
||
}];
|
||
```
|
||
|
||
[!TIP]
|
||
Dieser Node gibt **genau ein Item** mit dem nächsten Stream zurück.
|
||
Fehlt ein Termin, wird eine kurze Meldung im Feld `message` ausgegeben.
|
||
|
||
### 6.11 – Code-Node: „Stream prüfen“
|
||
|
||
**Zweck:**
|
||
Dieser Node überprüft, ob der nächste geplante Stream in den kommenden **30 Minuten** beginnt und ob für diesen Stream bereits ein Post veröffentlicht wurde.
|
||
Nur wenn beide Bedingungen erfüllt sind, wird der Workflow fortgesetzt.
|
||
|
||
**Node-Typ:** `Code`
|
||
**Name:** `Stream prüfen`
|
||
|
||
👉 Screenshot geeignet: n8n – geöffneter Code-Node mit folgendem Script
|
||
|
||
#### Node-Einstellungen
|
||
- **Programmiersprache:** `JavaScript`
|
||
- Keine weiteren Optionen ändern
|
||
|
||
#### Eingabe
|
||
Der Node erhält den Output aus **„Nächstes Event finden“** – also einen einzelnen Stream-Eintrag mit `uid`, `title`, `startIso` und weiteren Feldern.
|
||
|
||
#### Code-Inhalt
|
||
Kopiere den folgenden Code:
|
||
|
||
```
|
||
/**
|
||
* Prüft:
|
||
* 1. Startet der Stream in ≤ 30 Minuten?
|
||
* 2. Wurde bereits ein Post erstellt?
|
||
*
|
||
* Zeitumwandlung: Twitch liefert UTC ("2025-10-15T16:00:00Z").
|
||
* Wir rechnen in lokale Zeit (Europe/Berlin), um MEZ/MESZ korrekt zu berücksichtigen.
|
||
*/
|
||
|
||
const event = items[0]?.json ?? {};
|
||
if (!event.startIso) {
|
||
return [{
|
||
json: {
|
||
postAllowed: false,
|
||
reason: 'Kein Termin gefunden'
|
||
}
|
||
}];
|
||
}
|
||
|
||
// Aktuelle Zeit + Startzeit in lokale Zeitzone überführen
|
||
const tz = 'Europe/Berlin';
|
||
const now = new Date(); // lokale Zeit des n8n-Servers
|
||
const startUtc = new Date(event.startIso);
|
||
|
||
// Startzeit in lokales Format (inkl. Sommer-/Winterzeit)
|
||
const startLocal = new Date(startUtc.toLocaleString('en-US', { timeZone: tz }));
|
||
|
||
// Differenz in Minuten
|
||
const diffMin = (startLocal - now) / 60000;
|
||
const within30 = diffMin > 0 && diffMin <= 30;
|
||
|
||
// Zugriff auf global gespeicherte IDs
|
||
const sd = $getWorkflowStaticData('global');
|
||
sd.postedIds = sd.postedIds || [];
|
||
|
||
const alreadyPosted = sd.postedIds.includes(event.uid);
|
||
|
||
// Wenn innerhalb von 30 Minuten und noch kein Post → erlauben
|
||
if (within30 && !alreadyPosted) {
|
||
sd.postedIds.push(event.uid);
|
||
return [{
|
||
json: {
|
||
...event,
|
||
postAllowed: true,
|
||
reason: 'Stream startet bald, noch kein Post vorhanden',
|
||
localStart: startLocal.toISOString(),
|
||
diffMinutes: Math.round(diffMin)
|
||
}
|
||
}];
|
||
}
|
||
|
||
// Keine Aktion notwendig
|
||
return [{
|
||
json: {
|
||
...event,
|
||
postAllowed: false,
|
||
reason: alreadyPosted
|
||
? 'Für diesen Stream wurde bereits gepostet'
|
||
: 'Stream liegt außerhalb des 30-Minuten-Fensters',
|
||
localStart: startLocal.toISOString(),
|
||
diffMinutes: Math.round(diffMin)
|
||
}
|
||
}];
|
||
```
|
||
|
||
[!NOTE]
|
||
Dieser Node speichert die **UID jedes angekündigten Streams** im Workflow-Speicher (`global static data`).
|
||
So wird sichergestellt, dass kein Termin doppelt angekündigt wird – auch nicht nach einem Neustart des Systems.
|
||
Der Zeitvergleich erfolgt in **MEZ/MESZ (Europe/Berlin)**, damit lokale Streamzeiten korrekt erkannt werden.
|
||
|
||
### 6.12 – IF-Node: „Post ausführen?“
|
||
|
||
**Zweck:**
|
||
Der IF-Node entscheidet, ob tatsächlich ein Social-Post (z. B. auf X) ausgelöst werden soll.
|
||
Er prüft das Feld `postAllowed`, das aus dem vorherigen Code-Node stammt.
|
||
|
||
**Node-Typ:** `IF`
|
||
**Name:** `Post ausführen?`
|
||
|
||
👉 Screenshot geeignet: n8n – geöffneter IF-Node mit konfigurierter Bedingung
|
||
|
||
#### Node-Einstellungen
|
||
|
||
**Conditions**
|
||
|
||
| Feld | Einstellung |
|
||
|------|--------------|
|
||
| **Left Value** | `{{$json.postAllowed}}` |
|
||
| **Operator** | `is true` |
|
||
| **Type** | `Boolean` |
|
||
|
||
[!NOTE]
|
||
- Der *True*-Pfad wird nur ausgeführt, wenn der Stream innerhalb der nächsten 30 Minuten startet **und** noch kein Post gesendet wurde.
|
||
- Der *False*-Pfad kann später genutzt werden, um Debug-Logs oder Benachrichtigungen zu schreiben (z. B. „Kein Post nötig“).
|
||
|
||
👉 Screenshot geeignet: n8n – IF-Node mit `{{$json.postAllowed}} is true (Boolean)`
|
||
|
||
### 6.13 – Nextcloud-Node: Datei herunterladen
|
||
|
||
**Zweck:**
|
||
Dieser Node lädt die Datei `posts.txt` aus deiner Nextcloud in n8n, damit sie anschließend lokal verarbeitet werden kann.
|
||
|
||
**Node-Typ:** `Nextcloud`
|
||
**Name:** `posts.txt herunterladen`
|
||
|
||
👉 Screenshot geeignet: n8n – Nextcloud-Node mit ausgefüllten Feldern
|
||
|
||
#### Einstellungen
|
||
|
||
| Feld | Eingabe |
|
||
|------|----------|
|
||
| **Credential to connect with** | `Nextcloud` *(aus Schritt 5.9)* |
|
||
| **Resource** | `File` |
|
||
| **Operation** | `Download` |
|
||
| **File Path** | `/n8n/posts.txt` *(Pfad in deiner Nextcloud anpassen)* |
|
||
| **Put Output File in Field** | `data` |
|
||
|
||
[!NOTE]
|
||
Die Datei `posts.txt` sollte in deiner Nextcloud vorhanden sein und **eine Textzeile pro Post** enthalten, z. B.:
|
||
|
||
```
|
||
Gleich geht’s los – der Stream startet in Kürze!
|
||
Heute wieder live – seid dabei!
|
||
Stream incoming! Noch ein paar Minuten bis Start.
|
||
```
|
||
|
||
👉 Screenshot geeignet: Beispielansicht der Datei `posts.txt` in Nextcloud
|
||
|
||
Nach der Ausführung enthält der Node die Datei als **binäre Ausgabe** im Feld `data`.
|
||
Diese wird im nächsten Schritt lokal gespeichert, damit sie gelesen werden kann.
|
||
|
||
### 6.14 – Code-Node: Zufälligen Post auswählen
|
||
|
||
**Zweck:**
|
||
Dieser Node liest die Datei `posts.txt` (aus dem Binary-Feld des Nextcloud-Nodes) und wählt zufällig eine Zeile als Posting-Text.
|
||
Wenn die Datei fehlt oder leer ist, nutzt der Workflow eine kleine Standardliste mit vorbereiteten Posts als Fallback.
|
||
|
||
**Node-Typ:** `Code`
|
||
**Name:** `Posttext auswählen`
|
||
|
||
👉 Screenshot geeignet: n8n – geöffneter Code-Node mit Script
|
||
|
||
#### Code-Inhalt
|
||
|
||
```
|
||
/**
|
||
* Liest posts.txt direkt aus dem Binary-Feld "data" (vom Nextcloud-Node)
|
||
* und wählt zufällig eine Zeile aus.
|
||
* Wenn keine Datei oder kein Inhalt vorhanden ist, wird ein Fallback-Text aus einer Liste genutzt.
|
||
* Zusätzlich wird der Startzeitpunkt des Streams in lokaler Zeit (MEZ/MESZ) angehängt.
|
||
*/
|
||
|
||
let content = '';
|
||
try {
|
||
const buffer = items[0].binary?.data?.data;
|
||
if (buffer) {
|
||
content = Buffer.from(buffer, 'base64').toString('utf8');
|
||
}
|
||
} catch (err) {
|
||
content = '';
|
||
}
|
||
|
||
// Inhalt in Zeilen aufteilen
|
||
const lines = content.split('\n').map(l => l.trim()).filter(Boolean);
|
||
|
||
// Fallback-Texte
|
||
const fallbackPosts = [
|
||
'Der Stream startet gleich – holt euch Snacks und seid dabei! 🎮',
|
||
'Bald geht’s los – heute wird wieder gezockt! 🔥',
|
||
'Noch kurz durchatmen – gleich geht’s live auf Sendung! 🚀',
|
||
'In wenigen Minuten live – Kaffee bereit? ☕',
|
||
'Los geht’s – der Chat wartet schon auf euch! 💬',
|
||
'Heute gibt’s wieder gute Laune und Gaming pur! 💜'
|
||
];
|
||
|
||
// Textauswahl
|
||
let postText;
|
||
if (lines.length > 0) {
|
||
const randomIndex = Math.floor(Math.random() * lines.length);
|
||
postText = lines[randomIndex];
|
||
} else {
|
||
const randomIndex = Math.floor(Math.random() * fallbackPosts.length);
|
||
postText = fallbackPosts[randomIndex];
|
||
}
|
||
|
||
// Startzeitpunkt des Streams aus vorherigem Node lesen (startIso)
|
||
let startIso = items[0].json?.startIso || null;
|
||
let startLocal = '';
|
||
|
||
if (startIso) {
|
||
try {
|
||
const date = new Date(startIso);
|
||
const formatter = new Intl.DateTimeFormat('de-DE', {
|
||
weekday: 'short',
|
||
hour: '2-digit',
|
||
minute: '2-digit',
|
||
timeZone: 'Europe/Berlin',
|
||
hour12: false
|
||
});
|
||
startLocal = formatter.format(date);
|
||
} catch (err) {
|
||
startLocal = '';
|
||
}
|
||
}
|
||
|
||
if (startLocal) {
|
||
postText = `${postText} 🎬 Start: ${startLocal}`;
|
||
}
|
||
|
||
// Weitergabe an nächste Nodes
|
||
return [{
|
||
json: {
|
||
...items[0].json,
|
||
postText
|
||
}
|
||
}];
|
||
```
|
||
|
||
👉 Screenshot geeignet: Node-Ausgabe mit Feld `postText` und zufälligem Text
|
||
|
||
[!NOTE]
|
||
Wenn die Datei `posts.txt` fehlt oder leer ist, sorgt die integrierte Fallback-Liste dafür, dass trotzdem ein sinnvoller Post generiert wird.
|
||
Damit ist der Workflow robust und funktioniert zuverlässig auch ohne manuelle Pflege der Datei.
|
||
|
||
### 6.15 – X-Post veröffentlichen
|
||
|
||
**Zweck:**
|
||
Dieser Node sendet den zuvor generierten Text (`postText`) automatisch als Tweet über das verknüpfte X-Konto.
|
||
|
||
**Node-Typ:** `X`
|
||
**Name:** `X – Post veröffentlichen`
|
||
|
||
👉 Screenshot geeignet: n8n – X-Node mit ausgefülltem Formular für Tweet-Erstellung
|
||
|
||
#### Einstellungen
|
||
|
||
| Feld | Eingabe |
|
||
|------|----------|
|
||
| **Credential to connect with** | `X account` *(aus Schritt 5.8)* |
|
||
| **Resource** | `Tweet` |
|
||
| **Operation** | `Create` |
|
||
| **Text** | `{{ $json.postText }}` |
|
||
|
||
Beispielausgabe:
|
||
```
|
||
Stream incoming! Noch ein paar Minuten bis Start 🎬 Start: Mi., 18:00
|
||
```
|
||
|
||
👉 Screenshot geeignet: n8n – Erfolgreicher Tweet-Node mit grünem Ausgabestatus
|
||
|
||
[!NOTE]
|
||
Dieser Node nutzt direkt die X-Integration von n8n und benötigt keine manuelle API-Konfiguration.
|
||
Im **Free-Plan** sind bis zu **17 Posts pro 24 Stunden** erlaubt.
|
||
|
||
[!TIP]
|
||
Wenn der Node mit `401 Unauthorized` fehlschlägt:
|
||
- Öffne die X-Credentials in n8n und **verbinde den Account erneut**,
|
||
- prüfe, ob die App im X Developer Dashboard **„Read and Write“** aktiviert hat.
|
||
Danach sollte der Node wieder erfolgreich posten.
|
||
|
||
### 6.16 – Lokale Datei löschen (Workflow-Speicher bereinigen)
|
||
|
||
**Zweck:**
|
||
Dieser Node entfernt die lokal zwischengespeicherte Datei `posts.txt` aus dem Workflow-Speicher.
|
||
Damit wird verhindert, dass beim nächsten Lauf alte Daten erneut verwendet werden.
|
||
|
||
**Node-Typ:** `Code`
|
||
**Name:** `Temporäre Datei entfernen`
|
||
|
||
👉 Screenshot geeignet: n8n – Code Node mit Löschskript
|
||
|
||
#### Einstellungen
|
||
|
||
**Code:**
|
||
```
|
||
return items.map(item => {
|
||
if (item.binary && item.binary.data) {
|
||
delete item.binary.data; // Entfernt die heruntergeladene Datei aus dem Speicher
|
||
}
|
||
return item;
|
||
});
|
||
```
|
||
|
||
[!NOTE]
|
||
- Dieser Node löscht **nicht die Datei auf der Festplatte oder in Nextcloud**,
|
||
sondern nur die temporäre Kopie, die n8n im Speicher hält.
|
||
- Beim nächsten Workflow-Lauf wird die Datei automatisch neu aus Nextcloud geladen.
|
||
- Diese Methode funktioniert stabil in jeder n8n-Version, ohne zusätzliche Module.
|
||
|
||
### 6.17 – Gesamter Workflow als JSON-Import
|
||
|
||
Zum Abschluss stellen wir den gesamten Workflow als **importierbare JSON-Datei** bereit.
|
||
Diese Datei enthält alle Nodes, Verbindungen und Einstellungen – fertig vorbereitet für den direkten Import in n8n.
|
||
|
||
👉 Screenshot geeignet: n8n – Menüpunkt „Import from File“
|
||
|
||
1) Öffne n8n im Browser.
|
||
2) Klicke oben rechts auf das **Drei-Punkte-Menü** → **Import from File**.
|
||
3) Wähle die bereitgestellte JSON-Datei (`stream_schedule_workflow.json`) aus.
|
||
4) Nach dem Import prüfe, ob alle **Credentials** korrekt zugewiesen sind:
|
||
- Twitch
|
||
- X (Twitter)
|
||
- Nextcloud
|
||
|
||
[!TIP]
|
||
Sollten Credentials fehlen oder fehlerhaft sein, öffne den jeweiligen Node, wähle in der Liste das passende Credential neu aus und speichere den Node anschließend.
|
||
|
||
Nach erfolgreichem Import ist der Workflow sofort einsatzbereit und kann manuell gestartet oder automatisch durch den Cron-Trigger ausgelöst werden.
|
||
|
||
---
|
||
|
||
## Troubleshooting & Tipps
|
||
|
||
Auch ein gut eingerichteter Workflow kann gelegentlich aus dem Takt geraten.
|
||
Vielleicht erscheint kein Beitrag, vielleicht bleibt eine Verbindung hängen – das ist normal.
|
||
n8n arbeitet mit mehreren Diensten gleichzeitig, und schon kleine Änderungen bei Twitch, X oder Nextcloud können eine neue Anmeldung nötig machen.
|
||
Mit etwas Geduld lässt sich das schnell wieder beheben.
|
||
|
||
### Verbindungen prüfen und aktualisieren
|
||
|
||
n8n speichert die Zugänge zu deinen Diensten unter **Credentials**.
|
||
Diese Zugänge sind wie kleine Schlüssel, mit denen der Workflow auf Twitch, X und Nextcloud zugreifen darf.
|
||
Wenn du dich bei einem dieser Dienste neu anmeldest, das Passwort änderst oder der Zugang zu lange ungenutzt bleibt, verliert n8n die Berechtigung.
|
||
|
||
Das erkennst du daran, dass der Workflow plötzlich keine Daten mehr abruft oder beim Start eine Fehlermeldung anzeigt.
|
||
|
||
So stellst du die Verbindung wieder her:
|
||
|
||
1. Öffne in n8n die linke Seitenleiste und wähle **Credentials**.
|
||
2. Dort erscheinen alle gespeicherten Zugänge.
|
||
Schaue dir besonders **Twitch**, **X** und **Nextcloud** an.
|
||
3. Ist ein Eintrag rot markiert oder als *disconnected* gekennzeichnet, öffne ihn.
|
||
4. Klicke auf **Reconnect**. Es öffnet sich das gewohnte Anmeldefenster des Dienstes.
|
||
5. Melde dich mit deinem Konto an und bestätige die Freigabe für n8n.
|
||
6. Danach auf **Save** klicken.
|
||
|
||
Nach der Bestätigung prüft n8n automatisch, ob alles wieder funktioniert.
|
||
Du musst nichts neu anlegen – der Workflow arbeitet beim nächsten Lauf wie gewohnt weiter.
|
||
|
||
### Wenn kein Beitrag erscheint
|
||
|
||
Dass kein Post veröffentlicht wird, ist nicht immer ein Fehler.
|
||
Der Workflow reagiert nur, wenn im Twitch-Zeitplan ein Stream bevorsteht.
|
||
Ist aktuell keiner geplant, passiert auch nichts – so soll es sein.
|
||
|
||
Wenn aber ein Stream eingetragen ist und trotzdem kein Post kommt, gehe folgendermaßen vor:
|
||
|
||
1. Öffne den Workflow in n8n.
|
||
Oben rechts sollte der Statuspunkt **grün** sein.
|
||
Wenn er grau ist, klicke auf **Activate**, damit der automatische Start wieder aktiv ist.
|
||
2. Schaue unten links in den Bereich **Executions**.
|
||
Wird dort ein rotes Symbol oder der Hinweis „Unauthorized“ angezeigt, ist eine Verbindung abgelaufen.
|
||
In diesem Fall einmal die Credentials prüfen und gegebenenfalls neu verbinden (siehe oben).
|
||
3. Starte den Workflow testweise manuell über **Execute Workflow**.
|
||
Wenn danach ein Post ausgelöst wird, war die Verbindung die Ursache.
|
||
|
||
Nach dieser Kontrolle läuft der Ablauf in der Regel wieder zuverlässig.
|
||
|
||
### Posts-Datei kontrollieren
|
||
|
||
Die Textvorschläge für deine Beiträge stammen aus der Datei **posts.txt** in deiner Nextcloud.
|
||
Wenn n8n keine Beiträge mehr findet oder immer denselben Text verwendet, liegt das meist an dieser Datei.
|
||
|
||
Prüfe Folgendes:
|
||
|
||
- **Ort:** Die Datei muss im Ordner liegen, der im Workflow beim Download-Node angegeben wurde.
|
||
- **Inhalt:** Jede Zeile steht für einen Textvorschlag.
|
||
Beispiel:
|
||
```
|
||
Gleich geht’s los – wir sind live!
|
||
Heute wieder mit neuen Highlights im Stream!
|
||
Noch 15 Minuten, dann geht’s los!
|
||
```
|
||
- **Name:** Der Dateiname muss exakt `posts.txt` lauten.
|
||
- **Fehlerfall:** Ist die Datei leer oder fehlt, nutzt n8n automatisch eigene Standardtexte, damit der Ablauf nicht unterbrochen wird.
|
||
|
||
Wenn du neue Posts ergänzen möchtest, öffne die Datei direkt in Nextcloud, schreibe die Texte hinein und speichere sie.
|
||
n8n lädt beim nächsten Lauf automatisch die aktualisierte Version.
|
||
|
||
### Wenn der Workflow hängt
|
||
|
||
Manchmal reagiert n8n träge, zum Beispiel nach einem Update oder wenn der Container längere Zeit pausiert war.
|
||
Dann hilft ein kurzer Neustart:
|
||
|
||
1. Öffne den Workflow.
|
||
2. Klicke oben auf **Stop**.
|
||
3. Danach auf **Start**.
|
||
|
||
Dadurch wird nur der Ablauf neu geladen – alle Einstellungen und Verbindungen bleiben erhalten.
|
||
Beim nächsten geplanten Zeitpunkt arbeitet der Cron-Trigger wieder normal.
|
||
|
||
[!TIP]
|
||
Wenn du nachvollziehen möchtest, was beim letzten Durchlauf passiert ist, öffne unten links **Executions** und wähle den neuesten Eintrag.
|
||
n8n zeigt dort Schritt für Schritt, welche Aktionen erfolgreich waren und wo ein Fehler aufgetreten ist.
|
||
So findest du die Ursache gezielt, ohne den Workflow neu einrichten zu müssen.
|
||
|
||
---
|
||
|
||
## Abschluss
|
||
|
||
Mit dem hier eingerichteten Workflow ist dein System erstmals in der Lage, eigenständig auf zukünftige Streams zu reagieren.
|
||
Sobald auf Twitch ein neuer Termin im Zeitplan auftaucht, prüft n8n automatisch, ob dieser in Kürze startet, und erstellt einen vorbereiteten Beitrag.
|
||
Damit hast du den ersten Baustein für automatisierte Kommunikation gelegt – einfach, nachvollziehbar und ohne externe Dienste.
|
||
|
||
Der Ablauf läuft vollständig im eigenen Container und arbeitet stabil, solange die Verbindungen zu Twitch, X und Nextcloud aktiv bleiben.
|
||
Neue Ideen oder kleine Änderungen lassen sich jederzeit direkt in n8n testen, ohne etwas am Grundsystem zu verändern.
|
||
Wenn du möchtest, kannst du so nach und nach weitere Dienste einbinden oder bestehende Abläufe verfeinern.
|
||
|
||
Im weiteren Verlauf werden wir auf dieser Grundlage aufbauen und die Automatisierung Schritt für Schritt erweitern – bis hin zu intelligenten Workflows, die eigenständig Inhalte analysieren, kombinieren und veröffentlichen.
|
||
Doch selbst in dieser Basisform zeigt sich, wie viel Zeit sich mit etwas Vorbereitung einsparen lässt.
|
||
|
||
[!TIP]
|
||
Wenn dein Workflow zuverlässig läuft, sichere ihn regelmäßig über **Export > Download Workflow File**.
|
||
So kannst du jederzeit eine funktionierende Version wiederherstellen, falls n8n oder ein Container neu aufgesetzt werden muss. |