Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kapitel 10/Premium Rohtext.md hinzugefügt

Browse Source
This commit is contained in:
Thomas Dannenberg
2025-10-11 18:38:17 +00:00
parent 631ad01875
commit c560446e82
1 changed files with 679 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

679
Kapitel 10/Premium Rohtext.md Normal file
View File

@@ -0,0 +1,679 @@
# 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.*
### 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.
Sobald Kapitel [X] verfügbar ist, kann diese durch die eigene UCC-Installation ersetzt werden.
#### 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.*
---