snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-docs/l/de/user-guide/workflows/capabilities/send-emails-from-workflows.mdx

@@ -0,0 +1,167 @@
+---
+title: E-Mails über Workflows senden
+description: Senden Sie personalisierte E-Mails automatisch mit Workflow-Aktionen.
+---
+
+Senden Sie automatisch E-Mails, wenn bestimmte Ereignisse in Ihrem CRM auftreten—heißen Sie neue Kontakte willkommen, führen Sie Nachfassaktionen bei Verkaufschancen durch oder benachrichtigen Sie Teammitglieder.
+
+## Voraussetzungen
+
+Bevor Sie E-Mails aus Workflows senden können:
+
+1. Verbinden Sie ein E-Mail-Konto unter **Einstellungen → Konten**
+2. Stellen Sie sicher, dass für das Konto Sendeberechtigungen aktiviert sind
+
+## Grundlegender E-Mail-Workflow
+
+### Beispiel: Willkommens-E-Mail für neue Kontakte
+
+**Ziel**: Senden Sie eine Willkommens-E-Mail, wenn eine neue Person zum CRM hinzugefügt wird.
+
+**Einrichtung**:
+
+1. **Workflow erstellen**: Gehen Sie zu **Einstellungen → Workflows** und klicken Sie auf **+ Neuer Workflow**
+
+2. **Auslöser hinzufügen**: Wählen Sie **Datensatz wird erstellt** → **Personen**
+
+3. **Aktion "E-Mail senden" hinzufügen**:
+   * Klicken Sie auf **+**, um eine Aktion hinzuzufügen
+   * Wählen Sie **E-Mail senden**
+   * Konfigurieren Sie die E-Mail:
+
+| Feld        | Wert                                   |
+| ----------- | -------------------------------------- |
+| **An**      | `{{trigger.object.email}}`             |
+| **Betreff** | `Willkommen bei {{Your Company Name}}` |
+| **Inhalt**  | `Hi {{trigger.object.firstName}}, ...` |
+
+4. **Testen und aktivieren**: Testen Sie mit einem Beispieldatensatz und aktivieren Sie anschließend
+
+## Variablen in E-Mails verwenden
+
+Verweisen Sie mit der Syntax `{{variable}}` auf Daten aus vorherigen Schritten:
+
+```text
+Hi {{trigger.object.firstName}},
+
+Thank you for connecting with us!
+
+Your company, {{trigger.object.company.name}}, is now in our system.
+
+Best regards,
+The Team
+```
+
+### Verfügbare Variablen aus Auslösern
+
+| Auslöser-Typ                        | Häufige Variablen                      |
+| ----------------------------------- | -------------------------------------- |
+| **Datensatz erstellt/aktualisiert** | `{{trigger.object.fieldName}}`         |
+| **Manuell**                         | `{{trigger.selectedRecord.fieldName}}` |
+| **Webhook**                         | `{{trigger.body.fieldName}}`           |
+
+## Erweitert: Bedingte E-Mails
+
+### Beispiel: Unterschiedliche E-Mails basierend auf der Lead-Quelle
+
+**Ziel**: Senden Sie unterschiedliche Willkommens-E-Mails, je nachdem, woher der Lead stammt.
+
+**Einrichtung**:
+
+1. **Auslöser**: Datensatz wird erstellt (Personen)
+
+2. **Aktion "Filter" hinzufügen**:
+   * Bedingung: `{{trigger.object.source}}` ist gleich `"Website"`
+   * Wenn wahr → mit der Website-Willkommens-E-Mail fortfahren
+
+3. **Verzweigung für andere Quellen**:
+   * Erstellen Sie parallele Verzweigungen für verschiedene Quellen
+   * Jede Verzweigung hat ihre eigene Aktion "E-Mail senden"
+
+## E-Mails an mehrere Empfänger senden
+
+### Beispiel: Team benachrichtigen, wenn ein Deal abgeschlossen wird
+
+**Ziel**: Senden Sie E-Mails an den Vertriebsmitarbeiter und dessen Manager, wenn eine Verkaufschance gewonnen wird.
+
+**Einrichtung**:
+
+1. **Auslöser**: Datensatz wird aktualisiert (Chancen, Phase = "Closed Won")
+
+2. **Datensätze durchsuchen**: Finden Sie den Manager des Eigentümers der Verkaufschance
+
+3. **E-Mail senden #1**: An den Eigentümer der Verkaufschance
+   * An: `{{trigger.object.owner.email}}`
+   * Betreff: `Glückwunsch zum Abschluss von {{trigger.object.name}}!`
+
+4. **E-Mail senden #2**: An den Manager
+   * An: `{{searchRecords.manager.email}}`
+   * Betreff: `Deal gewonnen: {{trigger.object.name}}`
+
+## Geplante Nachfass-E-Mails
+
+### Beispiel: 3 Tage nach der Besprechung nachfassen
+
+**Ziel**: Senden Sie 3 Tage, nachdem eine Besprechung protokolliert wurde, eine Nachfass-E-Mail.
+
+**Einrichtung**:
+
+1. **Auslöser**: Datensatz wird erstellt (Aktivitäten, Typ = "Besprechung")
+
+2. **Verzögerungsaktion**: 3 Tage warten
+
+3. **E-Mail senden**:
+   * An: Besprechungsteilnehmer
+   * Betreff: Rückmeldung zu unserem Gespräch
+   * Text: Verweisen Sie auf Besprechungsdetails aus dem Auslöser
+
+## E-Mail-Anhänge
+
+Sie können Dateien an E-Mails anhängen, die von Workflows gesendet werden. Der Anhang ist eine statische Datei, die Sie beim Konfigurieren des Workflows hochladen.
+
+### So fügen Sie einen Anhang hinzu
+
+1. Klicken Sie in der Aktion **E-Mail senden** auf die Schaltfläche **Anhänge**
+2. Klicken Sie, um eine Datei von Ihrem Computer hochzuladen
+3. Die Datei wird allen E-Mails, die durch diese Aktion gesendet werden, angehängt
+
+### Häufige Anwendungsfälle
+
+| Anwendungsfall                  | Beispieldatei                     |
+| ------------------------------- | --------------------------------- |
+| **Willkommens-E-Mails**         | Unternehmensbroschüre (PDF)       |
+| **Onboarding-Sequenzen**        | Leitfaden für die ersten Schritte |
+| **Vertriebs-Nachverfolgungen**  | Produktkatalog oder Preisliste    |
+| **Veranstaltungsbestätigungen** | Veranstaltungsdetails oder Agenda |
+
+<Note>
+Anhänge sind statisch—dieselbe Datei wird an alle Empfänger gesendet. Für dynamische Dokumente (wie personalisierte Anführungszeichen), generieren und fügen Sie Dateien mit einer [Logic Funktion](/l/de/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty).
+</Note>
+
+## Beste Praktiken
+
+### E-Mail-Inhalt
+
+* Formulieren Sie Betreffzeilen prägnant und relevant
+* Personalisieren Sie mit dem Namen des Empfängers
+* Fügen Sie eine klare Handlungsaufforderung hinzu
+* Testen Sie E-Mails vor der Aktivierung
+
+### Zustellbarkeit
+
+* Senden Sie nicht zu viele E-Mails in zu kurzer Zeit
+* Verwenden Sie professionelle E-Mail-Signaturen
+* Vermeiden Sie Spam-Trigger-Wörter
+* Stellen Sie sicher, dass Marketing-E-Mails eine Abmeldemöglichkeit enthalten
+
+### Fehlerbehebung
+
+* Überprüfen Sie, dass das E-Mail-Konto verbunden und aktiv ist
+* Prüfen Sie, ob die E-Mail-Adresse des Empfängers gültig ist
+* Überprüfen Sie Workflow-Ausführungen auf Fehlermeldungen
+* Testen Sie zunächst mit Ihrer eigenen E-Mail-Adresse
+
+## Verwandt
+
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/de/user-guide/workflows/capabilities/use-branches-in-workflows.mdx

