854 lines
41 KiB
Markdown
854 lines
41 KiB
Markdown
# Premium – Community-Nodes & KI-Erweiterung für n8n
|
||
|
||
Im Free-Kapitel hast du n8n eingerichtet und einen vollständigen Workflow erstellt, der deinen Stream- oder Content-Alltag bereits spürbar vereinfacht.
|
||
Er prüft automatisch geplante Sendungen und erstellt daraus strukturierte Ankündigungen – eine solide, funktionierende Automatisierung mit direktem Nutzen.
|
||
|
||
Der Premium-Teil baut exakt auf diesem bestehenden Workflow auf.
|
||
Hier lernst du, wie du n8n mit Community-Nodes und KI-Funktionen erweiterst, um die bisherigen Abläufe deutlich zu professionalisieren:
|
||
Social-Posts, Medienbearbeitung, Textoptimierung und Voice-Overs werden automatisiert integriert, ohne den ursprünglichen Workflow zu ersetzen.
|
||
|
||
Das Ziel ist kein Experimentieren, sondern produktive Erweiterung: n8n wird zum zentralen Werkzeug, das Inhalte erkennt, aufbereitet und veröffentlicht – gesteuert von denselben Triggern, die du bereits nutzt.
|
||
|
||
In diesem Kapitel behandeln wir:
|
||
|
||
1. **Community-Nodes (aus „awesome-n8n“)**
|
||
- Auswahl und Installation acht praxiserprobter Erweiterungen, die n8n um echte Creator-Funktionen ergänzen.
|
||
- Professionelle Automationen für Social Media, Bild- und Textverarbeitung sowie KI-gestützte Aufgaben.
|
||
|
||
2. **KI-Erweiterung des bestehenden Workflows**
|
||
- Integration von Text- und Sprach-KI, die automatisch Ankündigungen verfeinern, Clips beschreiben oder Voice-Overs erzeugen.
|
||
- Erweiterung deiner bestehenden Struktur – keine neuen Workflows, sondern ein gezieltes Upgrade deiner Automatisierung.
|
||
|
||
>[!NOTE]
|
||
>Die in diesem Kapitel vorgestellten Community-Nodes stammen aus der öffentlichen Sammlung
|
||
>[**awesome-n8n**](https://github.com/restyler/awesome-n8n?tab=readme-ov-file#7-file--pdf-manipulation-nodes).
|
||
>Diese Liste wird von der internationalen n8n-Community gepflegt und regelmäßig aktualisiert.
|
||
>Da sie nicht von uns erstellt oder betreut wird, können sich Beschreibungen, Funktionen oder Kompatibilitäten jederzeit ändern.
|
||
>Wir übernehmen keine Gewähr für Richtigkeit oder Schäden, die durch die Nutzung einzelner Nodes entstehen können.
|
||
>Prüfe vor jeder Installation, ob der jeweilige Node mit deiner installierten n8n-Version kompatibel ist und aus einer vertrauenswürdigen >Quelle stammt.
|
||
|
||
---
|
||
|
||
## Community-Nodes
|
||
|
||
Community-Nodes sind von der n8n-Community entwickelte Erweiterungen, die zusätzliche Funktionen, Integrationen und Automatisierungen bereitstellen.
|
||
Sie ergänzen den Funktionsumfang von n8n erheblich – oft in Bereichen, die offiziell (noch) nicht abgedeckt sind.
|
||
Gerade für Streamer und Content-Creator eröffnen sie völlig neue Möglichkeiten: Social-Media-Automatisierung, Medienverarbeitung, Textanalyse oder KI-gestützte Inhalte.
|
||
|
||
Im Premium-Kapitel stellen wir sieben ausgewählte Nodes vor, die sich im Creator-Alltag als besonders nützlich erwiesen haben.
|
||
Sie stammen aus der kuratierten Sammlung *awesome-n8n* und sind praxiserprobt, aktiv gepflegt und stabil einsetzbar.
|
||
Alle Beispiele bauen direkt auf deinem bestehenden Workflow auf und zeigen, wie du ihn gezielt erweiterst – nicht ersetzt.
|
||
|
||
>[!TIP]
|
||
>Die Installation erfolgt immer über **Settings → Community Nodes → Install**, indem du den exakten Paketnamen einträgst (z. B. `n8n-nodes-meta-publisher`).
|
||
>Nach der Bestätigung steht der Node sofort in der Node-Liste unter „Community“ zur Verfügung.
|
||
|
||
👉 Screenshot geeignet: *Installationsfenster von n8n mit eingetragenem Paketnamen.*
|
||
|
||
### Installation der Community-Nodes
|
||
|
||
Alle in diesem Kapitel vorgestellten Erweiterungen stammen aus der Community und werden über den integrierten Node-Manager in n8n installiert.
|
||
Da sie nicht Bestandteil der Standard-Distribution sind, muss jede Erweiterung manuell hinzugefügt werden.
|
||
Die Vorgehensweise ist bei allen Nodes identisch.
|
||
|
||
#### Schritt 1 – Node-Manager öffnen
|
||
1. Melde dich in deiner n8n-Instanz an.
|
||
2. Klicke im linken Menü auf **Settings → Community Nodes**.
|
||
3. Bestätige die Sicherheitsabfrage mit **Enable** (einmalig erforderlich).
|
||
|
||
👉 Screenshot geeignet: *n8n-Einstellungen mit aktivierten Community-Nodes.*
|
||
|
||
#### Schritt 2 – Node hinzufügen
|
||
1. Klicke auf **Install a Community Node**.
|
||
2. Gib den exakten Paketnamen ein, z. B.:
|
||
```bash
|
||
n8n-nodes-edit-image-plus
|
||
```
|
||
3. Klicke auf **Install**, warte bis der Vorgang abgeschlossen ist, und bestätige mit **Close**.
|
||
|
||
👉 Screenshot geeignet: *Installationsfenster mit eingegebenem Node-Namen.*
|
||
|
||
#### Schritt 3 – Node im Editor prüfen
|
||
Öffne anschließend den Workflow-Editor.
|
||
Der neue Node sollte in der Suchleiste verfügbar sein.
|
||
Falls nicht, lade n8n einmal neu.
|
||
|
||
👉 Screenshot geeignet: *Node-Suchfeld mit neu installierter Erweiterung.*
|
||
|
||
>[!TIP]
|
||
>Bei allen Community-Nodes gilt: Schreibweise exakt übernehmen.
|
||
>Fehler im Paketnamen führen zu „not found“ oder „invalid package“-Meldungen.
|
||
|
||
>[!NOTE]
|
||
>Community-Nodes stammen aus externen Quellen, die regelmäßig aktualisiert werden.
|
||
>Die Liste und der jeweilige Funktionsumfang können sich ändern.
|
||
>Wir übernehmen **keine Gewähr für Vollständigkeit oder Funktionsgarantie**.
|
||
>Eine aktuelle Übersicht findest du in der offiziellen Sammlung unter
|
||
>[https://github.com/restyler/awesome-n8n](https://github.com/restyler/awesome-n8n?tab=readme-ov-file#7-file--pdf-manipulation-nodes)
|
||
|
||
### 1. n8n-nodes-discord-trigger
|
||
|
||
Der **Discord Trigger** startet deinen Workflow, sobald in deinem Discord-Server ein definiertes Ereignis eintritt – z. B. neue Nachricht im Ankündigungs-Channel, ein Slash-Command, ein Join/Leave oder eine Reaktion.
|
||
Damit holst du deine Community **direkt in die Automatisierung**: Ankündigungen, Social-Posts, KI-Antworten, Dateiverarbeitung – alles beginnt zuverlässig mit einem Discord-Event.
|
||
|
||
#### Schritt 1 – Discord-Bot anlegen (Developer Portal)
|
||
|
||
1. Öffne **https://discord.com/developers/applications** und klicke auf **New Application**.
|
||
2. Vergib einen Namen (z. B. `UCC n8n Bot`) → **Create**.
|
||
3. Menü **Bot** → **Add Bot** → **Yes, do it!**
|
||
4. Kopiere unter **Token** den **Bot Token** (zeige ihn nur in n8n, nirgends sonst).
|
||
5. Aktiviere unter **Privileged Gateway Intents**:
|
||
- **PRESENCE INTENT** (nur wenn du auf Präsenz reagieren willst)
|
||
- **SERVER MEMBERS INTENT** (nur wenn du auf Joins/Leaves reagierst)
|
||
- **MESSAGE CONTENT INTENT** (**erforderlich**, wenn `messageCreate` verarbeitet werden soll)
|
||
6. Menü **OAuth2 → URL Generator**:
|
||
- **Scopes:** `bot`, `applications.commands`
|
||
- **Bot Permissions (Minimum):**
|
||
- **View Channels**, **Read Message History**, **Send Messages**
|
||
- Optional: **Embed Links**, **Attach Files**, **Use Slash Commands**
|
||
- Kopiere die generierte URL und öffne sie → **Server auswählen** → **Authorize**.
|
||
|
||
👉 Screenshot geeignet: *Discord Developer Portal – Bot-Seite mit aktivierten Intents und „Copy Token“.*
|
||
|
||
>[!WARNING]
|
||
>Teile den **Bot Token** niemals öffentlich. Leakt der Token, **reset** ihn sofort im Developer Portal und aktualisiere das Credential in n8n.
|
||
|
||
#### Schritt 2 – Credential in n8n anlegen
|
||
|
||
1. Öffne **n8n → Credentials**.
|
||
2. Lege ein neues Credential für den Discord-Trigger an (Typ je nach Community-Node, i. d. R. „Discord Bot Token“ oder in den Node-Feldern direkt).
|
||
3. Trage den **Bot Token** ein und speichere.
|
||
|
||
👉 Screenshot geeignet: *n8n Credentials – neues Discord-Credential mit Token.*
|
||
|
||
>[!TIP]
|
||
>Lege für Produktion und Test **separate Credentials** an (z. B. `discord_bot_prod`, `discord_bot_stage`), damit du Änderungen gefahrlos testen kannst.
|
||
|
||
#### Schritt 3 – Node einfügen und Ereignis wählen
|
||
|
||
1. Öffne deinen bestehenden Workflow in n8n.
|
||
2. Füge **`n8n-nodes-discord-trigger`** hinzu.
|
||
3. Wähle dein Credential aus.
|
||
4. **Event** wählen – gängige Optionen:
|
||
- `messageCreate` (neue Nachricht in einem Channel)
|
||
- `interactionCreate` (Slash-Command / Button / Select)
|
||
- `guildMemberAdd` / `guildMemberRemove` (Join/Leave)
|
||
- `messageReactionAdd` (Reaktionen)
|
||
5. **Filter** setzen:
|
||
- **Guild/Server ID**
|
||
- **Channel ID** (nur relevante Kanäle)
|
||
- Optional: **Starts with** / **Regex** (z. B. nur Nachrichten, die mit `!clip` beginnen)
|
||
|
||
👉 Screenshot geeignet: *Discord Trigger – Konfiguration mit Event `messageCreate` und Channel-Filter.*
|
||
|
||
>[!IMPORTANT]
|
||
>Stelle sicher, dass **WebSockets** zwischen n8n und Discord durch deine Umgebung (Nginx Proxy Manager, Firewall) **nicht blockiert** werden. Ohne WS-Verbindung kommen keine Events an.
|
||
|
||
#### Schritt 4 – Payload verstehen (Beispiele)
|
||
|
||
Bei `messageCreate` sieht die Nutzlast typischerweise so aus (gekürzt):
|
||
|
||
```json
|
||
{
|
||
"id": "123456789012345678",
|
||
"content": "!announce Heute 20:00 Retro-Stream",
|
||
"author": {
|
||
"id": "111111111111111111",
|
||
"username": "Barney",
|
||
"bot": false
|
||
},
|
||
"channel_id": "222222222222222222",
|
||
"guild_id": "333333333333333333",
|
||
"timestamp": "2025-10-11T15:45:12.345Z"
|
||
}
|
||
```
|
||
|
||
Nützliche Ausdrücke für nachfolgende Nodes:
|
||
|
||
- Nachrichtentext: `{{$json.content}}`
|
||
- Benutzername: `{{$json.author.username}}`
|
||
- Channel-ID: `{{$json.channel_id}}`
|
||
- Gilde/Server: `{{$json.guild_id}}`
|
||
|
||
👉 Screenshot geeignet: *Node-Ausgabe (JSON) im „Execution Data“-Panel mit markierten Feldern.*
|
||
|
||
#### Schritt 5 – Typische Anwendungsfälle (direkt weiterverarbeiten)
|
||
|
||
- **Ankündigung mittels KI aufbereiten:**
|
||
`Discord Trigger → n8n-nodes-openrouter (Titel/Hashtags generieren) → n8n-nodes-text-manipulation (Format) → Postiz/CloudConvert/Discord Reply`
|
||
- **Clip-Befehl:**
|
||
`Discord Trigger (messageCreate mit !clip) → Webhook/HTTP (ffmpeg-Pipeline anstoßen) → Discord Reply (Bestätigung)`
|
||
- **Join/Leave-Begrüßung:**
|
||
`guildMemberAdd → Discord Send Message (Willkommen)`
|
||
|
||
>[!TIP]
|
||
>Halte den Trigger **sauber gefiltert** (Channel + Präfix/Regex). So löst du nur bei relevanten Nachrichten aus und sparst Ressourcen.
|
||
|
||
#### Fehlersuche & Absicherung
|
||
|
||
- **Es kommt kein Event an:**
|
||
- Prüfe, ob der Bot **auf dem Server** ist und **Rechte auf dem Channel** hat (mind. View, Read, Send).
|
||
- **MESSAGE CONTENT INTENT** aktiviert? Ohne das sieht der Bot **keine Inhalte**.
|
||
- **WebSocket erreichbar?** NPM/Firewall dürfen WS nicht blocken.
|
||
- Node speichern, Workflow aktivieren, n8n-Instanz neu laden.
|
||
|
||
- **„Missing Access“ / „Forbidden“:**
|
||
- Rechte im Channel prüfen; in privaten/Thread-Channels Bot ausdrücklich hinzufügen.
|
||
- In **Serverrollen** dem Bot die nötigen Berechtigungen geben.
|
||
|
||
- **Zu viele Events / Spam:**
|
||
- Channel gezielt filtern.
|
||
- Regex verwenden (z. B. nur `^!announce\s` oder `^!clip\s`).
|
||
- Rate-Limitierung in nachfolgenden Schritten (Delay/Queue).
|
||
|
||
>[!WARNING]
|
||
>Vermeide Antworten in Endlosschleifen (Bot reagiert auf die eigene Nachricht).
|
||
>Setze eine **Bedingung**, die Nachrichten mit `author.bot === true` ignoriert.
|
||
|
||
👉 Screenshot geeignet: *Filter-Einstellungen im Discord Trigger (Regex) und Beispiel-Execution mit gefilterter Nachricht.*
|
||
|
||
### 2. @devlikeapro/n8n-nodes-waha
|
||
|
||
Der **WAHA Node** (WhatsApp HTTP API) verbindet deinen Workflow direkt mit WhatsApp.
|
||
Er ermöglicht das automatisierte Senden und Empfangen von Nachrichten, Statusmeldungen oder Sprachaufnahmen über eine lokal gehostete oder gecloudete WAHA-Instanz.
|
||
Damit kannst du Benachrichtigungen, Bestätigungen oder KI-Antworten direkt per WhatsApp an dich selbst oder deine Community senden – völlig unabhängig von Drittanbietern wie Twilio.
|
||
|
||
>[!NOTE]
|
||
>Im Verlauf dieses Tutorials wird in **Kapitel [X] – WAHA (WhatsApp HTTP API)** ein eigener Server eingerichtet, der vollständig in die UCC-Struktur integriert ist.
|
||
>Die nachfolgende Anleitung verwendet daher eine **temporäre Instanz** zur Veranschaulichung.
|
||
|
||
#### Schritt 1 – WAHA-Instanz vorbereiten
|
||
|
||
1. Öffne [https://waha.devlike.pro](https://waha.devlike.pro) und lade die aktuelle Version der **WhatsApp HTTP API** herunter.
|
||
2. Installiere sie in einem separaten Container oder auf einem dedizierten Server (z. B. `waha.yourdomain.tld`).
|
||
Empfohlen wird ein einfacher **Docker-Container** mit folgendem Befehl:
|
||
|
||
```bash
|
||
docker run -d \
|
||
--name=waha \
|
||
-p 3000:3000 \
|
||
-v ~/waha-data:/app/data \
|
||
devlikeapro/waha
|
||
```
|
||
|
||
3. Rufe anschließend die lokale Oberfläche auf:
|
||
`http://<deine-server-ip>:3000`
|
||
4. Scanne den angezeigten **QR-Code** mit der offiziellen WhatsApp-App auf deinem Smartphone → Menü **Verknüpfte Geräte → Gerät hinzufügen**.
|
||
Nach erfolgreicher Kopplung zeigt die Oberfläche den Status **connected** an.
|
||
|
||
👉 Screenshot geeignet: *WAHA-Weboberfläche mit QR-Code und Status „connected“.*
|
||
|
||
>[!IMPORTANT]
|
||
>Die Verbindung bleibt nur bestehen, solange dein WhatsApp-Konto aktiv bleibt.
|
||
>Falls du WhatsApp neu installierst oder das Gerät wechselst, musst du die Kopplung erneut durchführen.
|
||
|
||
#### Schritt 2 – API-Schlüssel abrufen
|
||
|
||
1. In der WAHA-Oberfläche **Settings → API Token** öffnen.
|
||
2. Klicke auf **Generate Token** und kopiere den angezeigten Wert.
|
||
3. Notiere die Basis-URL deiner Instanz (z. B. `http://waha.yourdomain.tld`).
|
||
|
||
👉 Screenshot geeignet: *WAHA-Oberfläche mit erzeugtem API-Token.*
|
||
|
||
#### Schritt 3 – Credential in n8n anlegen
|
||
|
||
1. In n8n unter **Credentials** ein neues Credential anlegen.
|
||
2. Typ: `WAHA API` (oder `Generic API` bei älteren Versionen).
|
||
3. Trage ein:
|
||
- **Base URL:** `http://waha.yourdomain.tld`
|
||
- **Token:** den zuvor generierten API-Key
|
||
4. Speichern.
|
||
|
||
👉 Screenshot geeignet: *n8n Credentials mit WAHA-URL und Token.*
|
||
|
||
#### Schritt 4 – Node im Workflow verwenden
|
||
|
||
1. Öffne deinen bestehenden Workflow.
|
||
2. Füge den Node **`@devlikeapro/n8n-nodes-waha`** hinzu.
|
||
3. Wähle das angelegte Credential.
|
||
4. Wähle die gewünschte **Aktion**:
|
||
- `Send Message` → Textnachricht an eine Nummer senden
|
||
- `Send Audio` → Sprachdatei senden
|
||
- `Get Status` → Verbindung prüfen
|
||
- `Receive Message` → eingehende Nachrichten verarbeiten
|
||
5. Für **Send Message** z. B.:
|
||
- **Phone number:** im internationalen Format (z. B. `491701234567`)
|
||
- **Message:** z. B. `"Dein Stream startet in 10 Minuten!"`
|
||
|
||
👉 Screenshot geeignet: *WAHA Node-Konfiguration mit Telefonnummer und Textnachricht.*
|
||
|
||
#### Schritt 5 – Test und Ergebnis
|
||
|
||
Starte den Workflow manuell oder über den Trigger (z. B. Discord oder Cron).
|
||
Nach erfolgreicher Ausführung wird die Nachricht an dein WhatsApp-Konto gesendet und in der WAHA-Konsole protokolliert.
|
||
Die Node-Ausgabe enthält u. a. Message-ID, Timestamp und Delivery-Status.
|
||
|
||
```json
|
||
{
|
||
"id": "wamid.HBgLMzQ5MT...",
|
||
"status": "sent",
|
||
"timestamp": "2025-10-11T18:02:44.203Z"
|
||
}
|
||
```
|
||
|
||
👉 Screenshot geeignet: *WAHA-Logs mit gesendeter Nachricht und Status „sent“.*
|
||
|
||
#### Praxisnutzen für Streamer und Content-Creator
|
||
- **Automatische Benachrichtigung:** Sende dir selbst oder deinem Team eine WhatsApp, wenn ein Workflow abgeschlossen ist (z. B. Upload fertig, Stream geplant, Backup erfolgreich).
|
||
- **Feedback & Alerts:** Lass n8n Fehler oder Ausfälle per WhatsApp melden.
|
||
- **Interaktive Steuerung:** Sende Kommandos an n8n, z. B. `status`, `clip`, `start`, um Aktionen auszulösen.
|
||
- **Sprachintegration:** In Kombination mit **n8n-nodes-elevenlabs** kannst du Sprachnachrichten generieren und direkt verschicken.
|
||
|
||
>[!TIP]
|
||
>Halte die WAHA-Instanz auf einem stabilen Container oder Mini-Server mit fester IP.
|
||
>WhatsApp blockiert Verbindungen, wenn sie häufig neu aufgebaut werden oder über wechselnde IPs laufen.
|
||
|
||
👉 Screenshot geeignet: *n8n-Ausführung mit JSON-Output der gesendeten WhatsApp-Nachricht.*
|
||
|
||
### 3. n8n-nodes-edit-image-plus
|
||
|
||
Der **Edit Image Plus Node** ist eine erweiterte Bildbearbeitung für n8n.
|
||
Er kann Grafiken automatisch zuschneiden, skalieren, konvertieren, Wasserzeichen hinzufügen oder Thumbnails erzeugen – alles serverseitig und ohne manuelle Eingriffe.
|
||
Gerade für Streamer und Creator ist das ideal, um Vorschaubilder, Thumbnails oder Social-Media-Formate direkt im Workflow zu generieren.
|
||
|
||
#### Schritt 1 – Node im richtigen Abschnitt des Workflows einsetzen
|
||
|
||
Der **Edit Image Plus Node** wird immer dann eingesetzt, **wenn in deinem Workflow bereits eine Bilddatei vorliegt**, z. B. nach einem CloudConvert-Schritt, einer ffmpeg-Analyse oder einem Upload-Prozess.
|
||
Er bildet die Brücke zwischen der Dateierzeugung und der anschließenden Veröffentlichung, Konvertierung oder Archivierung.
|
||
Ziehe den Node **`n8n-nodes-edit-image-plus`** in diesen Abschnitt deines Workflows und verbinde ihn mit dem vorhergehenden Node, der das Bild bereitstellt.
|
||
|
||
👉 Screenshot geeignet: *Position des Edit Image Plus Nodes zwischen Datei-Quelle (z. B. CloudConvert) und Upload-Schritt.*
|
||
|
||
#### Schritt 2 – Eingabequelle definieren
|
||
|
||
Der Node übernimmt das Eingabebild direkt aus dem vorherigen Schritt.
|
||
Je nach Workflow kann dies eine Datei-URL, ein Dateipfad oder ein Base64-Buffer sein.
|
||
|
||
Beispielvariablen:
|
||
- **Dateipfad:** `{{$json.filePath}}`
|
||
- **Datei-URL:** `{{$json.fileUrl}}`
|
||
- **Base64-Daten:** `{{$json.data}}`
|
||
|
||
👉 Screenshot geeignet: *Input-Feld mit referenzierter Variable aus vorherigem Node.*
|
||
|
||
#### Schritt 3 – Parameter für Bildbearbeitung festlegen
|
||
|
||
Für die häufigsten Anwendungsfälle:
|
||
|
||
- **Resize:**
|
||
- Width: `1280`
|
||
- Height: `720`
|
||
- Mode: `cover` (Bild füllt das Format vollständig ohne Ränder)
|
||
|
||
- **Add Watermark:**
|
||
- Text: `Bratonien TV`
|
||
- Position: `bottom-right`
|
||
- Opacity: `0.7`
|
||
- Font size: `36`
|
||
|
||
- **Convert:**
|
||
- Output format: `webp`
|
||
- Quality: `90`
|
||
|
||
👉 Screenshot geeignet: *Node-Felder für Größe, Format und Wasserzeichen.*
|
||
|
||
>[!TIP]
|
||
>Kombiniere `Resize` und `Add Watermark`, um in einem Schritt ein gebrandetes, Social-Media-taugliches Thumbnail zu erzeugen.
|
||
|
||
#### Schritt 4 – Ausgabe verarbeiten
|
||
|
||
Nach der Ausführung gibt der Node standardmäßig ein JSON-Objekt mit allen relevanten Informationen zurück:
|
||
|
||
```json
|
||
{
|
||
"fileName": "clip_thumbnail.webp",
|
||
"filePath": "/data/outputs/clip_thumbnail.webp",
|
||
"width": 1280,
|
||
"height": 720,
|
||
"format": "webp"
|
||
}
|
||
```
|
||
|
||
Diese Datei kann anschließend direkt in einem Upload-, Postiz- oder CloudConvert-Node weiterverarbeitet werden.
|
||
|
||
👉 Screenshot geeignet: *Execution Data mit erzeugtem Bildobjekt.*
|
||
|
||
#### Praxisnutzen für Streamer und Content-Creator
|
||
- **Automatische Thumbnails:** Erzeuge nach jedem Schnittprozess sofort ein 720p-Thumbnail mit Branding.
|
||
- **Social-Media-Optimierung:** Bereite das gleiche Motiv in Hoch- und Querformat für verschiedene Plattformen auf.
|
||
- **Einheitliches Branding:** Füge automatisch dein Logo, Wasserzeichen oder einen Texthinweis hinzu.
|
||
- **Ressourcenschonung:** Komprimiere PNGs oder JPEGs direkt zu modernen WEBP-Dateien.
|
||
|
||
>[!IMPORTANT]
|
||
>Achte bei automatisch generierten Wasserzeichen darauf, dass sie nicht wichtige Bildelemente verdecken.
|
||
>Gerade bei dynamisch zugeschnittenen Bildern kann die Position variieren – prüfe regelmäßig die Ergebnisse.
|
||
|
||
👉 Screenshot geeignet: *Vorher/Nachher-Beispiel eines Thumbnails mit Wasserzeichen und Resize-Effekt.*
|
||
|
||
### 4. n8n-nodes-text-manipulation
|
||
|
||
Der **Text Manipulation Node** ist ein vielseitiges Werkzeug zur automatisierten Textverarbeitung in n8n.
|
||
Er eignet sich perfekt, um Inhalte für Social Media, Titel, Hashtags oder Beschreibungstexte zu formatieren, zu kürzen, zu bereinigen oder zu kombinieren – ohne externe Tools oder manuelles Nachbearbeiten.
|
||
|
||
#### Schritt 1 – Node im richtigen Abschnitt des Workflows einsetzen
|
||
|
||
Der **Text Manipulation Node** wird immer dann eingesetzt, **wenn im Workflow bereits ein Text- oder Beschreibungselement vorliegt**, das weiterverarbeitet werden soll.
|
||
Das kann eine automatisch generierte KI-Ausgabe, ein Discord-Command, ein Dateiname oder ein Upload-Titel sein.
|
||
Platziere den Node **direkt nach dem Schritt**, der den Text liefert, und verbinde ihn mit der nachfolgenden Aktion (z. B. Upload, Postiz oder CloudConvert).
|
||
|
||
👉 Screenshot geeignet: *Position des Text Manipulation Nodes zwischen Eingabequelle und nachfolgender Aktion.*
|
||
|
||
#### Schritt 2 – Grundlegende Operation wählen
|
||
|
||
Öffne im Node-Fenster das Feld **Operation** und wähle die gewünschte Funktion.
|
||
Zu den wichtigsten gehören:
|
||
|
||
- `Replace Text` → Ersetzt Wörter, Zeichenfolgen oder Muster
|
||
- `Trim` → Entfernt Leerzeichen am Anfang und Ende
|
||
- `Split` / `Join` → Zerlegt Text in Teile oder fügt ihn zusammen
|
||
- `Regex Replace` → Sucht mit regulären Ausdrücken (für präzise Bereinigungen)
|
||
- `Uppercase / Lowercase / Capitalize` → Vereinheitlicht Schreibweisen
|
||
- `Substring` → Schneidet Text auf eine bestimmte Länge zu
|
||
- `Format` → Fügt Variablen oder Platzhalter in Text ein
|
||
|
||
👉 Screenshot geeignet: *Drop-down-Liste der verfügbaren Operationen im Node-Fenster.*
|
||
|
||
#### Schritt 3 – Eingabe und Ausdrücke definieren
|
||
|
||
Je nach Operation gibst du entweder einen direkten Text oder eine Variable ein, z. B.:
|
||
|
||
- **Textquelle:** `{{$json.title}}`
|
||
- **Replace:** `"Stream"` → `"Livestream"`
|
||
- **Trim:** aktiviert (keine Parameter nötig)
|
||
- **Format-Beispiel:**
|
||
`"{{ $json.title }} – startet um {{ $json.time }}"`
|
||
|
||
Die Ausgabe wird im JSON des Nodes als `output` oder `text` gespeichert und kann in nachfolgenden Schritten weiterverwendet werden.
|
||
|
||
👉 Screenshot geeignet: *Node-Konfiguration mit Beispielvariablen und Textfeld.*
|
||
|
||
>[!TIP]
|
||
>Mit der Operation **Format** lassen sich Texte dynamisch zusammenbauen – ideal für Social-Posts, Videotitel oder Discord-Meldungen.
|
||
>Beispiel:
|
||
>`"🎬 Neuer Clip: {{ $json.clipName }} – jetzt live auf Twitch!"`
|
||
|
||
#### Schritt 4 – Ausgabe und Weiterverarbeitung
|
||
|
||
Nach der Ausführung gibt der Node den bereinigten oder formatierten Text als JSON zurück, z. B.:
|
||
|
||
```json
|
||
{
|
||
"text": "🎬 Neuer Clip: Bossfight Highlight – jetzt live auf Twitch!"
|
||
}
|
||
```
|
||
|
||
Dieser kann direkt in folgenden Nodes genutzt werden, etwa:
|
||
- **Discord Send Message**
|
||
- **Postiz / Meta / Twitter**
|
||
- **File Writer**
|
||
- **AI-Node (OpenRouter)**
|
||
- **CloudConvert (Text → PDF)**
|
||
|
||
👉 Screenshot geeignet: *Execution Data mit bereinigtem und formatiertem Text.*
|
||
|
||
#### Praxisnutzen für Streamer und Content-Creator
|
||
- **Konsistente Titel:** Automatische Formatierung von Clip-Namen, Upload-Titeln und Beschreibungen.
|
||
- **Hashtag-Generierung:** Ergänze oder formatiere Hashtags automatisch mit Regeln oder Regex.
|
||
- **KI-Ausgaben säubern:** Entferne Leerzeichen, Sonderzeichen oder ungewollte Zusätze aus OpenRouter-Ergebnissen.
|
||
- **Mehrsprachige Texte:** Kombiniere mit Übersetzungs- oder KI-Nodes, um Inhalte automatisch sprachlich anzupassen.
|
||
|
||
>[!IMPORTANT]
|
||
>Verwende bei dynamischen Texten stets `{{$json...}}`-Variablen.
|
||
>Direkte Texteingaben werden beim Workflow-Duplizieren nicht aktualisiert, Variablen hingegen automatisch.
|
||
|
||
👉 Screenshot geeignet: *Vorher/Nachher-Vergleich eines automatisch bereinigten Social-Media-Textes.*
|
||
|
||
### 5. @cloudconvert/n8n-nodes-cloudconvert
|
||
|
||
Der **CloudConvert Node** ist eine leistungsstarke Schnittstelle zur Datei- und Medienkonvertierung.
|
||
Er unterstützt über 200 Formate – von Videos, Audios und Bildern bis zu Dokumenten oder Archiven – und ist damit das zentrale Werkzeug, um Dateien direkt im Workflow umzuwandeln oder vorzubereiten, bevor sie weiterverarbeitet oder hochgeladen werden.
|
||
|
||
Gerade für Creator ist das hilfreich, um Clips, Thumbnails oder Transkripte automatisch in das richtige Format zu bringen.
|
||
|
||
#### Schritt 1 – API-Schlüssel bei CloudConvert anlegen
|
||
|
||
1. Gehe auf [https://cloudconvert.com/dashboard/api/v2/keys](https://cloudconvert.com/dashboard/api/v2/keys).
|
||
2. Melde dich mit deinem CloudConvert-Konto an oder erstelle ein kostenloses Konto.
|
||
3. Klicke auf **Create API Key** und vergib einen Namen, z. B. `n8n`.
|
||
4. Kopiere den angezeigten Schlüssel und notiere ihn sicher – du benötigst ihn in n8n.
|
||
|
||
👉 Screenshot geeignet: *CloudConvert-Dashboard mit neu erzeugtem API-Key.*
|
||
|
||
>[!TIP]
|
||
>Das kostenlose Konto umfasst 25 Konvertierungen pro Tag.
|
||
>Für mehr Volumen oder gleichzeitige Aufträge kann später ein Upgrade erfolgen.
|
||
|
||
#### Schritt 2 – Credential in n8n anlegen
|
||
|
||
1. Öffne **n8n → Credentials**.
|
||
2. Suche nach **CloudConvert** und klicke auf **Neu**.
|
||
3. Trage den zuvor kopierten **API Key** ein.
|
||
4. Speichere das Credential unter einem eindeutigen Namen, z. B. `cloudconvert_main`.
|
||
|
||
👉 Screenshot geeignet: *Credential-Eintrag mit API-Key-Feld und gespeicherter Bezeichnung.*
|
||
|
||
#### Schritt 3 – Node im Workflow platzieren
|
||
|
||
Der **CloudConvert Node** wird überall dort eingesetzt, **wo eine Datei konvertiert oder neu verpackt werden muss**, z. B.:
|
||
- Nach ffmpeg-Schritten im Clipper-Workflow (z. B. MP4 → WEBM oder MOV).
|
||
- Nach der Thumbnail-Erstellung (z. B. PNG → WEBP).
|
||
- Vor einem Upload oder Archivschritt (z. B. ZIP oder PDF).
|
||
|
||
Ziehe den Node **`@cloudconvert/n8n-nodes-cloudconvert`** an die passende Stelle zwischen Dateiausgabe und Weiterverarbeitung.
|
||
|
||
👉 Screenshot geeignet: *Workflow mit CloudConvert Node zwischen Datei-Erstellung und Upload.*
|
||
|
||
#### Schritt 4 – Konvertierung konfigurieren
|
||
|
||
1. Wähle in der Node-Konfiguration dein Credential aus (`cloudconvert_main`).
|
||
2. Im Feld **Operation** wähle den Modus:
|
||
- `Convert a File` (Standard)
|
||
- `Merge Files` (mehrere Dateien kombinieren)
|
||
- `Compress File` (Dateigröße verringern)
|
||
3. Unter **Input File URL / Path** gibst du die Quelle an, z. B. `{{$json.fileUrl}}`.
|
||
4. Unter **Output Format** wähle das gewünschte Zielformat, z. B. `webp`, `mp3`, `mp4`, `pdf` oder `zip`.
|
||
5. Optionale Parameter:
|
||
- `Quality` (0–100)
|
||
- `Resolution` (bei Videos oder Bildern)
|
||
- `Preset` (z. B. „mobile“, „archive“, „lossless“)
|
||
|
||
👉 Screenshot geeignet: *Node-Einstellungen mit ausgewähltem Format und Input-Variable.*
|
||
|
||
#### Schritt 5 – Ausgabe speichern oder weiterverarbeiten
|
||
|
||
Nach erfolgreicher Ausführung gibt der Node eine JSON-Antwort mit der URL oder dem Pfad zur konvertierten Datei zurück, z. B.:
|
||
|
||
```json
|
||
{
|
||
"file_name": "thumbnail.webp",
|
||
"file_size": 24583,
|
||
"url": "https://storage.cloudconvert.com/tasks/uuid/thumbnail.webp"
|
||
}
|
||
```
|
||
|
||
Diese Datei kann anschließend in nachfolgenden Nodes weiterverarbeitet werden, z. B.:
|
||
- **Upload (Nextcloud / WebDAV / FTP)**
|
||
- **Postiz** für Social-Media-Uploads
|
||
- **Text Manipulation / Edit Image Plus** für Nachbearbeitung
|
||
|
||
👉 Screenshot geeignet: *Execution Data mit Rückgabe der konvertierten Datei.*
|
||
|
||
#### Praxisnutzen für Streamer und Content-Creator
|
||
- **Videoformat vereinheitlichen:** Konvertiere automatisch alle Clips nach MP4 oder WEBM, um Kompatibilitätsprobleme zu vermeiden.
|
||
- **Dateigrößen reduzieren:** Erzeuge kleinere Versionen für mobile Uploads oder Web-Vorschauen.
|
||
- **PDF-Erstellung:** Wandle automatisch Texte, Beschreibungen oder Transkripte in PDF-Dateien um.
|
||
- **Archivierung:** Komprimiere Clips und Untertitel automatisch zu ZIP-Archiven für deine Upload-Automation.
|
||
|
||
>[!IMPORTANT]
|
||
>CloudConvert arbeitet mit externen Servern.
|
||
>Wenn du ausschließlich interne Verarbeitung willst, setze später im UCC-Projekt auf lokale Tools wie **ffmpeg** oder **imagemagick** – diese werden in einem separaten Kapitel behandelt.
|
||
|
||
👉 Screenshot geeignet: *Vergleich Original- und Ausgabedatei (Größe und Format) nach erfolgreicher Konvertierung.*
|
||
|
||
### 6. n8n-nodes-elevenlabs
|
||
|
||
Der **ElevenLabs Node** integriert hochwertige KI-Stimmen in deine Automationen.
|
||
Er kann Texte in natürlich klingende Sprachausgaben umwandeln – ideal für Trailer, Stream-Intros, Benachrichtigungen oder Social-Clips.
|
||
So kannst du automatisiert Audio-Feedback, Voice-Overs oder kurze Sprechertexte generieren, ohne selbst aufnehmen zu müssen.
|
||
|
||
#### Schritt 1 – API-Schlüssel bei ElevenLabs anlegen
|
||
|
||
1. Öffne [https://elevenlabs.io](https://elevenlabs.io) und melde dich mit deinem Konto an.
|
||
2. Gehe zu **Profile → API Keys**.
|
||
3. Klicke auf **Create API Key**, gib einen Namen ein (z. B. `n8n-UCC`), und kopiere den generierten Schlüssel.
|
||
4. Bewahre den Key sicher auf – er ermöglicht Zugriff auf dein Kontingent für Text-zu-Sprache-Konvertierungen.
|
||
|
||
👉 Screenshot geeignet: *ElevenLabs Dashboard mit neu erzeugtem API Key.*
|
||
|
||
>[!TIP]
|
||
>Das kostenlose ElevenLabs-Konto enthält ein monatliches Kontingent an Sprachminuten.
|
||
>Reicht dieses nicht aus, kann später jederzeit ein höheres Paket aktiviert werden.
|
||
|
||
#### Schritt 2 – Credential in n8n anlegen
|
||
|
||
1. Öffne in n8n die **Credential-Verwaltung**.
|
||
2. Suche nach **ElevenLabs** und klicke auf **Neu**.
|
||
3. Trage den API-Key ein und speichere das Credential, z. B. unter dem Namen `elevenlabs_main`.
|
||
|
||
👉 Screenshot geeignet: *n8n Credential-Eintrag mit API Key-Feld.*
|
||
|
||
#### Schritt 3 – Node im Workflow einsetzen
|
||
|
||
Der **ElevenLabs Node** wird überall dort verwendet, **wo ein Text bereits vorliegt, der vertont werden soll** – etwa nach dem Text Manipulation Node oder einer KI-Ausgabe über OpenRouter.
|
||
Ziehe den Node **`n8n-nodes-elevenlabs`** in den Workflow direkt hinter die Textquelle.
|
||
|
||
👉 Screenshot geeignet: *Workflow mit Textquelle und ElevenLabs Node in Folge.*
|
||
|
||
#### Schritt 4 – Sprache und Stimme konfigurieren
|
||
|
||
1. Wähle dein Credential (`elevenlabs_main`).
|
||
2. Gib den Text ein oder verweise auf eine Variable, z. B. `{{$json.text}}`.
|
||
3. Wähle eine **Stimme** aus der Liste (z. B. `Rachel`, `Elli`, `Adam`).
|
||
4. Optional: Stimmeigenschaften anpassen
|
||
- **Stability** → Sprachgleichmäßigkeit (0–1)
|
||
- **Similarity Boost** → Natürlichkeit/Charakter (0–1)
|
||
- **Style** → Emotionslage (je nach Stimme verfügbar)
|
||
- **Output Format** → MP3, WAV oder M4A
|
||
|
||
👉 Screenshot geeignet: *Node-Konfiguration mit Textfeld, Stimme und Audioformat.*
|
||
|
||
>[!TIP]
|
||
>Für Trailer oder Ankündigungen eignen sich Stimmen mit hoher Stabilität (0.7–0.9).
|
||
>Für KI-Dialoge oder emotionale Passagen wirken niedrigere Werte (0.3–0.6) natürlicher.
|
||
|
||
#### Schritt 5 – Ausgabe und Weiterverarbeitung
|
||
|
||
Nach der Ausführung erzeugt der Node eine Audiodatei und gibt deren Pfad oder Base64-Inhalt im JSON aus, z. B.:
|
||
|
||
```json
|
||
{
|
||
"fileName": "stream_intro.mp3",
|
||
"fileType": "audio/mpeg",
|
||
"duration": 8.12,
|
||
"filePath": "/data/audio/stream_intro.mp3"
|
||
}
|
||
```
|
||
|
||
Diese Datei kann anschließend direkt an andere Nodes übergeben werden:
|
||
- **WAHA Node** → Sprachnachricht über WhatsApp senden
|
||
- **CloudConvert** → Umwandlung in ein anderes Format
|
||
- **File Upload** → Speicherung in Nextcloud oder lokalem Archiv
|
||
|
||
👉 Screenshot geeignet: *Execution Data mit erzeugtem Audio-File und Laufzeit.*
|
||
|
||
#### Praxisnutzen für Streamer und Content-Creator
|
||
- **Automatische Trailer:** Lass n8n eine kurze Ankündigung mit KI-Stimme erzeugen, sobald ein neuer Stream geplant ist.
|
||
- **Sprachwarnungen:** Kombiniere mit n8n-nodes-waha, um dir kritische Systemmeldungen als Sprachnachricht aufs Handy schicken zu lassen.
|
||
- **Voice-Over für Clips:** Verwandle Textbeschreibungen oder Highlights automatisch in gesprochene Kommentare.
|
||
- **Mehrsprachige Versionen:** In Kombination mit OpenRouter kann derselbe Text vorher übersetzt und dann in verschiedenen Sprachen vertont werden.
|
||
|
||
>[!IMPORTANT]
|
||
>Beachte die Nutzungsbedingungen von ElevenLabs:
|
||
>Sprachsynthesen dürfen nur für eigene oder lizenzfreie Inhalte verwendet werden.
|
||
>Das Verwenden fremder Stimmen ohne Zustimmung ist untersagt.
|
||
|
||
👉 Screenshot geeignet: *Vorher/Nachher-Vergleich – Text zu erzeugter Sprachausgabe.*
|
||
|
||
### 7. n8n-nodes-openrouter
|
||
|
||
Der **OpenRouter Node** ist das Herzstück aller KI-Integrationen in n8n.
|
||
Er ermöglicht die direkte Anbindung an das **OpenRouter-Netzwerk**, über das du Zugriff auf zahlreiche Large Language Models (LLMs) erhältst – darunter GPT-4, Claude, Mistral, Gemini und viele andere.
|
||
Damit kannst du Texte generieren, umformulieren, bewerten oder automatisch Inhalte erstellen lassen – ohne eigene API-Anbindung an jeden Anbieter einzeln verwalten zu müssen.
|
||
|
||
#### Schritt 1 – OpenRouter API-Key anlegen
|
||
|
||
1. Öffne [https://openrouter.ai/keys](https://openrouter.ai/keys).
|
||
2. Melde dich mit deinem Konto an oder registriere dich kostenlos.
|
||
3. Klicke auf **Create Key**, vergib eine Bezeichnung (z. B. `n8n-UCC`) und kopiere den angezeigten Schlüssel.
|
||
4. Bewahre den Key sicher in **Vaultwarden** (Kapitel 5) auf.
|
||
|
||
👉 Screenshot geeignet: *OpenRouter Dashboard mit generiertem API-Key.*
|
||
|
||
>[!TIP]
|
||
>Der API-Key gilt plattformweit. Du kannst damit mehrere Modelle ansprechen, ohne für jedes einzelne neue Zugangsdaten anlegen zu müssen.
|
||
|
||
#### Schritt 2 – Credential in n8n erstellen
|
||
|
||
1. Öffne in n8n die **Credential-Verwaltung**.
|
||
2. Suche nach **OpenRouter** und klicke auf **Neu**.
|
||
3. Trage deinen API-Key ein und benenne das Credential eindeutig (z. B. `openrouter_main`).
|
||
4. Speichern.
|
||
|
||
👉 Screenshot geeignet: *n8n Credential-Eintrag mit API-Key und benutzerdefiniertem Namen.*
|
||
|
||
#### Schritt 3 – Node in den Workflow einsetzen
|
||
|
||
Der **OpenRouter Node** wird überall dort verwendet, **wo Texte generiert, erweitert oder überprüft werden sollen**.
|
||
Das kann am Anfang eines Automationsprozesses stehen (z. B. KI-Titelvorschläge für Clips) oder als Nachbearbeitungsschritt nach einer Analyse oder Texterkennung.
|
||
Ziehe den Node **`n8n-nodes-openrouter`** an die gewünschte Stelle und verbinde ihn mit der Textquelle.
|
||
|
||
👉 Screenshot geeignet: *Workflow mit OpenRouter Node, der Textdaten vom vorherigen Schritt empfängt.*
|
||
|
||
#### Schritt 4 – Modell und Prompt konfigurieren
|
||
|
||
1. Wähle dein Credential (`openrouter_main`).
|
||
2. Unter **Model** kannst du zwischen verschiedenen KI-Systemen wählen, z. B.:
|
||
- `openai/gpt-4o-mini` – präzise, ausgewogen und ressourcenschonend
|
||
- `anthropic/claude-3-sonnet` – stark in Textverständnis und Kontextanalyse
|
||
- `mistralai/mistral-large` – schnell und für einfache Generierungen geeignet
|
||
3. Im Feld **Prompt** trägst du deinen Befehl oder dein Textziel ein.
|
||
Beispiel:
|
||
`"Formuliere den folgenden Clip-Titel prägnanter und füge drei passende Hashtags hinzu:\n{{$json.title}}"`
|
||
4. Optional kannst du **Temperatur**, **Max Tokens** und **Top P** anpassen, um Kreativität und Länge der Antworten zu steuern.
|
||
|
||
👉 Screenshot geeignet: *Node-Fenster mit Modellwahl und Beispiel-Prompt.*
|
||
|
||
>[!TIP]
|
||
>Für kurze, präzise Ergebnisse setze die Temperatur auf `0.4–0.6`.
|
||
>Für kreative Textvorschläge oder Social-Posts eignen sich Werte zwischen `0.8–1.0`.
|
||
|
||
#### Schritt 5 – Ausgabe und Weiterverarbeitung
|
||
|
||
Nach der Ausführung liefert der Node eine JSON-Ausgabe, z. B.:
|
||
|
||
```json
|
||
{
|
||
"model": "openai/gpt-4o-mini",
|
||
"response": "Bossfight-Highlight: Epischer Moment im Stream! #Gaming #Twitch #BratonienTV"
|
||
}
|
||
```
|
||
|
||
Diese Ausgabe kann direkt an den **Text Manipulation Node** weitergegeben oder mit **ElevenLabs** in gesprochene Sprache umgewandelt werden.
|
||
|
||
👉 Screenshot geeignet: *Execution Data mit generiertem KI-Text.*
|
||
|
||
#### Praxisnutzen für Streamer und Content-Creator
|
||
- **Automatische Titelvorschläge:** Lass KI-basierte Varianten deiner Clip-Titel oder YouTube-Beschreibungen erstellen.
|
||
- **Hashtag-Optimierung:** Generiere automatisch passende Hashtags für Plattformen wie TikTok, Instagram oder Threads.
|
||
- **Mehrsprachige Inhalte:** Übersetze automatisch Posts und Titel in Englisch, Französisch oder Spanisch.
|
||
- **Stilprüfung:** Lass OpenRouter prüfen, ob ein Text neutral, professionell oder werbewirksam formuliert ist.
|
||
- **KI-Kombination:** Verbinde OpenRouter direkt mit ElevenLabs, um erzeugte Texte sofort vertonen zu lassen.
|
||
|
||
>[!IMPORTANT]
|
||
>Achte auf das Modell-Limit und API-Kontingent. Einige Modelle (z. B. GPT-4o) erfordern OpenRouter-Credits.
|
||
>Die Preise werden transparent auf [https://openrouter.ai/models](https://openrouter.ai/models) angezeigt.
|
||
|
||
👉 Screenshot geeignet: *Vorher/Nachher-Vergleich eines automatisch verbesserten Video-Titels.*
|
||
|
||
---
|
||
|
||
## KI-Erweiterung des bestehenden Workflows
|
||
|
||
Der im Free-Kapitel erstellte Workflow **„Stream-Reminder + Social Post“** übernimmt bereits die Planung und Veröffentlichung automatischer Stream-Ankündigungen.
|
||
Er verarbeitet Streamdaten, erstellt daraus Beiträge und veröffentlicht sie über die angebundenen Plattformen.
|
||
|
||
In diesem Premium-Abschnitt erweitern wir genau diesen Workflow um **eine KI-basierte Textoptimierung** über den Node **`n8n-nodes-openrouter`**.
|
||
Damit kann n8n künftig selbstständig aus vorhandenen Daten (z. B. Streamtitel, Kategorie, Datum) automatisch ansprechende Formulierungen, passende Hashtags und prägnante Kurztexte erzeugen – vollautomatisch und ohne manuelles Eingreifen.
|
||
|
||
Diese KI-Erweiterung ersetzt keine bestehenden Bestandteile, sondern ergänzt sie direkt an einer definierten Stelle im bestehenden Ablauf:
|
||
- Der **OpenRouter-Node** wird **nach der Datenermittlung** eingefügt, um aus den Streaminformationen optimierte Social-Posts zu generieren.
|
||
- Die erzeugten Texte können anschließend direkt an die bestehenden Veröffentlichungs-Nodes übergeben werden.
|
||
|
||
👉 Screenshot geeignet: *Workflow-Übersicht mit zusätzlich eingefügtem OpenRouter-Node hinter der Datenermittlung.*
|
||
|
||
> [!NOTE]
|
||
> Der bestehende Aufbau bleibt unverändert.
|
||
> Wir fügen ausschließlich den OpenRouter-Node hinzu und konfigurieren ihn so, dass er bestehende Felder automatisch weiterverarbeitet und optimiert.
|
||
|
||
> [!TIP]
|
||
> Diese Erweiterung ist ein erster Schritt zur vollständigen KI-Automatisierung von Social-Media-Abläufen.
|
||
> Spätere Kapitel bauen darauf auf und erweitern die Integration um kontextabhängige Textgenerierung und mehrsprachige Posts.
|
||
|
||
### Schritt 1 – OpenRouter-Node hinzufügen und konfigurieren
|
||
|
||
Der **OpenRouter-Node** wird direkt hinter dem IF-Node *„Stream prüfen“* eingefügt.
|
||
Er erzeugt aus den Twitch-Daten (`title`, `startIso`, `kategroie`) automatisch einen passenden Social-Media-Post.
|
||
|
||
| Einstellung | Wert |
|
||
|--------------|------|
|
||
| **Credential to connect with** | *OpenRouter account* |
|
||
| **Operation** | *Chat* |
|
||
| **Model Name or ID** | `OpenAI: GPT-5` |
|
||
| **System Prompt** | `You are a helpful assistant...` *(Standardtext belassen)* |
|
||
| **Message** | Siehe unten |
|
||
| **Temperature** | `0.9` |
|
||
|
||
**Prompt im Feld „Message“:**
|
||
|
||
```
|
||
Erstelle einen Social-Media-Post auf Deutsch für folgendes Event.
|
||
Stil: freundlich, prägnant. Maximal 5 Hashtags mit größter Wirkung nach Analyse
|
||
|
||
Titel: {{$json["title"]}}
|
||
Datum: {{ $json.startIso }} -> Umwandeln in Datum und Uhrzeit in Lokale Deutsche Zeit. Du brauchst nur die Uhrzeit nennen.
|
||
Kategorie: {{ $json.kategroie }}
|
||
|
||
Gib nur den fertigen Posttext zurück.
|
||
```
|
||
|
||
👉 **Screenshot geeignet:** Node-Editor mit eingetragenem Prompt und Modell „OpenAI: GPT-5“
|
||
|
||
Der Node erzeugt eine einzige Ausgabevariable:
|
||
`{{$json["response"]}}` – sie enthält den vollständigen Text, der anschließend an die If-Prüfung übergeben wird.
|
||
|
||
|
||
### Schritt 2 – KI-Antwort prüfen
|
||
|
||
Direkt hinter dem OpenRouter-Node wird ein **IF-Node** eingefügt, um leere Antworten abzufangen.
|
||
|
||
| Feld | Wert |
|
||
|------|------|
|
||
| **Left Value** | `={{ $json.response }}` |
|
||
| **Operator** | *String → Is Empty* |
|
||
|
||
Damit prüft n8n, ob das Feld `response` leer ist.
|
||
Nur wenn es wirklich Text enthält, läuft der KI-Zweig weiter.
|
||
|
||
👉 **Screenshot geeignet:** IF-Node mit Bedingung „response is empty“
|
||
|
||
- **TRUE (leer):** → *Download a file* (Fallback)
|
||
- **FALSE (Text vorhanden):** → *Edit Fields* (KI-Text übernehmen)
|
||
|
||
|
||
### Schritt 3 – KI-Text übernehmen
|
||
|
||
Der **Set-Node „Edit Fields“** wandelt die KI-Antwort in das vom Rest des Workflows genutzte Feld `postText` um.
|
||
|
||
| Feldname | Wert |
|
||
|-----------|------|
|
||
| **postText** | `={{ $json.response }}` |
|
||
|
||
Damit erhält der nächste Node dieselbe Datenstruktur wie zuvor.
|
||
|
||
👉 **Screenshot geeignet:** Node-Editor mit Feldzuweisung `postText = {{$json.response}}`
|
||
|
||
|
||
### Schritt 4 – Fallback-Zweig
|
||
|
||
Wenn der IF-Node auf „TRUE“ schaltet (also keine KI-Antwort vorhanden ist),
|
||
führt der Workflow den bekannten Pfad aus dem Free-Kapitel weiter:
|
||
|
||
- **Nextcloud-Node „Download a file“** lädt `posts.txt`.
|
||
- **Code-Node „Posttext auswählen“** wählt einen passenden Text oder Fallback-Satz.
|
||
|
||
👉 **Screenshot geeignet:** TRUE-Pfad mit Nextcloud- und Code-Node
|
||
|
||
|
||
### Schritt 5 – Merge-Node
|
||
|
||
Der **Merge-Node** führt die beiden Pfade (KI und Fallback) wieder zusammen,
|
||
sodass der folgende *X-Node* immer ein gültiges Feld `postText` erhält.
|
||
|
||
| Einstellung | Wert |
|
||
|--------------|------|
|
||
| **Mode** | *Append* |
|
||
| **Eingänge** | *2* |
|
||
|
||
Damit werden die Ausgaben beider Pfade zusammengeführt.
|
||
Da beide Nodes (`Edit Fields` und `Posttext auswählen`) dasselbe Feld `postText` besitzen,
|
||
übernimmt n8n automatisch den jeweils vorhandenen Wert — unabhängig davon, welcher Pfad aktiv war.
|
||
|
||
👉 **Screenshot geeignet:** Merge-Node mit beiden Eingängen (1 = Fallback, 2 = KI-Zweig)
|
||
|
||
> [!NOTE]
|
||
> Durch diesen Aufbau bleibt der Workflow stabil:
|
||
> - Fällt der KI-Dienst aus → Fallback aus Nextcloud
|
||
> - Antwort vorhanden → KI-Text aus OpenRouter
|
||
> Beide Fälle liefern dasselbe Datenformat für den abschließenden Veröffentlichungs-Node.
|
||
|
||
### Schritt 6 – Post veröffentlichen
|
||
|
||
Der **X-Node „Post veröffentlichen“** nutzt schließlich das Feld:
|
||
|
||
```
|
||
={{ $json.postText }}
|
||
```
|
||
|
||
Dadurch bleibt der Workflow robust:
|
||
- Wenn die KI funktioniert, wird ihr Text gepostet.
|
||
- Wenn sie ausfällt, nutzt der Workflow automatisch den bestehenden Zufallstext.
|
||
|
||
> [!TIP]
|
||
> Diese Integration erhöht die Automatisierung, ohne Abhängigkeiten zu erzwingen.
|
||
> Sie lässt sich später auf weitere Plattformen (z. B. Discord, Threads, WhatsApp) erweitern,
|
||
> indem dieselbe Logik für zusätzliche „Publish“-Nodes übernommen wird. |