@@ -0,0 +1,88 @@
+---
+title: Verzweigungen in Workflows verwenden
+description: Verstehen Sie, wie Verzweigungen funktionieren und wie Sie steuern, welcher Pfad ausgeführt wird.
+---
+
+## Wie Verzweigungen funktionieren
+
+Im Workflow-Editor können Sie mehrere Pfade (Verzweigungen) erstellen, die von einem einzelnen Knoten ausgehen. So können Sie komplexe Automatisierungen mit unterschiedlichen Ergebnissen erstellen.
+
+**Wichtig**: Wenn ein Workflow ausgeführt wird, **werden standardmäßig alle Verzweigungen parallel ausgeführt**. Es gibt keine integrierte "if/else"-Logik, um eine Verzweigung gegenüber einer anderen auszuwählen—jeder Pfad wird gleichzeitig ausgeführt.
+
+## Steuern, welche Verzweigung ausgeführt wird
+
+Um basierend auf bestimmten Bedingungen nur eine Verzweigung auszuführen, **fügen Sie am Anfang jeder Verzweigung einen Filter-Knoten hinzu**.
+
+### Beispiel-Setup
+
+1. Erstellen Sie Ihren Workflow mit mehreren Verzweigungen, die von einem einzelnen Knoten ausgehen
+2. Fügen Sie in jeder Verzweigung als ersten Schritt einen **Filter**-Knoten hinzu
+3. Legen Sie für jeden Filter Bedingungen fest, um zu bestimmen, wann diese Verzweigung fortgesetzt werden soll
+4. Nur die Verzweigung(en), deren Filterbedingungen erfüllt sind, wird/werden weiter ausgeführt
+
+### Wie Filter funktionieren
+
+* Wenn die Filterbedingung **erfüllt** ist: Die Verzweigung wird weiter ausgeführt
+* Wenn die Filterbedingung **nicht erfüllt** ist: Die Verzweigung stoppt am Filter-Knoten
+
+Dadurch entsteht effektiv eine bedingte Logik, bei der basierend auf Ihren Daten nur die passende Verzweigung ausgeführt wird.
+
+## Beispiel: Routing nach Dealgröße
+
+**Szenario**: Wenn ein Deal abgeschlossen wird, senden Sie je nach Dealgröße unterschiedliche Benachrichtigungen.
+
+1. **Auslöser**: Verkaufschance aktualisiert (Phase = Closed Won)
+2. **Verzweigung 1**: Filter für Betrag > $10.000 → Slack-Nachricht an #big-deals senden
+3. **Verzweigung 2**: Filter für Betrag ≤ $10.000 → E-Mail an den Vertriebsleiter senden
+
+Beide Verzweigungen starten, aber nur diejenige, die dem Dealbetrag entspricht, wird über ihren Filter hinaus fortgesetzt.
+
+## Verzweigungen erstellen
+
+<Note>
+Um aus einem bestehenden Schritt eine neue Verzweigung zu erstellen, klicken Sie im Schritt auf die Schaltfläche **+** und fügen Sie Ihre Aktion hinzu. Sie können mehrere Verzweigungen hinzufügen, indem Sie **+** mehrmals klicken.
+</Note>
+
+1. Wählen Sie im Workflow-Editor den Schritt aus, von dem Sie verzweigen möchten
+2. Klicken Sie auf **+**, um eine Aktion hinzuzufügen
+3. Dadurch wird eine Verzweigung erstellt
+4. Klicken Sie im selben Schritt erneut auf **+**, um weitere Verzweigungen zu erstellen
+5. Jede Verzweigung kann ihre eigene Abfolge von Aktionen haben
+
+## Verzweigungen wieder zusammenführen
+
+Nachdem parallele Verzweigungen ihre Arbeit abgeschlossen haben, können Sie sie wieder zu einem einzelnen Pfad zusammenführen:
+
+1. Schließen Sie Ihre verzweigten Aktionen ab
+2. Fügen Sie einen neuen Schritt hinzu, der nach allen Verzweigungen ausgeführt werden soll
+3. Ziehen Sie eine Verbindung vom letzten Schritt jeder Verzweigung zu diesem neuen Schritt
+4. Der zusammengeführte Schritt wartet, bis alle verbundenen Verzweigungen abgeschlossen sind, bevor er ausgeführt wird
+
+### Beispiel: Erst verarbeiten, dann benachrichtigen
+
+```
+Trigger
+   │
+   ├── Branch A: Update Customer Record
+   │
+   └── Branch B: Create Support Ticket
+
+       ↘  ↙
+
+   Merged Step: Send Confirmation Email
+```
+
+Die Bestätigungs-E-Mail wird sowohl nach der Kundenaktualisierung als auch nach der Ticketerstellung versendet.
+
+## Beste Praktiken
+
+* Verwenden Sie am Anfang von Verzweigungen immer **Filter-Knoten**, wenn Sie eine bedingte Ausführung möchten
+* Halten Sie Verzweigungsbedingungen **gegenseitig ausschließend**, um doppelte Aktionen zu vermeiden
+* Testen Sie Ihre Workflows mit unterschiedlichen Daten, um sicherzustellen, dass die richtigen Verzweigungen ausgeführt werden
+* **Benennen Sie Verzweigungsschritte um** und verwenden Sie aussagekräftige Bezeichnungen, damit klar ist, was jeder Pfad tut
+* **Verzweigungen zusammenführen**, wenn Sie nach paralleler Verarbeitung eine abschließende Aktion benötigen
+
+## Verwandt
+
+* [Workflows-FAQ](/l/de/user-guide/workflows/how-tos/need-more-help/workflows-faq) — Antworten zur parallelen Ausführung
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions) — verfügbare Aktionen für Verzweigungen

packages/twenty-docs/l/de/user-guide/workflows/capabilities/use-iterator.mdx

@@ -0,0 +1,183 @@
+---
+title: Iterator verwenden
+description: Durchlaufen Sie Arrays von Datensätzen, um Aktionen für jedes Element auszuführen.
+---
+
+Mit Iterator können Sie ein Array von Datensätzen durchlaufen und für jeden Datensatz Aktionen ausführen. Es ist unverzichtbar für Workflows, die mehrere Datensätze verarbeiten müssen, die von der Aktion „Datensätze suchen“ zurückgegeben oder über Webhooks empfangen werden.
+
+## Wann Sie Iterator verwenden sollten
+
+| Szenario                       | Beispiel                                                |
+| ------------------------------ | ------------------------------------------------------- |
+| **Suchergebnisse verarbeiten** | E-Mail an jede gefundene Person senden                  |
+| **Webhook-Arrays verarbeiten** | Der Reihe nach für jedes Element Datensätze erstellen   |
+| **Massenaktualisierungen**     | Mehrere Datensätze mit berechneten Werten aktualisieren |
+| **Benachrichtigungen**         | Mehrere Personen über ein Ereignis benachrichtigen      |
+
+## Iterator verstehen
+
+Iterator erwartet ein **Array** als Eingabe. Dann:
+
+1. Nimmt das erste Element aus dem Array
+2. Führt alle Aktionen im Iterator mit diesem Item aus
+3. Wechselt zum nächsten Element
+4. Wiederholt sich, bis alle Elemente verarbeitet sind
+
+### Auswählen des Arrays, über das iteriert werden soll
+
+Die meisten Array-Quellen (Search Records, ein Webhook-Array-Feld, ein Bulk Manual Trigger) können direkt im Variablen-Auswahldialog ausgewählt werden.
+
+Wenn ein **Code**- oder **Logic Function**-Schritt ein *Top-Level-Array* zurückgibt, erscheint dessen Ausgabe im Variablen-Auswahldialog als indizierte Einträge (`0`, `1`, `2`, …). Um über das Array als Ganzes zu iterieren, wähle für diesen Schritt die Option **Whole list** – der Iterator leitet dann die Struktur jedes Elements automatisch aus der Liste ab.
+
+## Grundlegende Einrichtung
+
+### Beispiel: E-Mail an alle in den Suchergebnissen
+
+**Ziel**: Alle Kontakte in einem bestimmten Unternehmen finden und jedem eine personalisierte E-Mail senden.
+
+### Schritt 1: Nach Datensätzen suchen
+
+1. Fügen Sie die Aktion **Datensätze suchen** hinzu
+2. Objekt: **Personen**
+3. Filter: Unternehmen ist gleich "Acme Inc"
+4. Dadurch wird ein Array von Personen zurückgegeben
+
+### Schritt 2: Prüfen, ob Ergebnisse vorhanden sind
+
+1. Fügen Sie eine **Filter**-Aktion hinzu
+2. Bedingung: `{{searchRecords.length}}` ist größer als 0
+3. Dies verhindert Iterator-Fehler bei leeren Ergebnissen
+
+### Schritt 3: Iterator hinzufügen
+
+1. Fügen Sie eine **Iterator**-Aktion hinzu
+2. Array-Eingabe: Wählen Sie `{{searchRecords}}` aus
+3. Dadurch wird eine Schleife erstellt
+
+### Schritt 4: Aktionen im Iterator hinzufügen
+
+Aktionen, die nach dem Iterator platziert werden, werden für jedes Element ausgeführt:
+
+1. Füge **E-Mail senden** Aktion (innerhalb des Iterators) hinzu
+2. An: `{{iterator.currentItem.email}}`
+3. Betreff: Hallo `{{iterator.currentItem.firstName}}`!
+4. Text: Personalisierte Nachricht unter Verwendung der Felder des aktuellen Elements
+
+### Ergebnis
+
+Wenn Datensätze suchen 5 Personen zurückgibt, führt der Iterator Folgendes aus:
+
+* Sendet E-Mail an Person 1
+* Sendet E-Mail an Person 2
+* ... setzt dies für alle 5 fort
+
+## Zugriff auf Daten des aktuellen Elements
+
+Im Iterator verwenden Sie `{{iterator.currentItem}}`, um auf den aktuellen Datensatz zuzugreifen:
+
+| Variable                                | Beschreibung                                      |
+| --------------------------------------- | ------------------------------------------------- |
+| `{{iterator.currentItem}}`              | Das vollständige Objekt des aktuellen Datensatzes |
+| `{{iterator.currentItem.id}}`           | Datensatz-ID                                      |
+| `{{iterator.currentItem.email}}`        | E-Mail-Feld                                       |
+| `{{iterator.currentItem.company.name}}` | Name des zugehörigen Unternehmens                 |
+| `{{iterator.index}}`                    | Aktuelle Position im Array (0-basiert)            |
+
+Im Variablen-Auswahldialog kannst du entweder in ein bestimmtes Feld des aktuellen Elements hineinnavigieren oder **Use the whole item** auswählen, um auf das gesamte aktuelle Element zu verweisen (`{{iterator.currentItem}}`). Das Auswählen des gesamten Elements ist praktisch, wenn du einen vollständigen Datensatz direkt an einen nachgelagerten Schritt übergeben möchtest, anstatt ihn Feld für Feld neu aufzubauen.
+
+## Häufige Muster
+
+### Mehrere Datensätze aktualisieren
+
+**Ziel**: Alle überfälligen Aufgaben als "Late" markieren
+
+```
+1. Search Records (Tasks, Due Date < Today, Status ≠ Completed)
+2. Filter (length > 0)
+3. Iterator (searchRecords)
+   └── Update Record
+       - Object: Tasks
+       - Record: {{iterator.currentItem.id}}
+       - Status: Late
+```
+
+### Datensätze aus Array erstellen
+
+**Ziel**: Ein Webhook erhält eine Bestellung mit mehreren Positionen; für jede Position einen Datensatz erstellen
+
+```
+1. Webhook Trigger (receives items array)
+2. Filter (items.length > 0)
+3. Iterator (trigger.body.items)
+   └── Create Record
+       - Object: Order Items
+       - Name: {{iterator.currentItem.name}}
+       - Quantity: {{iterator.currentItem.qty}}
+       - Related Order: {{trigger.body.orderId}}
+```
+
+### Bedingte Verarbeitung innerhalb der Schleife
+
+**Ziel**: Nur E-Mails an Kontakte mit gültigen E-Mail-Adressen senden
+
+```
+1. Search Records (People)
+2. Iterator (searchRecords)
+   └── Filter (currentItem.email is not empty)
+       └── Send Email
+           - To: {{iterator.currentItem.email}}
+```
+
+## Fehlerbehebung
+
+### "Iterator erwartet ein Array"
+
+**Ursache**: Sie haben einen einzelnen Datensatz statt eines Arrays übergeben.
+
+**Lösung**: Stellen Sie sicher, dass Sie das Ergebnis von Datensätze suchen oder ein Array-Feld übergeben, nicht einen einzelnen Datensatz.
+
+```
+✅ Correct: {{searchRecords}}
+❌ Wrong: {{searchRecords[0]}}
+```
+
+### Iterator wird nicht ausgeführt
+
+**Ursache**: Das Array ist leer.
+
+**Lösung**: Fügen Sie vor dem Iterator einen Filter hinzu, um die Array-Länge zu prüfen:
+
+```
+Filter: {{searchRecords.length}} > 0
+```
+
+### Aktionen werden zu oft ausgeführt
+
+**Ursache**: Datensätze suchen hat mehr Datensätze zurückgegeben als erwartet.
+
+**Lösung**:
+
+* Fügen Sie der Aktion „Datensätze suchen“ spezifischere Filter hinzu
+* Legen Sie für die Aktion „Datensätze suchen“ ein Limit fest (max. 200)
+* Fügen Sie innerhalb des Iterators einen Filter für zusätzliche Bedingungen hinzu
+
+## Leistungsaspekte
+
+* **Credit-Verbrauch**: Jede Iteration verbraucht Credits für ihre Aktionen
+* **Zeit**: Große Arrays benötigen länger für die Verarbeitung
+* **Grenzwerte**: Ziehen Sie für sehr große Vorgänge eine Stapelverarbeitung in Betracht
+* **Ratenlimits**: Externe API-Aufrufe können bei vielen Iterationen auf Ratenlimits stoßen
+
+## Beste Praktiken
+
+1. **Prüfen Sie stets die Array-Länge** vor dem Iterator, um Fehler zu vermeiden
+2. **Fügen Sie Filter innerhalb von Schleifen hinzu**, wenn nicht alle Elemente verarbeitet werden müssen
+3. **Benennen Sie Ihren Iterator-Schritt um**, um zu beschreiben, was durchlaufen wird
+4. **Testen Sie mit kleinen Arrays**, bevor Sie große Datenmengen verarbeiten
+5. **Überwachen Sie Workflow-Ausführungen**, um sicherzustellen, dass Iterationen wie erwartet abgeschlossen werden
+
+## Verwandt
+
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [So verwenden Sie Verzweigungen](/l/de/user-guide/workflows/capabilities/use-branches-in-workflows)
+* [Workflows-FAQ](/l/de/user-guide/workflows/how-tos/need-more-help/workflows-faq)

packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-actions.mdx

@@ -0,0 +1,332 @@
+---
+title: Workflow-Aktionen
+description: Erfahren Sie mehr über die in Twenty-Workflows verfügbaren Aktionen.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+## Über Aktionen
+
+Aktionen definieren, was nach dem Auslösen passiert. Sie können mehrere Aktionen verketten, um komplexe Automatisierungen zu erstellen.
+
+<Tip>
+* Verwenden Sie die Variablenauswahl (klicken Sie auf das Symbol `(x+)`), um verfügbare Daten aus vorherigen Schritten zu durchsuchen
+* Bewegen Sie den Mauszeiger über ein beliebiges Eingabefeld, um zu sehen, aus welchem Schritt eine Variable stammt — hilfreich, wenn dasselbe Feld (z. B. ID) in mehreren vorherigen Schritten vorhanden ist
+* Geben Sie jeder Aktion einen aussagekräftigen Namen, um die Wartung zu erleichtern
+</Tip>
+
+## Datensatz-Aktionen
+
+<img src="/images/user-guide/workflows/workflow_actions.png" style={{width:'100%'}} />
+
+### Datensatz erstellen
+
+Fügt einem ausgewählten Objekt einen neuen Datensatz hinzu.
+
+**Konfiguration**:
+
+* Wählen Sie das Zielobjekt aus
+* Füllen Sie die erforderlichen und optionalen Felder aus
+* Verwenden Sie Daten aus vorherigen Schritten oder geben Sie Werte manuell ein, um Felder auszufüllen
+
+**Ausgabe**: Die neu erstellten Datensatzdaten stehen in nachfolgenden Schritten zur Verfügung.
+
+### Datensatz aktualisieren
+
+Ändert einen bestehenden Datensatz in einem ausgewählten Objekt.
+
+<img src="/images/user-guide/workflows/update_record.png" style={{width:'100%'}} />
+
+**Konfiguration**:
+
+* Wählen Sie das Zielobjekt aus
+* Wählen Sie den spezifischen Datensatz zum Aktualisieren aus.
+  * Sie können entweder einen festen Datensatz auswählen, indem Sie das Dropdown-Menü verwenden, das alle verfügbaren Datensätze anzeigt.
+  * Oder Sie lassen den Datensatz dynamisch auswählen, indem Sie einen in einem vorherigen Schritt gefundenen Datensatz über `(x+)` angeben. In diesem Schritt können Sie den Datensatz nicht anhand verschiedener Kriterien suchen. Wenn Sie den Datensatz noch nicht identifiziert haben, fügen Sie vor diesem Schritt `Update Record` einen Schritt `Search Record` hinzu.
+* Wählen Sie zu ändernde Felder aus und geben Sie neue Werte ein
+
+**Ausgabe**: Die aktualisierten Datensatzdaten stehen in nachfolgenden Schritten zur Verfügung.
+
+### Datensatz löschen
+
+Entfernt einen Datensatz aus einem ausgewählten Objekt.
+
+**Konfiguration**:
+
+* Wählen Sie das Zielobjekt aus
+* Wählen Sie den spezifischen Datensatz zum Löschen aus
+
+**Ausgabe**: Die gelöschten Datensatzdaten stehen in nachfolgenden Schritten zur Verfügung.
+
+### Datensätze durchsuchen
+
+Findet Datensätze innerhalb eines ausgewählten Objekts mittels Filterkonditionen.
+
+**Konfiguration**:
+
+* Wählen Sie das Objekt aus, das Sie durchsuchen möchten.
+* Legen Sie Filterkriterien fest, um Ergebnisse einzugrenzen.
+* Konfigurieren Sie Sortierung und Begrenzungen.
+
+**Ausgabe**: Gibt passende Datensätze zurück, die in nachfolgenden Schritten verwendet werden können.
+
+<Note>
+**Limit**: Search Records gibt maximal **200 Datensätze** zurück. Wenn Sie mehr verarbeiten müssen, fügen Sie spezifische Filter hinzu, um die Ergebnisse zu reduzieren, oder verwenden Sie geplante Workflows, um stapelweise zu verarbeiten.
+</Note>
+
+**Best Practice**: Verwenden Sie [Verzweigungen](/l/de/user-guide/workflows/capabilities/workflow-branches) nach dem Durchsuchen von Datensätzen, um "gefunden" vs "nicht gefunden" Szenarien zu behandeln.
+
+### Datensatz einfügen oder aktualisieren
+
+Erstellt einen neuen Datensatz oder aktualisiert einen vorhandenen anhand von Übereinstimmungskriterien. Das ist hilfreich, wenn Sie nicht sicher sind, ob ein Datensatz bereits vorhanden ist.
+
+<img src="/images/user-guide/workflows/upsert_double_identifier.png" style={{width:'100%'}} />
+
+**Konfiguration**:
+
+* Wählen Sie das Zielobjekt aus
+* Beachten Sie, welche Felder für den Abgleich verwendet werden können: E-Mail für Personen, Domain für Unternehmen, ID für beliebige Objekte oder jedes Feld, das als eindeutig markiert ist. Unten müssen Sie mindestens eines davon ausfüllen.
+* Füllen Sie die Feldwerte aus. Vergessen Sie nicht, mindestens einen der eindeutigen Bezeichner auszufüllen.
+
+<Note>
+**Der Abgleich funktioniert in der Regel noch besser, wenn Sie nur einen eindeutigen Bezeichner hinzufügen.** Beispielsweise werden im untenstehenden Screenshot Unternehmen anhand ihrer Domain abgeglichen. Die ID ist nicht unbedingt erforderlich.
+</Note>
+
+<img src="/images/user-guide/workflows/upsert_simple_identifier.png" style={{width:'100%'}} />
+
+* Verwenden Sie Daten aus vorherigen Schritten, um Felder zu füllen
+
+**So funktioniert**:
+
+1. Sucht nach einem Datensatz, der Ihren Kriterien entspricht
+2. Wenn gefunden → Aktualisiere den vorhandenen Eintrag
+3. Wenn nicht gefunden → Erstelle einen neuen Datensatz
+
+**Ausgabe**: Die erstellten oder aktualisierten Datensatzdaten sind für die Verwendung in folgenden Schritten verfügbar.
+
+## Flow-Aktionen
+
+### Iterator
+
+**Schleppt sich durch ein Array von Datensätzen** aus einem vorherigen Schritt, so dass du Aktionen auf jedem Datensatz einzeln ausführen kannst.
+
+**Konfiguration**:
+
+* Wählen Sie das Array der Datensätze aus einem vorherigen Schritt (z.B. Ergebnisse aus Suchdatensätzen, aus einem manuellen Trigger mit Bulk-Verfügbarkeit, aus einem Codeknoten). Wenn ein Code- oder Logikfunktions-Schritt ein Top-Level-Array zurückgibt, wählen Sie die Option **Whole list**, um über die gesamte Ausgabe zu iterieren.
+* Definieren Sie die Aktionen, die für jeden Datensatz in der Schleife ausgeführt werden sollen.
+
+<Note>
+- Sie können mehrere Aktionen innerhalb eines Iterators hinzufügen.
+- Wenn Sie Zweige innerhalb eines Iterators verwenden, stellen Sie sicher, dass sich der letzte Schritt jedes Zweiges mit dem Iterator verbindet, um die Schleife zu schließen.
+</Note>
+
+* Zugriff auf `Aktuelle Item` Felder: Um Felder aus dem aktuell verarbeiteten Datensatz zu verwenden, klicke auf den **Iterator** Schritt, dann wähle **Aktuelles Iterator**. Die Liste der verfügbaren Felder aus diesem Datensatz wird angezeigt und kann für die Verwendung in folgenden Aktionen ausgewählt werden. Sie können auch **Use the whole item** auswählen, um das gesamte aktuelle Element an einen nachgelagerten Schritt zu übergeben.
+
+<VimeoEmbed videoId="1146577247" title="Video-Demo" />
+
+### Filter
+
+Filtert Datensätze basierend auf bestimmten Bedingungen, so dass nur Datensätze, die die Kriterien erfüllen, durchlaufen können.
+
+**Konfiguration**:
+
+* Datensatz zum filtern auswählen
+* Definieren Sie Filterbedingungen und Kriterien
+* Konfigurieren Sie, welche Datensätze in nachfolgende Schritte übergehen sollen
+
+<Note>
+1. **Ausgabe**: Filterknoten geben keine Daten zurück – sie fungieren als Tore. Wenn die Bedingungen erfüllt sind, geht der Workflow weiter. Wenn nicht, stoppt der Workflow an diesem Zweig.
+2. Der "IS"-Operator kann mit numerischen Feldern verwendet werden. Es spielt als "EQUAL".
+</Note>
+
+### Verzögerung
+
+Behebt Workflow-Ausführung für eine bestimmte Dauer oder bis zu einem bestimmten Datum/Zeitpunkt.
+
+**Verzögerungstypen**:
+
+| Typ                 | Beschreibung                                                     |
+| ------------------- | ---------------------------------------------------------------- |
+| **Dauer**           | Warte auf eine bestimmte Zeit (Tage, Stunden, Minuten, Sekunden) |
+| **Geplantes Datum** | Warten Sie bis zu einem bestimmten Datum und Zeit                |
+
+**Konfiguration für Dauern**:
+
+* Tage, Stunden, Minuten und/oder Sekunden festlegen
+* Mehrere Einheiten kombinieren (z. B. 2 Tage und 4 Stunden)
+
+**Konfiguration für geplantes Datum**:
+
+* Datum und Uhrzeit auswählen
+* Kann ein Datumsfeld aus einem vorherigen Schritt referenzieren (z.B. 3 Tage nach einer Besprechung)
+
+**Anwendungsfälle**:
+
+* Warten Sie 24 Stunden bevor Sie eine Nachfass-E-Mail senden
+* Pause bis zum Enddatum einer Gelegenheit
+* Aufgaben für Geschäftszeiten planen
+
+<Note>
+Das geplante Datum kann nicht in der Vergangenheit sein. Wenn ein Datumsfeld aus einem vorherigen Schritt verwendet wird und das Datum bereits abgelaufen ist, wird der Workflow fehlschlagen.
+</Note>
+
+**Limits & Credits**:
+
+* **Kein maximales Zeitlimit** - Du kannst Verzögerungen von Minuten, Tage, Wochen oder länger einstellen
+* **1 Credits verbraucht** wenn der Delay Knoten ausgeführt wird, unabhängig von der Dauer
+* **Kein Guthaben verbraucht** während des Wartens - eine 5-minütige Verzögerung kostet dasselbe wie eine 5-tägige Verzögerung
+
+## Kommunikationsaktionen
+
+### E-Mail senden
+
+Sendet eine E-Mail aus Ihrem Workflow. Dies ist ideal für vordefinierte Gruppenmails. E-Mails werden so aussehen, wie sie von Ihrem Postfach gesendet werden.
+Es eignet sich nicht für Newsletter (die eine umfassendere Formatierung erfordern) oder für automatisierte E-Mail-Sequenzen.
+
+**Voraussetzungen**: Fügen Sie ein E-Mail-Konto unter Einstellungen → Konten hinzu
+
+**Konfiguration**:
+
+* Wählen Sie das Absender-E-Mail-Konto
+
+<Note>
+Sie können nur E-Mails aus Postfächern versenden, die mit Ihrem eigenen Konto synchronisiert wurden. Das Versenden von Postfächern anderer Teammitglieder (z. B. die E-Mail des Kontoinhabers) ist auf der Roadmap.
+</Note>
+
+Für alle folgenden Schritte können Sie Variablen aus früheren Schritten zur Personalisierung referenzieren.
+
+* E-Mail-Adresse des Empfängers eingeben.
+
+<Note>
+Im Moment ist nur ein Empfänger möglich.
+</Note>
+
+* Betreffzeile festlegen.
+* Nachrichtentext verfassen. Sie können Links formatieren, nummerierte Listen, Kugelpunktlisten erstellen und Anhänge hinzufügen.
+
+<Note>
+Das Hinzufügen von HTML-Signaturen ist im Moment nicht möglich.
+</Note>
+
+### Formular
+
+Fordert während der Workflow-Ausführung ein Formular an, um Benutzereingaben zu sammeln. Die Antworten können dann in folgenden Schritten verwendet werden, um Datensätze zu erstellen, E-Mails zu senden oder jede andere Aktion basierend auf der Eingabe auszuführen.
+
+<Warning>
+**Formulare sind nur für manuelle Trigger konzipiert**. Bei Workflows mit anderen Triggern (Datensatz erstellt, aktualisiert, etc.) sind Formulare nur über die Workflow-Ausführungsoberfläche zugänglich, was nicht das erwartete Benutzererlebnis ist. 2026 wird ein Benachrichtigungszentrum freigegeben, um Formulare in automatisierten Arbeitsabläufen ordnungsgemäß zu unterstützen.
+</Warning>
+
+**Konfiguration**:
+
+* Konfigurieren Sie die Felder, die Benutzer ausfüllen sollen. Für jedes Feld wählen
+  * ein Typ unter Text, Nummer, Datum, gegebener Datensatz, ein Auswahlfeld. Felder aller Objekte stehen zur Auswahl zur Verfügung.
+  * ein Label
+  * ein Standardwert unter `Platzhalter` (optional)
+* Formulartitel bearbeiten
+
+**Ausgabe**: Formularantworten sind für nachfolgende Schritte verfügbar.
+
+**Beispiel**: Der "Quick Lead"-Workflow ist standardmäßig in allen Arbeitsbereichen verfügbar, die überall im Kommandomenü `Cmd+K` verfügbar sind.
+
+**So füllen Sie das Formular aus**:
+
+* Löse deinen manuellen Workflow aus dem Kommandomenü `Cmd+K` aus
+* Füllen Sie das Formular aus, das im Seitenfenster angezeigt wird, und klicken Sie auf "Absenden".
+
+<Note>
+Die Felder können nicht obligatorisch gemacht werden.
+</Note>
+
+<VimeoEmbed videoId="1147277989" title="Video-Demo" />
+
+## Integrationsaktionen
+
+### Code
+
+Führt benutzerdefiniertes JavaScript in Ihrem Workflow aus.
+
+Im Hintergrund wird jede Code-Aktion von ihrer eigenen **Logikfunktion** unterstützt – einer serverseitigen TypeScript-Funktion, die auf der Twenty-Plattform ausgeführt wird. Wenn Sie eine Code-Aktion hinzufügen, erstellt Twenty eine dedizierte Logikfunktion für diesen Schritt und stellt deren Editor inline bereit, sodass der von Ihnen geschriebene Code zusammen mit dem Workflow gespeichert wird.
+
+**Konfiguration**:
+
+* Greifen Sie auf Variablen aus vorherigen Schritten zu. Sie können die Namen der Variablen dynamisch bearbeiten.
+
+<VimeoEmbed videoId="1147281795" title="Video-Demo" />
+
+* Schreiben Sie JavaScript-Code im Editor
+* Variablen zurückgeben, um sie in nachfolgenden Schritten zu verwenden
+* Code direkt im Schritt testen
+
+<Note>
+Wenn Sie externe API-Schlüssel in Ihrem Code verwenden müssen, müssen Sie diese direkt in den Funktionskörper eingeben. Sie können API-Schlüssel nicht an anderer Stelle konfigurieren und sie dann in der Logikfunktion referenzieren.
+</Note>
+
+<Tip>
+**Mit Arrays arbeiten?** Arrays von externen Systemen oder vorherigen Schritten können als Zeichenketten verwendet werden. Siehe [Wie man Arrays in Code-Aktionen behandelt](/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions) für die Lösung.
+</Tip>
+
+<Tip>
+Klicken Sie auf das quadratische Symbol oben rechts im Code-Editor, um es im Vollbildmodus anzuzeigen – hilfreich, da die Standardbreite des Editors begrenzt ist.
+</Tip>
+
+#### Eine Logikfunktion in mehreren Workflows wiederverwenden
+
+Die Inline-Code-Aktion ist ideal für einmalige Logik, aber der darin enthaltene Code gehört zu genau diesem einen Schritt. Wenn Sie dieselbe Logik über mehrere Workflows hinweg teilen oder sie als versionierten Quellcode in einer App pflegen möchten, definieren Sie eine **wiederverwendbare Logikfunktion**, anstatt Code in jede Code-Aktion zu kopieren und einzufügen.
+
+Eine Logikfunktion wird einmal in einer App definiert (mithilfe des SDK-Befehls `defineLogicFunction`) und durch Hinzufügen von `workflowActionTriggerSettings` im Workflow-Builder verfügbar gemacht. Sobald Ihre App installiert ist, erscheint diese Funktion als eigene Aktion im Workflow-Builder, neben den eingebauten Aktionen. Wenn Sie sie auswählen, werden die von Ihnen deklarierten Eingabefelder angezeigt (mit Variablen-Auswahl, genau wie bei anderen Aktionen) und Ihr geteilter Code wird ausgeführt – kein Inline-JavaScript erforderlich.
+
+|                            | Code-Aktion                                                 | Wiederverwendbare Logikfunktion                                    |
+| -------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------ |
+| **Wo der Code liegt**      | Inline-Editor, an einen einzelnen Workflow-Schritt gebunden | In einer App definiert, im Versionskontrollsystem versioniert      |
+| **Wiederverwendung**       | Pro Schritt kopiert und eingefügt                           | Als Aktion in jedem Workflow hinzugefügt                           |
+| **Eingaben**               | Variablen, die im Editor verdrahtet werden                  | Felder, die aus Ihrem deklarierten Eingabe-Schema gerendert werden |
+| **Am besten geeignet für** | Schnelle, Workflow-spezifische Logik                        | Gemeinsam genutzte Logik, die in mehreren Workflows verwendet wird |
+
+Beide laufen auf derselben Logikfunktions-Laufzeit, sodass eine Code-Aktion, die Sie inline prototypisiert haben, später mit minimalen Änderungen in eine wiederverwendbare Logikfunktion überführt werden kann.
+
+<Tip>
+Die entwicklerorientierte Referenz zur Definition von Logikfunktionen und deren Bereitstellung im Workflow-Builder finden Sie unter [Logic Functions](/l/de/developers/extend/apps/logic/logic-functions) – insbesondere im Abschnitt **Exposing a function as an AI tool or workflow action** und bei `workflowActionTriggerSettings`.
+</Tip>
+
+### HTTP-Anfrage
+
+Sendet eine Anfrage an eine externe API als Teil Ihres Workflows.
+
+<img src="/images/user-guide/workflows/http_action.png" style={{width:'100%'}} />
+
+**Konfiguration**:
+
+* Geben Sie die API-Endpunkt-URL ein. Die Verwendung von Parametern aus früheren Schritten ist möglich.
+* Wählen Sie die HTTP-Methode aus (GET, POST, PUT, PATCH, DELETE)
+* Erforderliche Header und Werte hinzufügen
+* Beispielantwort zur Strukturvorschau bereitstellen
+
+## KI-Aktionen
+
+### AI Agent - demnächst
+
+Führt einen KI-Agent innerhalb Ihres Workflows aus, um intelligente Aufgaben auszuführen.
+
+**Konfiguration**:
+
+* **Agent**: Wähle einen vorhandenen KI-Agent oder verwende den Standardmakler
+* **Anfrage**: Schreibe die Anweisung für den KI-Agent
+* Referenzvariablen von vorherigen Schritten in der Promption
+
+**Was KI Agenten tun können**:
+
+* Daten analysieren und zusammenfassen
+* Einträge klassifizieren oder kategorisieren
+* Textinhalt generieren
+* Entscheidungen auf Basis von Daten treffen
+* Interagiere mit deinen CRM-Daten mithilfe von Tools
+
+**Ausgabe**: Die Antwort des KI-Agenten ist verfügbar für die Verwendung in folgenden Schritten. Wenn der Agent ein strukturiertes Ausgabeschema hat, folgt die Antwort diesem Format.
+
+<Note>
+AI Agent-Aktionen verbrauchen Workflow-Credits basierend auf dem verwendeten KI-Modell. Siehe [Workflow Credits](/l/de/user-guide/workflows/capabilities/workflow-credits) für Details.
+</Note>
+
+<Note>
+Die AI-Agenten respektieren die rollenbasierten Genehmigungen. Sie können Agenten unter **Einstellungen → Mitglieder → Rollen** bestimmte Rollen zuweisen, um zu steuern, auf welche Daten sie zugreifen können. Siehe [Permissions](/l/de/user-guide/permissions-access/capabilities/permissions) für Details.
+</Note>

packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-branches.mdx

@@ -0,0 +1,66 @@
+---
+title: Workflow-Verzweigungen
+description: Erstellen Sie parallele Pfade und bedingte Logik in Ihren Workflows.
+---
+
+Verzweigungen ermöglichen es Ihnen, Ihren Workflow in mehrere Pfade aufzuteilen, die abhängig von Ihren Daten gleichzeitig oder bedingt ausgeführt werden können.
+
+<img src="/images/user-guide/workflows/branches.png" style={{width:'100%'}} />
+
+## So funktionieren Verzweigungen
+
+Wenn Sie von einem einzelnen Knoten mehrere Verbindungen erstellen, wird jeder Pfad zu einer Verzweigung. Standardmäßig werden **alle Verzweigungen parallel ausgeführt**—sie warten nicht aufeinander.
+
+## Verzweigungen erstellen
+
+### Neue Verzweigung hinzufügen
+
+1. **Klicken Sie mit der rechten Maustaste auf die Hauptfläche** des Workflows (nicht auf einen vorhandenen Knoten)
+2. Klicken Sie auf **Knoten hinzufügen**
+3. Wählen Sie den Knotentyp für Ihre neue Verzweigung
+4. Ziehen Sie einen Pfeil vom unteren Rand des vorherigen Schritts zum oberen Rand dieser neuen Aktion
+5. Wiederholen Sie dies, um weitere Verzweigungen vom selben Knoten hinzuzufügen
+
+<Note>
+Jede Verzweigung ist unabhängig. Das Hinzufügen einer Verzweigung wirkt sich nicht auf andere bestehende Pfade von diesem Knoten aus.
+</Note>
+
+### Visuelles Layout
+
+Verzweigungen erscheinen als parallele Pfade im Workflow-Editor. Sie können Knoten ziehen, um das visuelle Layout neu anzuordnen, ohne die Ausführung zu beeinflussen.
+
+## Bedingte Verzweigungen
+
+Da standardmäßig alle Verzweigungen ausgeführt werden, verwenden Sie **Filter**-Knoten, um zu steuern, welche Pfade tatsächlich ausgeführt werden:
+
+| Verzweigung | Filterbedingung       | Aktion                           |
+| ----------- | --------------------- | -------------------------------- |
+| A           | Phase = "Gewonnen"    | Glückwunsch-E-Mail senden        |
+| B           | Phase = "Verloren"    | Nachverfolgungsaufgabe erstellen |
+| C           | Phase = "Verhandlung" | Manager benachrichtigen          |
+
+1. Erstellen Sie Verzweigungen von Ihrem Trigger oder Ihrer Aktion aus
+2. Fügen Sie einen **Filter**-Knoten als ersten Schritt jeder Verzweigung hinzu
+3. Konfigurieren Sie jeden Filter mit sich gegenseitig ausschließenden Bedingungen
+4. Fügen Sie Ihre Aktionen nach jedem Filter hinzu
+
+Nur die Verzweigungen, bei denen die Filterbedingung erfüllt ist, werden weiter ausgeführt.
+
+## Verzweigungen zusammenführen
+
+**Verzweigungen werden nicht automatisch zusammengeführt.** Jede Verzweigung wird unabhängig ausgeführt, bis sie endet. Sie haben volle Flexibilität, wie Sie dies handhaben:
+
+* **Option 1: Verzweigungen getrennt halten**
+  Jede Verzweigung verarbeitet ihre eigenen Nachverfolgungsaktionen unabhängig. Dies ist der einfachste Ansatz, wenn Verzweigungen nicht zusammengeführt werden müssen.
+
+* **Option 2: Verzweigungen manuell zusammenführen**
+  Beim Erstellen Ihres Workflows können Sie mehrere Verzweigungen manuell mit derselben nachgelagerten Aktion verbinden. Ziehen Sie einfach Pfeile vom Ende jeder Verzweigung zu einem gemeinsamen Knoten.
+
+<Note>
+Obwohl Sie einen [Delay](/l/de/user-guide/workflows/capabilities/workflow-actions#delay)-Knoten verwenden können, um die Ausführung zu pausieren, lässt er sich derzeit nicht so konfigurieren, dass er wartet, "bis eine andere Verzweigung endet".
+</Note>
+
+## Verwandte Inhalte
+
+* [So verwenden Sie Verzweigungen in Workflows](/l/de/user-guide/workflows/capabilities/use-branches-in-workflows) - Schritt-für-Schritt-Anleitung
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions) - Verfügbare Aktionen einschließlich Filter

packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-credits.mdx

@@ -0,0 +1,75 @@
+---
+title: Workflow-Guthaben
+description: Verstehen Sie den Verbrauch und die Verwaltung von Workflow-Guthaben.
+---
+
+Workflow-Guthaben treiben Ihre Automatisierungen in Twenty an. Das Verständnis ihrer Funktionsweise hilft Ihnen, die Kosten zu optimieren und Ihr Automatisierungsbudget effektiv zu verwalten.
+
+## Guthabenverteilung
+
+Workflow-Guthaben werden basierend auf Ihrem Abrechnungszeitraum zugeteilt, nicht nach Ihrer Tarifstufe:
+
+| Abrechnungszeitraum        | Guthaben            |
+| -------------------------- | ------------------- |
+| **Monatliches Abonnement** | 5 Credits pro Monat |
+| **Jährliches Abonnement**  | 50 Credits pro Jahr |
+
+<Note>
+5 Credits pro Monat sind für Standardautomatisierungen großzügig bemessen. Die meisten Teams überschreiten dieses Limit bei typischer Nutzung von Workflows nicht. Zusätzliche Guthaben werden vor allem für erweiterte Code-Aktionen und KI-gestützte Workflows benötigt.
+</Note>
+
+## Wie der Verbrauch von Guthaben funktioniert
+
+Guthaben werden verbraucht, wenn Workflows ausgeführt werden, nicht, wenn Sie sie erstellen. Jede Workflow-Aktion verbraucht Credits basierend auf ihrer Komplexität:
+
+### Guthabenverbrauch nach Aktionstyp
+
+* **Einfache interne Vorgänge**: Sehr niedriger Guthabenverbrauch
+  * Datensätze durchsuchen
+  * Datensatz erstellen
+  * Datensatz aktualisieren
+  * Datensatz löschen
+  * Formularaktionen
+
+* **Komplexe Vorgänge**: Höherer Guthabenverbrauch
+  * Code-Aktionen (JavaScript-Ausführung)
+  * HTTP-Anfragen an externe Dienste
+
+* **KI-Funktionen**: Höherer Guthabenverbrauch
+  * KI-Agent-Aktionen verbrauchen Guthaben abhängig vom verwendeten KI-Modell
+  * Komplexere Prompts und längere Ausgaben verbrauchen mehr Guthaben
+
+* **Delay-Aktionen**: Minimaler Guthabenverbrauch
+  * Der Delay-Knoten verbraucht **1 Guthaben**, wenn er ausgeführt wird
+  * **Es werden keine Guthaben verbraucht** während der Wartezeit
+  * Eine Verzögerung von 5 Minuten kostet dasselbe wie eine Verzögerung von 5 Tagen
+
+### Echtzeitabzug
+
+Guthaben werden in Echtzeit abgezogen, sobald Workflows ausgeführt werden. Das bedeutet:
+
+* Entwurfs-Workflows verbrauchen keine Guthaben
+* Nur aktive, laufende Workflows nutzen Ihre Guthabenzuteilung
+* Fehlgeschlagene Workflows verbrauchen dennoch Guthaben für abgeschlossene Schritte
+
+## Guthabenverwaltung
+
+### Guthabenverbrauch prüfen
+
+1. Gehen Sie zu **Einstellungen → Abrechnung**
+2. Sehen Sie sich Ihren aktuellen Guthabenverbrauch und verbleibenden Saldo an
+3. Beobachten Sie Nutzungsmuster, um Ihre Workflows zu optimieren
+
+### Zusätzliche Guthaben kaufen
+
+Wenn Sie mehr Guthaben über Ihre Plan-Zuteilung hinaus benötigen:
+
+1. Gehen Sie zu **Einstellungen → Abrechnung**
+2. Klicken Sie auf die Option, um zusätzliche Guthaben zu kaufen. Pakete unterschiedlicher Größen sind verfügbar.
+3. Guthaben werden Ihrem aktuellen Saldo hinzugefügt
+
+## Beste Praktiken
+
+* **Batch-Verarbeitung**: Verwenden Sie Massen-Operationen und Iterator-Aktionen effizient um einzelne Aktionsaufrufe zu reduzieren
+* **Optimierung manueller Auslöser**: Wählen Sie bei manuellen Auslösern die Verfügbarkeit `Bulk`, um mehrere Datensätze in einem einzelnen Workflow-Durchlauf zu verarbeiten
+* Optimieren Sie Code-Aktionen für Effizienz

packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-runs.mdx

@@ -0,0 +1,93 @@
+---
+title: Workflow-Läufe
+description: Workflow-Ausführungen überwachen und verwalten.
+---
+
+## Über Läufe
+
+Ein **Lauf** ist ein Protokoll einer Workflow-Ausführung. Jedes Mal, wenn ein Workflow ausgelöst wird – sei es durch ein Datensatzereignis, einen Zeitplan, eine manuelle Aktion oder einen Webhook – wird ein neuer Lauf erstellt.
+
+## Läufe anzeigen
+
+### Im Workflow-Editor
+
+1. Öffnen Sie den Workflow, den Sie überwachen möchten
+2. Klicken Sie auf das **Läufe**-Panel auf der rechten Seite
+3. Sehen Sie eine Liste der letzten Läufe mit ihrem Status
+
+### In der Ansicht Workflow-Läufe
+
+1. Gehen Sie in der Seitenleiste zu **Workflow-Läufe**
+2. Zeigen Sie Läufe über alle Workflows hinweg an
+3. Filtern Sie nach Status, Workflow oder Datum
+
+## Laufstatus
+
+| Status              | Beschreibung                                                                                      |
+| ------------------- | ------------------------------------------------------------------------------------------------- |
+| **Wird ausgeführt** | Workflow wird derzeit ausgeführt                                                                  |
+| **Abgeschlossen**   | Workflow wurde erfolgreich abgeschlossen                                                          |
+| **Fehlgeschlagen**  | Beim Workflow ist ein Fehler aufgetreten und wurde angehalten                                     |
+| **Wartend**         | Workflow ist angehalten (z. B. wartet auf eine Verzögerungsaktion oder eine Formularübermittlung) |
+
+## Laufdetails
+
+Klicken Sie auf einen beliebigen Lauf, um Folgendes zu sehen:
+
+* **Status**: Aktueller Zustand des Laufs
+* **Gestartet am**: Wann der Lauf begonnen hat
+* **Dauer**: Wie lange der Lauf gedauert hat
+* **Triggerdaten**: Die Eingabe, die den Workflow gestartet hat
+* **Schrittausgaben**: Daten, die von jedem Schritt zurückgegeben wurden
+* **Fehlermeldungen**: Falls der Lauf fehlgeschlagen ist – was schiefgelaufen ist
+
+## Ausführung Schritt für Schritt
+
+Jeder Lauf zeigt den Fortschritt in Ihrem Workflow:
+
+1. Sehen Sie, welche Schritte erfolgreich abgeschlossen wurden
+2. Ermitteln Sie, wo Fehler aufgetreten sind
+3. Sehen Sie sich die zwischen den Schritten übergebenen Daten an
+4. Beheben Sie Probleme, indem Sie die Eingaben und Ausgaben der Schritte untersuchen
+
+## Fehlerbehandlung
+
+Wenn ein Lauf fehlschlägt:
+
+1. Öffnen Sie den fehlgeschlagenen Lauf
+2. Finden Sie den Schritt, der den Fehler verursacht hat
+3. Prüfen Sie die Fehlermeldung auf Details
+
+Häufige Probleme:
+
+* Erforderliche Felder fehlen
+* Ungültiges Datenformat
+* Externe API-Fehler
+* Berechtigungsprobleme
+
+## Workflows erneut ausführen
+
+Wenn ein Durchlauf fehlschlägt, können Sie Folgendes tun:
+
+* Beheben Sie das zugrunde liegende Problem und warten Sie auf den nächsten Trigger
+* Lösen Sie bei manuellen Workflows den Workflow mit denselben oder aktualisierten Daten erneut aus
+* Überprüfen Sie die Workflow-Logik, um zukünftige Fehler zu verhindern
+
+## Leistungs-Tipps
+
+### Verlauf verwalten
+
+* Läufen sind als historische Referenz erhalten
+* Sehr alte Abläufe können automatisch archiviert werden
+* Exportiere ausgeführte Daten, wenn Datensätze gespeichert werden müssen
+
+### Best Practices überwachen
+
+* Überprüfen Sie regelmäßig nach der Aktivierung neuer Workflows
+* Überprüfung fehlgeschlagen um Muster zu identifizieren
+
+## Verwandt
+
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [Workflow Fehlerbehebung](/l/de/user-guide/workflows/how-tos/need-more-help/workflow-troubleshooting)

packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-triggers.mdx

@@ -0,0 +1,136 @@
+---
+title: Workflow-Auslöser
+description: Erfahren Sie mehr über die verschiedenen Auslöser, die Ihre Workflows starten.
+---
+
+## Über Auslöser
+
+Workflows beginnen immer mit einem einzelnen Auslöser, der festlegt, wann die Automatisierung ausgeführt werden soll.
+
+<img src="/images/user-guide/workflows/workflow_triggers.png" style={{width:'100%'}} />
+
+<Tip>
+**Erweiterte Objekte werden unterstützt!** Über die standardmäßigen CRM-Objekte hinaus (Personen, Unternehmen, Chancen) können Sie auch Workflows auslösen und Aktionen ausführen für:
+* Arbeitsbereichsmitglieder
+* Kalenderereignisse
+* Nachrichten (E-Mails)
+* Aufgaben, Notizen und viele andere Systemobjekte
+
+Dies ermöglicht leistungsstarke Automatisierungen, etwa das Benachrichtigen von Teammitgliedern, wenn Kalenderereignisse erstellt werden, oder das automatische Verarbeiten eingehender E-Mails.
+</Tip>
+
+## Datensatz wird erstellt
+
+Startet den Workflow, wenn ein neuer Datensatz in einem ausgewählten Objekt (Personen, Unternehmen, Gelegenheiten oder ein benutzerdefiniertes Objekt) erstellt wird.
+
+**Konfiguration**: Wählen Sie den Objekttyp aus, der auf neue Datensätze überwacht werden soll.
+
+<Note>
+* Dieser Trigger eignet sich hervorragend für Datensätze, die von CSV, Postfach- und Kalendersynchronisation oder API erstellt wurden.
+* **Für manuell erstellte Datensätze nicht empfohlen**: Mit diesem Auslöser starten Workflows, sobald der Datensatz erstellt wird. Da Zwanzig UI automatisch spart (es gibt keinen Bearbeitungsmodus und dann eine Validierung, um Datensätze zu speichern) wird der Workflow ausgelöst, bevor der Benutzer alle Felder eingibt.
+  Um diesen Workflow bei manuell erstellten Datensätzen auszulösen, wird empfohlen, stattdessen den Auslöser `Record is created or updated` zu verwenden.
+</Note>
+
+## Datensatz wird aktualisiert
+
+Startet den Workflow, wenn Änderungen an einem bestehenden Datensatz vorgenommen werden.
+
+**Konfiguration**:
+
+* Wählen Sie den Objekttyp aus
+* Optional angeben, welche Felder auf Änderungen überwacht werden sollen
+
+## Datensatz wird aktualisiert oder erstellt
+
+Startet den Workflow, wenn ein Datensatz in einem ausgewählten Objekt entweder erstellt oder aktualisiert wird.
+
+**Warum das wichtig ist**: Dieser Auslöser ist besonders hilfreich, da auf verschiedene Arten erstellte Datensätze sich unterschiedlich verhalten:
+
+* **API-/CSV-Importe**: Datensätze werden sofort mit allen Feldern befüllt erstellt
+* **Manuelle Erstellung**: Datensätze werden zuerst erstellt, dann werden Felder in nachfolgenden Aktualisierungen hinzugefügt
+
+**Konfiguration**:
+
+* Wählen Sie den Objekttyp aus, der überwacht werden soll
+* Optional angeben, welche Felder auf Änderungen überwacht werden sollen
+* Der Workflow wird sowohl bei der ersten Erstellung als auch bei nachfolgenden Aktualisierungen ausgelöst
+
+## Datensatz wird gelöscht
+
+Startet den Workflow, wenn ein Datensatz aus einem Objekt entfernt wird.
+
+**Konfiguration**: Wählen Sie den Objekttyp aus, der auf Löschungen überwacht werden soll.
+
+## Manueller Auslöser
+
+Startet den Workflow, wenn er durch eine Benutzeraktion ausgelöst wird. Dieser Auslöser ist über das `Cmd+K`-Menü oder über eine benutzerdefinierte Schaltfläche zugänglich, die nach Auswahl von Datensätzen in der oberen Navigationsleiste angezeigt wird.
+
+<img src="/images/user-guide/workflows/add_to_newsletter_button.png" style={{width:'100%'}} />
+
+**Verfügbarkeitskonfiguration**: Wählen Sie aus, wie der Workflow die Datensatzauswahl handhaben soll:
+
+* **Global**: Für das Auslösen dieses Workflows ist kein Datensatz erforderlich. Der Workflow wird aus dem Befehlsmenü `Cmd+K` irgendwo (von jedem Objekt) ausgelöst und verwendet keine Eintragung(en) als Eingabe.
+
+Für die **Single** und **Bulk** Verfügbarkeit werden die ausgewählten Datensätze(n) an Ihren Workflow übergeben. Dies ist für ein bestimmtes Objekt konfiguriert und mehrere Datensätze können ausgewählt werden, bevor der Workflow ausgelöst wird.
+
+* **Single**: Der Workflow läuft von Anfang bis Ende so oft wie die Datensätze ausgewählt sind.
+
+  <Note>
+    **Soft-Limit: 100 Ausführungen/Minute**. Darüber hinaus verbleiben Workflows im Status "Nicht gestartet" und werden schrittweise verarbeitet—entweder durch einen Hintergrundauftrag oder wenn ein anderer Workflow in die Warteschlange gelangt. Das bedeutet, Sie können mit einem einzelnen Auslöser mehr als 100 Datensätze auswählen; die Ausführung wird dann lediglich langsamer.
+  </Note>
+
+* **Bulk**: Der Workflow wird einmal ausgeführt und stellt die gesamte Liste der Datensätze als Eingabe zur Verfügung. Das bedeutet, dass der Workflow eine [Iterator-Aktion](/l/de/user-guide/workflows/capabilities/workflow-actions#iterator) enthalten muss.
+
+<Note>
+Dies ist fortgeschrittener und am besten für Personen geeignet, die die Anzahl der Workflow-Ausführungen optimieren möchten.
+</Note>
+
+<img src="/images/user-guide/workflows/manual_trigger.png" style={{width:'100%'}} />
+
+**Zusätzliche Konfiguration**:
+
+* Wählen Sie das Zielobjekt aus (für Einzel- und Bulk-Verfügbarkeit)
+* Wählen Sie ein Befehls-Symbol für den Workflow-Trigger
+* Platzierung in der Navigationsleiste konfigurieren (angeheftet oder nicht angeheftet)
+
+**Zugriffsmethoden**:
+
+* `Cmd+K`-Menü zum Finden und Starten manueller Workflows
+* Benutzerdefinierte Schaltfläche in der oberen Navigationsleiste (falls konfiguriert)
+
+## Zeitbasierter Auslöser: Nach Zeitplan
+
+Startet den Workflow auf regelmäßiger Basis, die Sie definieren.
+
+**Konfiguration**:
+
+* Zeiteinheit auswählen (Minuten, Stunden, Tage)
+* Geben Sie einen Wert ein oder verwenden Sie benutzerdefinierte Cron-Ausdrücke für erweitertes Scheduling
+
+<Note>
+**Zeitzone**: Geplante Workflows laufen in **UTC**. Wenn Sie Uhrzeiten für tägliche Zeitpläne festlegen, konvertieren Sie Ihre lokale Zeit in UTC.
+</Note>
+
+## Externer Auslöser: Webhook
+
+Startet den Workflow, wenn eine GET- oder POST-Anfrage von einem externen Dienst empfangen wird.
+
+<img src="/images/user-guide/workflows/webhook_trigger.png" style={{width:'100%'}} />
+
+**Konfiguration**:
+
+* Der Workflow stellt eine eindeutige Webhook-URL bereit—kopieren Sie diese und fügen Sie sie in Ihrem externen System als aufzurufenden Endpunkt hinzu.
+* Für POST-Anfragen definieren Sie die erwartete Body-Struktur, damit Twenty weiß, welche Daten zu erwarten sind. Fügen Sie hier die Felder hinzu, die Sie erhalten und die weiter unten in Ihrem Workflow benötigt werden.
+* Konfigurieren Sie die Authentifizierung (bald verfügbar).
+
+## Den richtigen Auslöser wählen
+
+| Anwendungsfall                               | Empfohlener Auslöser                      |
+| -------------------------------------------- | ----------------------------------------- |
+| Neue Leads müssen verarbeitet werden         | Datensatz wird erstellt                   |
+| Datenänderungen müssen synchronisiert werden | Datensatz wird aktualisiert               |
+| Import/manuelle Datenverarbeitung            | Datensatz wird aktualisiert oder erstellt |
+| Bereinigung nach dem Löschen                 | Datensatz wird gelöscht                   |
+| Vom Benutzer initiierte Aktion               | Manuell auslösen                          |
+| Wiederkehrende Berichte                      | Nach Zeitplan                             |
+| Externe Integration                          | Webhook oder Nach Zeitplan                |

packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-versions.mdx

@@ -0,0 +1,84 @@
+---
+title: Workflow-Versionen
+description: Workflow-Versionen und -Entwürfe verwalten.
+---
+
+## Über Versionen
+
+Jedes Mal, wenn Sie einen Workflow aktivieren, wird eine neue Version erstellt. So können Sie Änderungen im Laufe der Zeit nachverfolgen und bei Bedarf zu früheren Konfigurationen zurückkehren.
+
+## Versionsstatus
+
+| Status          | Beschreibung                                      |
+| --------------- | ------------------------------------------------- |
+| **Entwurf**     | Wird bearbeitet, noch nicht veröffentlicht        |
+| **Aktiv**       | Live-Version, die auf Trigger reagiert            |
+| **Deaktiviert** | Zuvor aktiv, aber manuell gestoppt                |
+| **Archiviert**  | Vergangene Versionen für die Historie beibehalten |
+
+## Mit Entwürfen arbeiten
+
+Wenn Sie einen aktiven Workflow bearbeiten, werden Ihre Änderungen als **Entwurf** gespeichert. Die aktive Version läuft weiter, während Sie an Aktualisierungen arbeiten.
+
+Wenn Sie mit der Bearbeitung fertig sind, können Sie:
+
+* **Aktivieren**: Den Entwurf als neue aktive Version veröffentlichen (die vorherige Version wird archiviert)
+* **Verwerfen**: Den Entwurf löschen und die aktuelle aktive Version beibehalten
+
+## Versionsverlauf
+
+### Frühere Versionen anzeigen
+
+1. Öffnen Sie den Workflow
+2. Klicken Sie auf die Registerkarte **Versionen**
+3. Alle früheren Versionen mit Zeitstempeln anzeigen
+
+### Eine Version wiederherstellen
+
+1. Suchen Sie die Version, die Sie wiederherstellen möchten
+2. Klicken Sie auf **Als Entwurf verwenden**
+3. Die Version wird in einen neuen Entwurf kopiert
+4. Nehmen Sie alle erforderlichen Aktualisierungen vor
+5. Aktivieren Sie, wenn alles bereit ist
+
+## Beste Praktiken
+
+### Versionsverwaltung
+
+* Aktivieren Sie nur, wenn alles für den Produktivbetrieb bereit ist
+* Achten Sie auf aussagekräftige Änderungen zwischen Versionen
+* Dokumentieren Sie größere Änderungen in Workflow-Namen oder -Beschreibungen
+* Testen Sie im Entwurfsmodus, bevor Sie aktivieren
+
+### Änderungen rückgängig machen
+
+* Wenn eine neue Version Probleme verursacht, stellen Sie die vorherige Version wieder her
+* Verwenden Sie den Versionsverlauf, um nachzuvollziehen, was sich geändert hat
+* Testen Sie wiederhergestellte Versionen immer, bevor Sie sie aktivieren
+
+## Häufige Workflows
+
+### Schnellbearbeitung
+
+1. Kleine Änderungen an einem aktiven Workflow vornehmen
+2. Im Entwurfsmodus testen
+3. Die neue Version aktivieren
+
+### Umfassende Überarbeitung
+
+1. Verwenden Sie die vorherige Version als Ausgangspunkt
+2. Nehmen Sie umfangreiche Änderungen im Entwurf vor
+3. Testen Sie alle Szenarien gründlich
+4. Aktivieren Sie, wenn Sie sicher sind
+
+### Rollback
+
+1. Identifizieren Sie das Problem mit der aktuellen Version
+2. Suchen Sie im Verlauf die letzte funktionierende Version
+3. Klicken Sie auf **Als Entwurf verwenden**
+4. Aktivieren Sie, um das alte Verhalten wiederherzustellen
+
+## Verwandte Themen
+
+* [Erste Schritte mit Workflows](/l/de/user-guide/workflows/overview)
+* [Workflow-Ausführungen](/l/de/user-guide/workflows/capabilities/workflow-runs)