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)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx

@@ -0,0 +1,82 @@
+---
+title: Arrays in Code-Aktionen verarbeiten
+description: Erfahren Sie, wie Sie Array-Eingaben in Code-Aktionen innerhalb von Workflows korrekt verarbeiten.
+---
+
+Bei der Arbeit mit Arrays in Code-Aktionen stoßen Sie möglicherweise auf zwei häufige Herausforderungen:
+
+1. **Als Strings übergebene Arrays** — Daten aus externen Systemen oder vorherigen Schritten kommen als String statt als echtes Array an
+2. **Einzelne Elemente nicht auswählbar** — Sie können nur das gesamte Array auswählen, nicht bestimmte Felder darin
+
+Beides lässt sich mit einem Code-Knoten lösen.
+
+## Arrays aus Strings parsen
+
+Arrays werden zwischen Workflow-Schritten häufig als Strings oder JSON übergeben, statt als native Arrays. Dies geschieht, wenn:
+
+* Empfangen von Daten aus externen APIs über HTTP Request
+* Verarbeiten von Webhook-Payloads
+* Weitergeben von Daten zwischen Workflow-Schritten
+
+**Lösung**: Fügen Sie dieses Muster am Anfang Ihrer Code-Aktion hinzu:
+
+```javascript
+export const main = async (params: {
+  users: any;
+}): Promise<object> => {
+  const { users } = params;
+
+  // Handle input that may come as a string or an array
+  const usersFormatted = typeof users === "string" ? JSON.parse(users) : users;
+
+  // Now you can safely work with usersFormatted as an array
+  return {
+    users: usersFormatted.map((user) => ({
+      ...user,
+      activityStatus: String(user.activityStatus).toUpperCase(),
+    })),
+  };
+};
+```
+
+Die entscheidende Zeile `typeof users === "string" ? JSON.parse(users) : users` prüft, ob die Eingabe ein String ist, parst sie bei Bedarf oder verwendet sie direkt, wenn sie bereits ein Array ist.
+
+## Einzelne Felder aus Arrays extrahieren
+
+Ein Webhook kann ein Array wie `answers: [...]` zurückgeben, aber in nachfolgenden Workflow-Schritten können Sie nur das **gesamte Array** auswählen — nicht einzelne Elemente darin.
+
+**Lösung**: Fügen Sie einen Code-Knoten hinzu, um bestimmte Felder zu extrahieren und als strukturiertes Objekt zurückzugeben:
+
+```javascript
+export const main = async (params: {
+  answers: any;
+}): Promise<object> => {
+  const { answers } = params;
+
+  // Handle input that may come as a string or an array
+  const answersFormatted = typeof answers === "string"
+    ? JSON.parse(answers)
+    : answers;
+
+  // Extract specific fields from the array
+  const firstname = answersFormatted[0]?.text || "";
+  const name = answersFormatted[1]?.text || "";
+
+  return {
+    answer: {
+      firstname,
+      name
+    }
+  };
+};
+```
+
+Der Code-Knoten gibt statt eines Arrays ein strukturiertes Objekt zurück. In den folgenden Schritten können Sie nun einzelne Felder wie `answer.firstname` und `answer.name` aus der Variablenauswahl auswählen.
+
+<Tip>
+**Möchten Sie über das Array iterieren, anstatt Felder zu extrahieren?** Wenn ein Code- oder Logikfunktionsschritt ein Array auf oberster Ebene zurückgibt, können Sie es direkt in einen [Iterator](/l/de/user-guide/workflows/capabilities/use-iterator) einspeisen: Wählen Sie die Option **Whole list** des Schritts als Eingabe des Iterators und verweisen Sie dann innerhalb der Schleife mit `{{iterator.currentItem}}` auf jedes Element. In diesem Fall müssen Sie das Array nicht in ein Objekt umstrukturieren.
+</Tip>
+
+<Tip>
+Klicken Sie auf das quadratische Symbol oben rechts im Code-Editor, um ihn im Vollbild anzuzeigen — hilfreich, da die Standardbreite des Editors begrenzt ist.
+</Tip>

packages/twenty-docs/l/de/user-guide/workflows/how-tos/connect-to-other-tools/bring-product-data-in-twenty.mdx

@@ -0,0 +1,182 @@
+---
+title: Produktdaten in Twenty importieren
+description: Synchronisieren Sie Produktkatalogdaten nach Zeitplan aus einem Data Warehouse in Ihr CRM.
+---
+
+Verwenden Sie dieses Muster, um Twenty mit Produktdaten aus Ihrem Data Warehouse (z. B. Snowflake, BigQuery, PostgreSQL) synchron zu halten.
+
+## Workflow-Struktur
+
+1. **Auslöser**: Nach Zeitplan
+2. **Code**: Ihr Data Warehouse abfragen
+3. **Code** (optional): Daten als Array formatieren
+4. **Iterator**: Jedes Produkt durchlaufen
+5. **Upsert Record**: In Twenty erstellen oder aktualisieren
+
+<img src="/images/user-guide/workflows/create_users_workflow.png" style={{width:'100%'}} />
+
+## Schritt 1: Auslöser planen
+
+Stellen Sie den Workflow so ein, dass er mit einer Häufigkeit läuft, die Ihren Anforderungen an die Datenaktualität entspricht:
+
+* Alle 5 Minuten für eine nahezu Echtzeit-Synchronisierung
+* Stündlich für weniger kritische Daten
+* Täglich für Batch-Updates
+
+## Schritt 2: Ihr Data Warehouse abfragen
+
+Fügen Sie eine **Code**-Aktion hinzu, um aktuelle Daten abzurufen:
+
+```javascript
+export const main = async () => {
+  const intervalMinutes = 10; // Match your schedule frequency
+  const cutoffTime = new Date(Date.now() - intervalMinutes * 60 * 1000).toISOString();
+
+  // Replace with your actual data warehouse connection
+  const response = await fetch("https://your-warehouse-api.com/query", {
+    method: "POST",
+    headers: {
+      "Authorization": "Bearer YOUR_API_KEY",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: `
+        SELECT id, name, sku, price, stock_quantity, updated_at
+        FROM products
+        WHERE updated_at >= '${cutoffTime}'
+      `
+    })
+  });
+
+  const data = await response.json();
+  return { products: data.results };
+};
+```
+
+<Tip>
+Filtern Sie nach `updated_at >= last X minutes`, um nur kürzlich geänderte Datensätze abzurufen. So bleibt die Synchronisierung effizient.
+</Tip>
+
+## Schritt 3: Daten formatieren (optional)
+
+Wenn Ihr Data Warehouse Daten in einem Format zurückgibt, das transformiert werden muss, fügen Sie eine weitere **Code**-Aktion hinzu. Häufige Transformationen umfassen Typkonvertierungen, Feldumbenennungen und Datenbereinigung.
+
+### Beispiel: Benutzerdaten mit booleschen und Statusfeldern
+
+```javascript
+export const main = async (params: {
+  users: any;
+}): Promise<object> => {
+  const { users } = params;
+  const usersFormatted = typeof users === "string" ? JSON.parse(users) : users;
+
+  // Convert string "true"/"false" to actual booleans
+  const toBool = (v: any) => v === true || v === "true";
+
+  return {
+    users: usersFormatted.map((user) => ({
+      ...user,
+      activityStatus: String(user.activityStatus).toUpperCase(),
+      isActiveLast30d: toBool(user.isActiveLast30d),
+      isActiveLast7d: toBool(user.isActiveLast7d),
+      isActiveLast24h: toBool(user.isActiveLast24h),
+      isTwenty: toBool(user.isTwenty),
+    })),
+  };
+};
+```
+
+### Beispiel: Produktdaten mit Typkonvertierungen
+
+```javascript
+export const main = async (params: { products: any }) => {
+  const products = typeof params.products === "string"
+    ? JSON.parse(params.products)
+    : params.products;
+
+  return {
+    products: products.map(product => ({
+      externalId: product.id,
+      name: product.name,
+      sku: product.sku,
+      price: parseFloat(product.price),        // String → Number
+      stockQuantity: parseInt(product.stock_quantity),
+      isActive: product.status === "active"    // String → Boolean
+    }))
+  };
+};
+```
+
+### Beispiel: Datums- und Währungsformatierung
+
+```javascript
+export const main = async (params: { deals: any }) => {
+  const deals = typeof params.deals === "string"
+    ? JSON.parse(params.deals)
+    : params.deals;
+
+  return {
+    deals: deals.map(deal => ({
+      ...deal,
+      // Convert Unix timestamp to ISO date
+      closedAt: deal.closed_timestamp
+        ? new Date(deal.closed_timestamp * 1000).toISOString()
+        : null,
+      // Ensure amount is a number (remove currency symbols)
+      amount: parseFloat(String(deal.amount).replace(/[^0-9.-]/g, "")),
+      // Normalize stage names
+      stage: deal.stage?.toLowerCase().replace(/_/g, " ")
+    }))
+  };
+};
+```
+
+### Häufige Transformationen
+
+| Quellformat          | Zielformat       | Code                                     |
+| -------------------- | ---------------- | ---------------------------------------- |
+| `"true"` / `"false"` | `true` / `false` | `v === true \|\| v === "true"`           |
+| `"123.45"`           | `123.45`         | `parseFloat(value)`                      |
+| `"active"`           | `"ACTIVE"`       | `value.toUpperCase()`                    |
+| `1704067200` (Unix)  | ISO-Datum        | `new Date(v * 1000).toISOString()`       |
+| `"$1,234.56"`        | `1234.56`        | `parseFloat(v.replace(/[^0-9.-]/g, ""))` |
+| `null` / `undefined` | `""`             | `value \|\| ""`                          |
+
+## Schritt 4: Durch die Produkte iterieren
+
+Fügen Sie eine **Iterator**-Aktion hinzu:
+
+* Eingabe: `{{code.products}}`
+
+Dies durchläuft jedes Produkt im Array.
+
+## Schritt 5: Jeden Datensatz upserten
+
+Fügen Sie innerhalb des Iterators eine **Upsert Record**-Aktion hinzu:
+
+| Einstellung           | Wert                                         |
+| --------------------- | -------------------------------------------- |
+| **Objekt**            | Ihr benutzerdefiniertes Produktobjekt        |
+| **Abgleichen anhand** | Externe ID oder SKU (eindeutiger Bezeichner) |
+| **Name**              | `{{iterator.item.name}}`                     |
+| **SKU**               | `{{iterator.item.sku}}`                      |
+| **Preis**             | `{{iterator.item.price}}`                    |
+
+<Tip>
+Verwenden Sie **Upsert** (aktualisieren oder erstellen), anstatt separate Verzweigungen für Erstellen vs. Aktualisieren zu bauen. Das ist schneller aufzubauen und leichter zu debuggen.
+</Tip>
+
+## Beispielanwendungsfälle
+
+| Quelle                        | Daten                                         |
+| ----------------------------- | --------------------------------------------- |
+| **ERP-System**                | Produktkatalog, Preise, Bestand               |
+| **E-Commerce-Plattform**      | Bestellungen, Kunden, Produktaktualisierungen |
+| **Data Warehouse**            | Aggregierte Metriken, angereicherte Daten     |
+| **Bestandsverwaltungssystem** | Bestandsmengen, Nachbestellwarnungen          |
+
+## Verwandt
+
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [Arrays in Code-Aktionen verarbeiten](/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/connect-to-other-tools/bring-typeform-submissions-in-twenty.mdx

@@ -0,0 +1,130 @@
+---
+title: Typeform-Formulareinsendungen in Twenty übernehmen
+description: Verarbeiten Sie die Webhook-Payload von Typeform, um aus Formulareinsendungen Leads zu erstellen.
+---
+
+Für die Standard-Webhook-Einrichtung siehe [Webhook-Trigger einrichten](/l/de/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger). Dieser Artikel behandelt die spezifische Verarbeitung, die für die benutzerdefinierte Payload-Struktur von Typeform erforderlich ist.
+
+### Schritt 1: Webhook-Workflow erstellen
+
+1. Gehen Sie zu **Einstellungen → Workflows**
+2. Klicken Sie auf **+ Neuer Workflow**
+3. Wählen Sie **Webhook** als Trigger
+4. Kopieren Sie die Webhook-URL
+
+### Schritt 2: Typeform konfigurieren
+
+1. Öffnen Sie in Typeform Ihr Formular
+2. Gehen Sie zu **Connect → Webhooks**
+3. Fügen Sie Ihre Twenty-Webhook-URL ein
+4. Speichern
+
+### Schritt 3: Die Typeform-Payload verstehen
+
+Typeform sendet eine verschachtelte JSON-Struktur. Hier ist ein vereinfachtes Beispiel:
+
+```json
+{
+  "event_type": "form_response",
+  "form_response": {
+    "form_id": "abc123",
+    "submitted_at": "2025-01-15T10:30:00Z",
+    "answers": [
+      {
+        "text": "Jane",
+        "type": "text",
+        "field": { "id": "field1", "type": "short_text", "title": "First Name" }
+      },
+      {
+        "text": "Smith",
+        "type": "text",
+        "field": { "id": "field2", "type": "short_text", "title": "Last Name" }
+      },
+      {
+        "text": "Acme Corp",
+        "type": "text",
+        "field": { "id": "field3", "type": "short_text", "title": "Company" }
+      },
+      {
+        "email": "jane@acme.com",
+        "type": "email",
+        "field": { "id": "field4", "type": "email", "title": "Email" }
+      },
+      {
+        "type": "choice",
+        "field": { "id": "field5", "type": "dropdown", "title": "Team Size" },
+        "choice": { "label": "10-50" }
+      }
+    ]
+  }
+}
+```
+
+Wichtige Hinweise:
+
+* Formulardaten sind unter `form_response` verschachtelt
+* **Antworten werden als Array zurückgegeben**, nicht als benannte Felder
+* Jede Antwort enthält den Feldtyp und den Titel als Referenz
+
+### Schritt 4: Felder aus dem `answers`-Array extrahieren
+
+Da `answers` ein Array ist, können Sie in den folgenden Schritten nur das gesamte Array auswählen — nicht einzelne Felder. Fügen Sie eine **Code**-Aktion hinzu, um die benötigten Felder zu extrahieren:
+
+```javascript
+export const main = async (params: {
+  answers: any;
+}): Promise<object> => {
+  const { answers } = params;
+
+  // Handle input that may come as a string or an array
+  const answersFormatted = typeof answers === "string"
+    ? JSON.parse(answers)
+    : answers;
+
+  // Extract fields by position or by finding the field type
+  const firstName = answersFormatted[0]?.text || "";
+  const lastName = answersFormatted[1]?.text || "";
+  const company = answersFormatted[2]?.text || "";
+  const email = answersFormatted.find(a => a.type === "email")?.email || "";
+  const teamSize = answersFormatted.find(a => a.type === "choice")?.choice?.label || "";
+
+  return {
+    contact: {
+      firstName,
+      lastName,
+      company,
+      email,
+      teamSize
+    }
+  };
+};
+```
+
+In den folgenden Schritten können Sie nun `contact.firstName`, `contact.email` usw. aus der Variablenauswahl auswählen.
+
+<Tip>
+Weitere Details zum Umgang mit Arrays in Code-Aktionen finden Sie unter [Arrays in Code-Aktionen verarbeiten](/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions).
+</Tip>
+
+### Schritt 5: Datensatz erstellen
+
+Fügen Sie die Aktion **Datensatz erstellen** hinzu:
+
+| Feld            | Wert                                                               |
+| --------------- | ------------------------------------------------------------------ |
+| **Objekt**      | Personen                                                           |
+| **Vorname**     | `{{code.contact.firstName}}`                                       |
+| **Nachname**    | `{{code.contact.lastName}}`                                        |
+| **E-Mail**      | `{{code.contact.email}}`                                           |
+| **Unternehmen** | Suchen oder erstellen Sie basierend auf `{{code.contact.company}}` |
+
+### Schritt 6: Testen und aktivieren
+
+1. Senden Sie in Typeform eine Testantwort ab
+2. Überprüfen Sie die Workflow-Ausführung, um zu bestätigen, dass die Daten erfasst wurden
+3. Aktivieren Sie den Workflow
+
+## Verwandt
+
+* [Webhook-Trigger einrichten](/l/de/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger)
+* [Arrays in Code-Aktionen verarbeiten](/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty.mdx

@@ -0,0 +1,263 @@
+---
+title: Ein PDF aus Twenty generieren
+description: Erstellen Sie einen Workflow, um ein PDF (z. B. ein Angebot) zu generieren und an einen Datensatz anzuhängen.
+---
+
+Automatisch ein PDF generieren oder abrufen und an einen Datensatz in Twenty anhängen. Dies wird häufig verwendet, um Angebote, Rechnungen oder Berichte zu erstellen, die mit Companies, Opportunities oder anderen Objekten verknüpft sind.
+
+## Übersicht
+
+Dieser Workflow verwendet einen **Manuellen Auslöser**, damit Benutzer bei Bedarf für jeden ausgewählten Datensatz ein PDF generieren können. Eine **Logikfunktion** übernimmt:
+
+1. Das Herunterladen des PDFs von einer URL (von einem PDF-Generierungsdienst)
+2. Das Hochladen der Datei in Twenty
+3. Das Erstellen eines Anhangs, der mit dem Datensatz verknüpft ist
+
+## Voraussetzungen
+
+Bevor Sie den Workflow einrichten:
+
+1. **API-Schlüssel erstellen**: Gehen Sie zu **Einstellungen → APIs** und erstellen Sie einen neuen API-Schlüssel. Sie benötigen dieses Token für die Logic Funktion.
+2. **Richten Sie einen PDF-Generierungsdienst ein** (optional): Wenn Sie PDFs dynamisch generieren möchten (z. B. Angebote), verwenden Sie einen Dienst wie Carbone, PDFMonkey oder DocuSeal, um das PDF zu erstellen und eine Download-URL zu erhalten.
+
+## Schritt-für-Schritt-Einrichtung
+
+### Schritt 1: Trigger konfigurieren
+
+1. Gehen Sie zu **Workflows** und erstellen Sie einen neuen Workflow
+2. Wählen Sie **Manueller Auslöser**
+3. Wählen Sie das Objekt aus, dem Sie PDFs anhängen möchten (z. B. **Company** oder **Opportunity**)
+
+<Tip>
+Mit einem manuellen Trigger Benutzer können diesen Workflow mit einem Button ausführen, der rechts oben erscheint, sobald ein Datensatz ausgewählt ist — dies führt den Workflow aus, um eine PDF zu generieren und anzuhängen.
+</Tip>
+
+### Schritt 2: Logikfunktion hinzufügen
+
+1. Füge eine **Code** Aktion (Logikfunktion) hinzu
+2. Erstellen Sie eine neue Funktion mit dem folgenden Code
+3. Konfigurieren Sie die Eingabeparameter
+
+#### Eingabeparameter
+
+| Parameter   | Wert                    |
+| ----------- | ----------------------- |
+| `companyId` | `{{trigger.object.id}}` |
+
+<Note>
+Wenn Sie an ein anderes Objekt anhängen (Person, Opportunity usw.), benennen Sie den Parameter entsprechend um (z. B. `personId`, `opportunityId`) und aktualisieren Sie die Logikfunktion.
+</Note>
+
+#### Code der Logikfunktion
+
+```typescript
+export const main = async (
+  params: { companyId: string },
+) => {
+  const { companyId } = params;
+  // Replace with your Twenty GraphQL endpoints (/metadata for metadata and files or /graphql for your records)
+  // Cloud: https://api.twenty.com/graphql
+  // Self-hosted: https://your-domain.com/graphql
+
+  const metadataGraphqlEndpoint = 'https://api.twenty.com/metadata';
+  const dataGraphqlEndpoint = 'https://api.twenty.com/graphql';
+
+  // Replace with your API key from Settings → APIs
+  const authToken = 'YOUR_API_KEY';
+
+  // Replace with your PDF URL
+  // This could be from a PDF generation service or a static URL
+  const pdfUrl = 'https://your-pdf-service.com/generated-quote.pdf';
+  const filename = 'quote.pdf';
+
+  // Step 1: Download the PDF file
+  const pdfResponse = await fetch(pdfUrl);
+
+  if (!pdfResponse.ok) {
+    throw new Error(`Failed to download PDF: ${pdfResponse.status}`);
+  }
+
+  const pdfBlob = await pdfResponse.blob();
+  const pdfFile = new File([pdfBlob], filename, { type: 'application/pdf' });
+
+  const fieldMetadataIdQuery = `
+    query FindUploadFileFieldMetadataId {
+      objects {
+        edges {
+          node {
+            nameSingular
+            fieldsList {
+              id
+              name
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  // Step 2: Find a fieldMetadataId of "Attachment file" field in Attachments object with GraphQL API
+  const response = await fetch(metadataGraphqlEndpoint, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      },
+      body: {
+        query: fieldMetadataIdQuery,
+      }
+    });
+  const result = await response.json();
+  const uploadFileFieldMetadataId = result.data.objects.edges.find(object => object.node.nameSingular === 'attachment').node.fieldsList.find(field => field.name === 'file').id;
+
+  // Step 3: Upload the file via GraphQL multipart upload
+  const uploadMutation = `
+    mutation UploadFilesFieldFile($file: Upload!, $fieldMetadataId: String!) {
+      uploadFilesFieldFile(file: $file, fieldMetadataId: $fieldMetadataId) {
+        id
+      }
+    }
+  `;
+
+  const uploadForm = new FormData();
+  uploadForm.append('operations', JSON.stringify({
+    query: uploadMutation,
+    variables: { file: null, fieldMetadataId: uploadFileFieldMetadataId },
+  }));
+  uploadForm.append('map', JSON.stringify({ '0': ['variables.file'] }));
+  uploadForm.append('0', pdfFile);
+
+  const uploadResponse = await fetch(metadataGraphqlEndpoint, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${authToken}` },
+    body: uploadForm,
+  });
+
+  const uploadResult = await uploadResponse.json();
+
+  if (uploadResult.errors?.length) {
+    throw new Error(`Upload failed: ${uploadResult.errors[0].message}`);
+  }
+
+  const fileId = uploadResult.data?.uploadFilesFieldFile?.id;
+
+  if (!fileId) {
+    throw new Error('No file id returned from upload');
+  }
+
+  // Step 4: Create the attachment linked to the company
+  const attachmentMutation = `
+    mutation CreateOneAttachment($data: AttachmentCreateInput!) {
+      createAttachment(data: $data) {
+        id
+        name
+      }
+    }
+  `;
+
+  const attachmentResponse = await fetch(dataGraphqlEndpoint, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${authToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      query: attachmentMutation,
+      variables: {
+        data: {
+          name: filename,
+          targetCompanyId: companyId,
+          file: [
+            {
+              fileId: fileId,
+              label: filename
+            }
+          ]
+        },
+      },
+    }),
+  });
+
+  const attachmentResult = await attachmentResponse.json();
+
+  if (attachmentResult.errors?.length) {
+    throw new Error(`Attachment creation failed: ${attachmentResult.errors[0].message}`);
+  }
+
+  return attachmentResult.data?.createAttachment;
+};
+```
+
+### Schritt 3: An Ihren Anwendungsfall anpassen
+
+#### An ein anderes Objekt anhängen
+
+Ersetzen Sie `targetCompanyId` durch das entsprechende Feld:
+
+| Objekt                     | Feldname                   |
+| -------------------------- | -------------------------- |
+| Unternehmen                | `targetCompanyId`          |
+| Person                     | `targetPersonId`           |
+| Opportunity                | `targetOpportunityId`      |
+| Benutzerdefiniertes Objekt | `targetYourCustomObjectId` |
+
+Aktualisieren Sie sowohl den Funktionsparameter als auch das Objekt `variables.data` in der Attachment-Mutation.
+
+#### So verwenden Sie eine dynamische PDF-URL
+
+Wenn Sie einen PDF-Generierungsdienst verwenden, können Sie:
+
+1. Führen Sie zuerst eine HTTP-Request-Aktion aus, um das PDF zu generieren
+2. Übergeben Sie die zurückgegebene PDF-URL als Parameter an die Logikfunktion
+
+```typescript
+export const main = async (
+  params: { companyId: string; pdfUrl: string; filename: string },
+) => {
+  const { companyId, pdfUrl, filename } = params;
+  // ... rest of the function
+};
+```
+
+### Schritt 4: Testen und aktivieren
+
+1. Speichern Sie den Workflow
+2. Navigieren Sie zu einem Company-Datensatz
+3. Klicken Sie auf das **⋮**-Menü und wählen Sie Ihren Workflow aus
+4. Überprüfen Sie im Datensatz den Bereich **Attachments**, um zu verifizieren, dass das PDF angehängt wurde
+5. Aktivieren Sie den Workflow
+
+## Kombination mit PDF-Generierungsdiensten
+
+Zum Erstellen dynamischer Angebote oder Rechnungen:
+
+### Beispiel: Angebot generieren → PDF anhängen
+
+| Schritt | Aktion                       | Zweck                                            |
+| ------- | ---------------------------- | ------------------------------------------------ |
+| 1       | Manueller Auslöser (Company) | Benutzer initiiert am Datensatz                  |
+| 2       | Datensatz suchen             | Opportunity- oder Positionsdetails abrufen       |
+| 3       | HTTP-Anfrage                 | PDF-Generierungs-API mit Datensatzdaten aufrufen |
+| 4       | Logikfunktion                | Das generierte PDF herunterladen und anhängen    |
+
+### Beliebte PDF-Generierungsdienste
+
+* **Carbone** – Vorlagenbasierte Dokumentenerstellung
+* **PDFMonkey** – Dynamische PDF-Erstellung aus Vorlagen
+* **DocuSeal** – Plattform für Dokumentenautomatisierung
+* **Documint** – API-first-Dokumentenerstellung
+
+Jeder Dienst stellt eine API zur Verfügung, die eine PDF-URL zurückgibt, die Sie dann an die Logic Funktion übergeben können.
+
+## Fehlerbehebung
+
+| Problem                                   | Lösung                                                                                 |
+| ----------------------------------------- | -------------------------------------------------------------------------------------- |
+| "PDF konnte nicht heruntergeladen werden" | Prüfen Sie, ob die PDF-URL erreichbar ist und ein gültiges PDF zurückgibt              |
+| "Upload fehlgeschlagen"                   | Stellen Sie sicher, dass Ihr API-Schlüssel gültig ist und Schreibberechtigungen hat    |
+| "Anhangserstellung fehlgeschlagen"        | Stellen Sie sicher, dass der Feldname der Objekt-ID mit Ihrem Zielobjekt übereinstimmt |
+
+## Verwandt
+
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)
+* [Logikfunktionen](/l/de/user-guide/workflows/capabilities/workflow-actions#code)
+* [Ein Angebot oder eine Rechnung aus Twenty generieren](/l/de/user-guide/workflows/how-tos/connect-to-other-tools/generate-quote-or-invoice-from-twenty)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/connect-to-other-tools/generate-quote-or-invoice-from-twenty.mdx

@@ -0,0 +1,144 @@
+---
+title: Ein Angebot oder eine Rechnung aus Twenty erstellen.
+description: Rechnungen in externen Tools automatisch erstellen, wenn Deals abgeschlossen werden.
+---
+
+Deal-Daten automatisch an Ihr Rechnungsstellungssystem senden (Stripe, QuickBooks, Xero usw.) wenn eine Opportunity gewonnen wird.
+
+## Workflow-Struktur
+
+1. **Auslöser**: Datensatz wird aktualisiert (Opportunity)
+2. **Filter**: Phase = Closed Won
+3. **Datensatz suchen**: Unternehmensdetails abrufen
+4. **Code** (optional): Nutzlast formatieren
+5. **HTTP-Anfrage**: An Rechnungsstellungssystem senden
+
+## Schritt 1: Auslöser einrichten
+
+1. Erstellen Sie einen neuen Workflow
+2. Wählen Sie den Auslöser **Datensatz wird aktualisiert** aus
+3. Wählen Sie **Opportunity** als Objekt
+
+## Schritt 2: Nach Closed Won filtern
+
+Fügen Sie eine **Filter**-Aktion hinzu, damit nur fortgefahren wird, wenn der Deal gewonnen wurde:
+
+| Einstellung   | Wert                                     |
+| ------------- | ---------------------------------------- |
+| **Feld**      | Phase                                    |
+| **Bedingung** | Gleich                                   |
+| **Wert**      | `CLOSED_WON` (oder der Name Ihrer Phase) |
+
+<Tip>
+Der Auslöser wird bei jeder Opportunity-Aktualisierung ausgelöst. Der Filter stellt sicher, dass der Workflow nur fortgesetzt wird, wenn die Phase auf Closed Won geändert wird.
+</Tip>
+
+## Schritt 3: Unternehmensdetails abrufen
+
+Der Opportunity-Datensatz enthält möglicherweise nicht alle Unternehmensfelder, die Sie für die Rechnung benötigen. Fügen Sie eine **Datensatz suchen**-Aktion hinzu:
+
+| Einstellung           | Wert                                         |
+| --------------------- | -------------------------------------------- |
+| **Objekt**            | Unternehmen                                  |
+| **Abgleichen anhand** | ID entspricht `{{trigger.object.companyId}}` |
+
+Dadurch wird der vollständige Unternehmensdatensatz mit Rechnungsadresse, Steuernummer usw. abgerufen.
+
+## Schritt 4: Nutzlast formatieren (optional)
+
+Wenn Ihr Rechnungsstellungssystem ein bestimmtes Format erwartet, fügen Sie eine **Code**-Aktion hinzu:
+
+```javascript
+export const main = async (params: {
+  opportunity: any;
+  company: any;
+}): Promise<object> => {
+  const { opportunity, company } = params;
+
+  return {
+    invoice: {
+      // Customer info from Company
+      customer_name: company.name,
+      customer_email: company.email || "",
+      billing_address: {
+        line1: company.address?.street || "",
+        city: company.address?.city || "",
+        postal_code: company.address?.postalCode || "",
+        country: company.address?.country || ""
+      },
+      tax_id: company.taxId || null,
+
+      // Invoice details from Opportunity
+      amount: opportunity.amount,
+      currency: opportunity.currency || "USD",
+      description: `Invoice for ${opportunity.name}`,
+      due_days: 30,
+
+      // Reference back to Twenty
+      metadata: {
+        opportunity_id: opportunity.id,
+        company_id: company.id
+      }
+    }
+  };
+};
+```
+
+## Schritt 5: An Rechnungsstellungssystem senden
+
+Fügen Sie eine **HTTP-Anfrage**-Aktion hinzu:
+
+| Einstellung | Wert                                           |
+| ----------- | ---------------------------------------------- |
+| **Methode** | POST                                           |
+| **URL**     | Ihr API-Endpunkt für die Rechnungsstellung     |
+| **Header**  | `Authorization: Bearer YOUR_API_KEY`           |
+| **Inhalt**  | `{{code.invoice}}` oder Felder direkt zuordnen |
+
+### Beispiel: Stripe-Rechnung
+
+```
+POST https://api.stripe.com/v1/invoices
+Headers:
+  Authorization: Bearer sk_live_xxx
+  Content-Type: application/x-www-form-urlencoded
+
+Body:
+  customer: {{company.stripeCustomerId}}
+  collection_method: send_invoice
+  days_until_due: 30
+```
+
+### Beispiel: QuickBooks-Rechnung
+
+```
+POST https://quickbooks.api.intuit.com/v3/company/{realmId}/invoice
+Headers:
+  Authorization: Bearer YOUR_ACCESS_TOKEN
+  Content-Type: application/json
+
+Body: {{code.invoice}}
+```
+
+## Vollständige Workflow-Zusammenfassung
+
+| Schritt | Aktion                           | Zweck                                                              |
+| ------- | -------------------------------- | ------------------------------------------------------------------ |
+| 1       | Auslöser: Datensatz aktualisiert | Wird ausgelöst, wenn sich eine beliebige Opportunity ändert        |
+| 2       | Filter                           | Nur fortfahren, wenn Phase = Closed Won                            |
+| 3       | Datensatz suchen                 | Vollständige Unternehmensdetails für die Rechnungsstellung abrufen |
+| 4       | Code                             | Daten für die Rechnungsstellungs-API formatieren                   |
+| 5       | HTTP-Anfrage                     | Rechnung im externen System erstellen                              |
+
+## Tipps
+
+* **Externe IDs speichern**: Speichern Sie die von der API zurückgegebene Rechnungs-ID mithilfe einer **Datensatz aktualisieren**-Aktion in der Opportunity
+* **Fehlerbehandlung**: Fügen Sie einen Zweig hinzu, um eine Benachrichtigung zu senden, wenn die HTTP-Anfrage fehlschlägt
+* **Zuerst testen**: Verwenden Sie den Sandbox-/Testmodus Ihres Rechnungsstellungssystems, bevor Sie live gehen
+
+## Verwandt
+
+* [Ein PDF aus Twenty generieren](/l/de/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty) — generierte PDFs an Datensätze anhängen
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [Automatisierungen für Closed Won](/l/de/user-guide/workflows/how-tos/crm-automations/closed-won-automations)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger.mdx

@@ -0,0 +1,170 @@
+---
+title: Webhook-Trigger einrichten
+description: Empfangen Sie Daten von externen Diensten, um Workflows auszulösen.
+---
+
+Webhook-Trigger ermöglichen es externen Diensten, Ihre Workflows zu starten, indem sie Daten an eine eindeutige URL senden. Verwenden Sie sie, um Formulare, Drittanbieter-Apps und benutzerdefinierte Integrationen zu verbinden.
+
+## Wann Sie Webhooks verwenden sollten
+
+| Anwendungsfall                       | Beispiel                                          |
+| ------------------------------------ | ------------------------------------------------- |
+| **Webformulare**                     | Einsendungen von Kontaktformularen erzeugen Leads |
+| **Drittanbieter-Apps**               | Stripe-Zahlung → Kundendatensatz erstellen        |
+| **Benutzerdefinierte Integrationen** | Ihre App → Twenty-Automatisierung                 |
+| **No-Code-Tools**                    | Zapier-, Make- und n8n-Verbindungen               |
+
+## Schritt-für-Schritt-Einrichtung
+
+### Schritt 1: Workflow erstellen
+
+1. Gehen Sie zu **Einstellungen → Workflows**
+2. Klicken Sie auf **+ Neuer Workflow**
+3. Benennen Sie ihn (z. B. „Website-Formularübermittlung“)
+
+### Schritt 2: Webhook-Trigger konfigurieren
+
+1. Klicken Sie auf den Trigger-Block
+2. Wählen Sie **Webhook** aus
+3. Sie erhalten eine eindeutige Webhook-URL wie:
+   ```
+   https://api.twenty.com/webhooks/workflow/abc123...
+   ```
+4. Kopieren Sie diese URL — Sie benötigen sie für Ihren externen Dienst
+
+### Schritt 3: Erwartete Datenstruktur definieren
+
+Bei **POST**-Anfragen die erwartete Body-Struktur definieren:
+
+1. Klicken Sie auf **Erwarteten Body definieren**
+2. Geben Sie ein Beispiel-JSON ein, das dem entspricht, was Ihr Dienst sendet:
+
+```json
+{
+  "firstName": "John",
+  "lastName": "Doe",
+  "email": "john@example.com",
+  "company": "Acme Inc",
+  "message": "Interested in your product"
+}
+```
+
+3. Klicken Sie auf **Speichern** — dadurch werden Variablen erstellt, die Sie in den nächsten Schritten verwenden können.
+
+### Schritt 4: Aktionen hinzufügen
+
+Fügen Sie nun Aktionen hinzu, die die Webhook-Daten verwenden:
+
+**Beispiel: Einen Personendatensatz erstellen**
+
+1. Fügen Sie die Aktion **Datensatz erstellen** hinzu
+2. Wählen Sie das Objekt **Personen** aus
+3. Felder zuordnen:
+
+| Feld        | Wert                                                               |
+| ----------- | ------------------------------------------------------------------ |
+| Vorname     | `{{trigger.body.firstName}}`                                       |
+| Nachname    | `{{trigger.body.lastName}}`                                        |
+| E-Mail      | `{{trigger.body.email}}`                                           |
+| Unternehmen | Suchen oder erstellen Sie basierend auf `{{trigger.body.company}}` |
+
+### Schritt 5: Den Webhook testen
+
+Testen Sie Ihren Webhook, bevor Sie ihn aktivieren:
+
+**Mit cURL**:
+
+```bash
+curl -X POST https://api.twenty.com/webhooks/workflow/abc123... \
+  -H "Content-Type: application/json" \
+  -d '{"firstName":"Test","lastName":"User","email":"test@example.com"}'
+```
+
+**Mit Postman oder ähnlichen Tools**:
+
+1. Erstellen Sie eine POST-Anfrage an Ihre Webhook-URL
+2. Setzen Sie den Content-Type-Header auf `application/json`
+3. Fügen Sie Ihren Test-JSON-Body hinzu
+4. Senden und die Workflow-Ausführungen prüfen
+
+### Schritt 6: Aktivieren
+
+Nach dem Testen klicken Sie auf **Aktivieren**, um den Workflow live zu schalten.
+
+## Umgang mit unterschiedlichen Datenstrukturen
+
+### Verschachtelte Daten
+
+Wenn Ihr Webhook verschachtelte Daten sendet:
+
+```json
+{
+  "contact": {
+    "name": "John Doe",
+    "email": "john@example.com"
+  },
+  "source": "website"
+}
+```
+
+Referenzieren mit: `{{trigger.body.contact.email}}`
+
+### Arrays
+
+Wenn die Daten Arrays enthalten:
+
+```json
+{
+  "items": [
+    {"name": "Product A", "qty": 2},
+    {"name": "Product B", "qty": 1}
+  ]
+}
+```
+
+Wie Sie Arrays handhaben, hängt von Ihrem Anwendungsfall ab:
+
+**Unbekannte Anzahl von Elementen → Iterator verwenden**
+
+Wenn Sie jedes Element im Array verarbeiten müssen (z. B. für jedes einen Datensatz erstellen), fügen Sie eine **Code**-Aktion hinzu, um das Array zu parsen, und verwenden Sie anschließend **Iterator**:
+
+```javascript
+export const main = async (params: { items: any }) => {
+  const items = typeof params.items === "string"
+    ? JSON.parse(params.items)
+    : params.items;
+  return { items };
+};
+```
+
+Verwenden Sie dann Iterator, um zu iterieren: `{{code.items}}`
+
+**Bekannte/spezifische Felder → In benannte Felder extrahieren**
+
+Wenn das Array bestimmte Felder enthält, auf die Sie einzeln zugreifen möchten (z. B. Formularantworten, bei denen Position 0 immer „Vorname“ und Position 1 immer „Nachname“ ist), fügen Sie eine **Code**-Aktion hinzu, um sie zu extrahieren:
+
+```javascript
+export const main = async (params: { items: any }) => {
+  const items = typeof params.items === "string"
+    ? JSON.parse(params.items)
+    : params.items;
+
+  return {
+    product: {
+      name: items[0]?.name || "",
+      qty: items[0]?.qty || 0
+    }
+  };
+};
+```
+
+Jetzt können Sie `product.name` und `product.qty` in den folgenden Schritten jeweils einzeln auswählen.
+
+<Tip>
+Weitere Details zum Umgang mit Arrays finden Sie unter [Arrays in Code-Aktionen verarbeiten](/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions).
+</Tip>
+
+## 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/how-tos/crm-automations/auto-reply-to-inbound-emails.mdx

@@ -0,0 +1,121 @@
+---
+title: Automatische Antwort auf eingehende E-Mails
+description: Erstellen Sie einen Workflow, der KI nutzt, um eingehende E-Mails zu sichten und automatisch Antworten im Thread zu senden.
+---
+
+Antworten Sie auf eingehende E-Mails in Sekunden — nicht in Stunden. Dieser Workflow verwendet einen AI Agenten, um Rauschen (Newsletter, Spam, Auto-Antworten) zu filtern und eine personalisierte Antwort auf echte Nachrichten zu entwerfen. Dann sendet die KI sie als Thread-Antwort innerhalb der ursprünglichen Konversation.
+
+## Wie E-Mail-Threading funktioniert
+
+Jede E-Mail enthält einen verborgenen `Message-ID`-Header — einen eindeutigen Fingerabdruck, der vom Mailserver des Absenders zugewiesen wird. Wenn Sie auf eine E-Mail antworten, setzt Ihr E-Mail-Client einen `In-Reply-To`-Header, der auf diesen Fingerabdruck verweist. So gruppieren Gmail, Outlook und alle anderen Clients Nachrichten in Threads.
+
+In Twenty wird dieser Fingerabdruck als `headerMessageId` am Message-Objekt gespeichert. Ihr Workflow greift ihn auf und übergibt ihn an das Feld In-Reply-To der Aktion Send Email.
+
+## Den Workflow erstellen
+
+### Schritt 1: Neuen Workflow erstellen
+
+Gehen Sie zu **Settings -> Workflows** und klicken Sie auf **+ New Workflow**.
+
+### Schritt 2: Bei eingehenden Nachrichten auslösen
+
+Wählen Sie **When a Record is Created** und dann **Messages**.
+
+Jedes Mal, wenn eine E-Mail in Twenty eingeht, wird dies ausgelöst.
+
+<img src="/images/user-guide/workflows/auto-reply/workflow-overview.png" style={{width:'100%'}} />
+
+### Schritt 3: Absender ermitteln
+
+Fügen Sie eine **Datensätze suchen**-Aktion hinzu.
+
+Die Absenderadresse befindet sich nicht in der Nachricht selbst — sie steht im zugehörigen Datensatz Message Participant.
+
+| Feld       | Wert                             |
+| ---------- | -------------------------------- |
+| **Objekt** | Nachrichtenteilnehmer            |
+| **Filter** | Message **ist** `{{trigger.id}}` |
+| **Filter** | Rolle **ist** From               |
+| **Limit**  | 1                                |
+
+Dadurch erhalten Sie die E-Mail-Adresse des Absenders in `handle` und den Namen in `displayName`.
+
+<img src="/images/user-guide/workflows/auto-reply/find-sender.png" style={{width:'100%'}} />
+
+### Schritt 4: Triage und Entwurf einer Antwort mit der KI
+
+Fügen Sie eine **AI Agent**-Aktion hinzu. Dieser einzelne Schritt erledigt zwei Dinge: Er entscheidet, ob die E-Mail eine Antwort verdient, und falls ja, verfasst er eine.
+
+Verwenden Sie einen Prompt wie:
+
+```
+You are an email triage assistant for a sales team. Read the following
+inbound email and decide if it deserves a reply.
+
+Subject: {{trigger.subject}}
+Body: {{trigger.text}}
+From: {{Find Sender.first.displayName}} ({{Find Sender.first.handle}})
+
+If this email is spam, a newsletter, an automated notification, or
+otherwise does not need a human reply, respond with exactly: SKIP
+
+Otherwise, write a short, professional reply (3-4 sentences max) that:
+- Acknowledges their specific message
+- Lets them know someone from the team will follow up shortly
+- Is warm but not overly casual
+
+Respond with only the reply text, no subject line or greeting prefix.
+```
+
+Der AI Agent gibt seine Antwort in einem Feld `response` aus, auf das sich die nächsten Schritte beziehen können.
+
+<img src="/images/user-guide/workflows/auto-reply/ai-triage.png" style={{width:'100%'}} />
+
+### Schritt 5: Verzweigen anhand der KI-Entscheidung
+
+Fügen Sie eine **If/Else**-Aktion hinzu, um zu prüfen, ob die KI sich entschieden hat zu antworten oder zu überspringen.
+
+| Feld          | Wert                                         |
+| ------------- | -------------------------------------------- |
+| **Bedingung** | AI Agent `response` **enthält nicht** `SKIP` |
+| **Wenn wahr** | Mit Send Email fortfahren                    |
+| **Sonst**     | Nichts tun (Workflow endet)                  |
+
+Spam, Newsletter und automatisch erzeugte Nachrichten werden verworfen. Alles andere geht zum nächsten Schritt über.
+
+<img src="/images/user-guide/workflows/auto-reply/should-reply.png" style={{width:'100%'}} />
+
+### Schritt 6: Eine Antwort im Thread senden
+
+Fügen Sie im "Wenn wahr"-Zweig eine **Send Email**-Aktion hinzu. Klicken Sie auf **Advanced options**, dann **Add In-Reply-To**.
+
+| Feld            | Wert                                   |
+| --------------- | -------------------------------------- |
+| **An**          | `{{Find Sender.first.handle}}`         |
+| **Betreff**     | `Re: {{trigger.subject}}`              |
+| **Body**        | `{{AI Triage & Draft Reply.response}}` |
+| **In-Reply-To** | `{{trigger.headerMessageId}}`          |
+
+Das Feld In-Reply-To sorgt dafür, dass dies eine Antwort und keine neue Unterhaltung ist. Der Empfänger sieht sie als Teil des Threads unter der ursprünglichen E-Mail in Gmail, Outlook oder jedem anderen Client.
+
+<img src="/images/user-guide/workflows/auto-reply/send-email.png" style={{width:'100%'}} />
+
+<Tip>
+**In-Reply-To** erwartet eine `message.headerMessageId` aus dem Trigger — das ist der eindeutige Fingerabdruck der E-Mail, keine Empfängeradresse. Wenn Sie es leer lassen, wird die E-Mail trotzdem gesendet, nur als eigenständige Nachricht.
+</Tip>
+
+<Warning>
+Gmail verwendet die Betreffzeile, um Nachrichten in Threads zu gruppieren. Der Betreff **muss** mit `Re:` beginnen (einschließlich Doppelpunkt und Leerzeichen), damit Gmail die Antwort im ursprünglichen Thread anzeigt. Ohne dies erscheint die Antwort als separate Unterhaltung — selbst wenn der In-Reply-To-Header korrekt gesetzt ist.
+</Warning>
+
+### Schritt 7: Testen und aktivieren
+
+Klicken Sie auf **Test**, und prüfen Sie dann Ihren E-Mail-Client. Die Antwort sollte unter der ursprünglichen Nachricht verschachtelt erscheinen.
+
+Aktivieren Sie ihn, wenn Sie zufrieden sind.
+
+## Ideen zum Ausbau
+
+* **Nur an VIPs antworten** — fügen Sie einen Zweig hinzu, der die Domain des Absenders prüft oder ob er in Twenty als Kontakt existiert
+* **Nach Absicht routen** — verwenden Sie separate AI Agent-Prompts, um Vertriebsanfragen anders zu bearbeiten als Supportanfragen
+* **Vor der Antwort anreichern** — fügen Sie einen Schritt Search Records hinzu, um das Unternehmen oder die Deal-Historie des Absenders in den AI-Prompt zu übernehmen, für persönlichere Antworten

packages/twenty-docs/l/de/user-guide/workflows/how-tos/crm-automations/closed-won-automations.mdx

@@ -0,0 +1,179 @@
+---
+title: Closed-Won-Automatisierungen
+description: Automatisieren Sie Post-Win-Aktivitäten, wenn Opportunities abgeschlossen werden.
+---
+
+Wenn ein Deal abgeschlossen wird, müssen mehrere Dinge geschehen: Unternehmensstatus aktualisieren, Teammitglieder benachrichtigen, Onboarding-Aufgaben erstellen. Automatisieren Sie all das mit einem einzigen Workflow.
+
+## Das Problem
+
+Wenn eine Opportunity zu "Closed Won" wechselt:
+
+* Der Unternehmenstyp muss von "Prospect" zu "Customer" geändert werden
+* Onboarding-Aufgaben müssen erstellt werden
+* Das Customer-Success-Team muss benachrichtigt werden
+* Der Vertriebsmitarbeiter benötigt eine Bestätigung
+
+Dies manuell zu erledigen ist zeitaufwendig und fehleranfällig.
+
+## Die Lösung
+
+Erstellen Sie einen Workflow, der alle Post-Win-Aktivitäten automatisch erledigt.
+
+## Vollständige Workflow-Einrichtung
+
+### Schritt 1: Workflow erstellen
+
+1. Gehen Sie zu **Einstellungen → Workflows**
+2. Klicken Sie auf **+ Neuer Workflow**
+3. Benennen Sie ihn "Deal Won - Post-Win Automation"
+
+### Schritt 2: Trigger konfigurieren
+
+1. Wählen Sie **Datensatz wird aktualisiert** aus
+2. Wählen Sie **Opportunities**
+3. Wählen Sie unter "Fields to monitor" **Stage** aus
+
+### Schritt 3: Stage-Filter hinzufügen
+
+1. Fügen Sie eine **Filter**-Aktion hinzu
+2. Bedingung: `{{trigger.object.stage}}` ist gleich "Closed Won"
+
+### Schritt 4: Unternehmenstyp aktualisieren
+
+1. Fügen Sie die Aktion **Datensatz aktualisieren** hinzu
+2. Konfigurieren:
+
+| Feld                       | Wert                            |
+| -------------------------- | ------------------------------- |
+| **Objekt**                 | Unternehmen                     |
+| **Datensatz**              | `{{trigger.object.company.id}}` |
+| **Typ**                    | Kunde                           |
+| **Datum des ersten Deals** | `{{trigger.object.closedAt}}`   |
+| **Kontoinhaber**           | `{{trigger.object.owner.id}}`   |
+
+### Schritt 5: Onboarding-Aufgabe erstellen
+
+1. Fügen Sie die Aktion **Datensatz erstellen** hinzu
+2. Konfigurieren:
+
+| Feld                        | Wert                                                                                             |
+| --------------------------- | ------------------------------------------------------------------------------------------------ |
+| **Objekt**                  | Aufgaben                                                                                         |
+| **Titel**                   | `Onboarding: {{trigger.object.name}}`                                                            |
+| **Zuständiger**             | Mitglied des Customer-Success-Teams                                                              |
+| **Fälligkeitsdatum**        | In 3 Tagen                                                                                       |
+| **Priorität**               | Hoch                                                                                             |
+| **Zugehöriges Unternehmen** | `{{trigger.object.company.id}}`                                                                  |
+| **Zugehörige Opportunity**  | `{{trigger.object.id}}`                                                                          |
+| **Beschreibung**            | `Neukunden-Onboarding für {{trigger.object.company.name}}. Deal-Wert: {{trigger.object.amount}}` |
+
+### Schritt 6: Customer Success benachrichtigen
+
+1. Fügen Sie eine **E-Mail senden**-Aktion hinzu
+2. Konfigurieren:
+
+| Feld        | Wert                                              |
+| ----------- | ------------------------------------------------- |
+| **An**      | customer-success@yourcompany.com                  |
+| **Betreff** | `🎉 Neuer Kunde: {{trigger.object.company.name}}` |
+| **Inhalt**  | Siehe Beispiel unten                              |
+
+**Beispiel für den E-Mail-Text**:
+
+```
+Hi CS Team,
+
+We have a new customer!
+
+Company: {{trigger.object.company.name}}
+Deal: {{trigger.object.name}}
+Value: {{trigger.object.amount}}
+Sales Rep: {{trigger.object.owner.name}}
+Close Date: {{trigger.object.closedAt}}
+
+An onboarding task has been created automatically.
+
+Let's give them a great start!
+```
+
+### Schritt 7: Bestätigung an Vertriebsmitarbeiter senden
+
+1. Fügen Sie eine weitere **E-Mail senden**-Aktion hinzu
+2. Konfigurieren:
+
+| Feld        | Wert                                                                                                                                |
+| ----------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| **An**      | `{{trigger.object.owner.email}}`                                                                                                    |
+| **Betreff** | `✅ Deal abgeschlossen: {{trigger.object.name}}`                                                                                     |
+| **Inhalt**  | Herzlichen Glückwunsch! Ihr Deal wurde verarbeitet. Das Customer-Success-Team wurde benachrichtigt und das Onboarding hat begonnen. |
+
+### Schritt 8: Testen und aktivieren
+
+1. Testen Sie, indem Sie eine Test-Opportunity auf "Closed Won" verschieben
+2. Verifizieren:
+   * Unternehmenstyp auf "Customer" geändert
+   * Onboarding-Aufgabe erstellt
+   * CS-Team hat E-Mail erhalten
+   * Vertriebsmitarbeiter hat Bestätigung erhalten
+3. Aktivieren Sie, sobald alles bereit ist
+
+## Closed Lost behandeln
+
+Erstellen Sie einen ähnlichen Workflow für verlorene Deals:
+
+### Auslöser
+
+* Datensatz wird aktualisiert (Opportunities, Stage = "Closed Lost")
+
+### Aktionen
+
+1. **Datensatz erstellen**: Aufgabe für "Lost Deal Analysis"
+2. **Datensatz aktualisieren**: Grund für verlorenen Deal zum Unternehmensdatensatz hinzufügen
+3. **E-Mail senden**: Manager über verlorenen Deal benachrichtigen
+
+## Erweitert: Mehrstufiges Onboarding
+
+Für komplexes Onboarding mehrere Aufgaben erstellen:
+
+```javascript
+export const main = async (params) => {
+  const tasks = [
+    { title: "Welcome call", daysFromNow: 1, assignee: "CS" },
+    { title: "Send onboarding materials", daysFromNow: 2, assignee: "CS" },
+    { title: "Technical setup", daysFromNow: 5, assignee: "Support" },
+    { title: "30-day check-in", daysFromNow: 30, assignee: "CS" }
+  ];
+
+  return { tasks };
+};
+```
+
+Verwenden Sie **Iterator**, um jede Aufgabe aus dem Array zu erstellen.
+
+## Ideen zur Anpassung
+
+### Halten Sie Ihre anderen Tools auf dem neuesten Stand
+
+* Kunden im Abrechnungssystem per **HTTP Request** erstellen
+
+### Bedingte Aktionen
+
+Verwenden Sie **Filter**-Aktionen, um:
+
+* Unterschiedliches Onboarding für Enterprise vs. SMB
+* Unterschiedliche Zuständige je nach Region
+* Benachrichtigungen für kleine Deals überspringen
+
+### Deal-Details einbeziehen
+
+Verwenden Sie die **Code**-Aktion, um zu formatieren:
+
+* Dokumente zur Deal-Zusammenfassung
+* Übergabenotizen für das CS-Team
+* Individuelle Onboarding-Checklisten
+
+## Verwandt
+
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [E-Mails aus Workflows senden](/l/de/user-guide/workflows/capabilities/send-emails-from-workflows)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/crm-automations/detect-stale-opportunities.mdx

@@ -0,0 +1,136 @@
+---
+title: Ruhende Gelegenheiten erkennen
+description: Manager automatisch benachrichtigen, wenn Gelegenheiten nicht aktualisiert wurden.
+---
+
+Halten Sie Ihre Pipeline gesund, indem Sie Manager benachrichtigen, wenn Gelegenheiten ruhend werden. Dieser Workflow prüft Gelegenheiten, die seit einer festgelegten Anzahl von Tagen nicht aktualisiert wurden.
+
+## Das Problem
+
+Nicht aktualisierte Gelegenheiten führen zu:
+
+* Erkaltende Deals
+* Unzuverlässige Prognosen
+* Entgangener Umsatz
+
+## Die Lösung
+
+Erstellen Sie einen geplanten Workflow, der ruhende Gelegenheiten findet und deren Manager per E-Mail benachrichtigt.
+
+## Schritt-für-Schritt-Einrichtung
+
+### Schritt 1: Workflow erstellen
+
+1. Gehen Sie zu **Einstellungen → Workflows**
+2. Klicken Sie auf **+ Neuer Workflow**
+3. Benennen Sie ihn "Benachrichtigung für ruhende Gelegenheiten"
+
+### Schritt 2: Trigger konfigurieren
+
+1. Wählen Sie **Nach Zeitplan**
+2. Auf täglich festlegen (z. B. jeden Tag um 8 Uhr)
+
+### Schritt 3: Nach ruhenden Gelegenheiten suchen
+
+1. Fügen Sie die Aktion **Datensätze suchen** hinzu
+2. Konfigurieren:
+
+| Feld       | Wert                                                 |
+| ---------- | ---------------------------------------------------- |
+| **Objekt** | Opportunities                                        |
+| **Filter** | Aktualisiert am ist vor (heute - 7 Tage)             |
+| **Filter** | Phase ist nicht "Closed Won" UND nicht "Closed Lost" |
+| **Limit**  | 100                                                  |
+
+### Schritt 4: Prüfen, ob Einträge gefunden wurden
+
+1. Fügen Sie eine **Filter**-Aktion hinzu
+2. Bedingung: `{{searchRecords.length}}` ist größer als 0
+3. Wenn keine ruhenden Gelegenheiten vorhanden sind, endet der Workflow hier
+
+### Schritt 5: Benachrichtigung formatieren (Code-Aktion)
+
+Fügen Sie eine **Code**-Aktion hinzu, um die E-Mail zu formatieren:
+
+```javascript
+export const main = async (params) => {
+  const opportunities = params.opportunities;
+
+  // Group opportunities by owner
+  const byOwner = {};
+  opportunities.forEach(opp => {
+    const ownerEmail = opp.owner?.email || 'unassigned';
+    if (!byOwner[ownerEmail]) {
+      byOwner[ownerEmail] = [];
+    }
+    byOwner[ownerEmail].push({
+      name: opp.name,
+      amount: opp.amount,
+      lastUpdated: opp.updatedAt,
+      stage: opp.stage
+    });
+  });
+
+  // Format summary for manager
+  let summary = "Stale Opportunities Report\n\n";
+  Object.entries(byOwner).forEach(([owner, opps]) => {
+    summary += `${owner}: ${opps.length} stale opportunities\n`;
+    opps.forEach(opp => {
+      summary += `  - ${opp.name} (${opp.stage})\n`;
+    });
+    summary += "\n";
+  });
+
+  return {
+    summary,
+    totalCount: opportunities.length
+  };
+};
+```
+
+### Schritt 6: Benachrichtigungs-E-Mail senden
+
+Fügen Sie eine **E-Mail senden**-Aktion hinzu:
+
+| Feld        | Wert                                                                    |
+| ----------- | ----------------------------------------------------------------------- |
+| **An**      | sales-manager@yourcompany.com                                           |
+| **Betreff** | `🚨 {{code.totalCount}} ruhende Gelegenheiten erfordern Aufmerksamkeit` |
+| **Inhalt**  | `{{code.summary}}`                                                      |
+
+### Schritt 7: Testen und aktivieren
+
+1. Klicken Sie auf **Test**, um den Workflow auszuführen
+2. Überprüfen Sie, dass die E-Mail die richtigen Daten enthält
+3. Aktivieren Sie, sobald alles bereit ist
+
+## Anpassungsoptionen
+
+### Schwellenwert für Inaktivität ändern
+
+Passen Sie den Filter der Aktion Datensätze suchen an, um statt 7 Tagen Ihren bevorzugten Zeitraum zu verwenden:
+
+* 3 Tage für schnelllebige Verkäufe
+* 14 Tage für Enterprise-Deals
+* 30 Tage für lange Verkaufszyklen
+
+### Einzelne Vertriebsmitarbeiter benachrichtigen
+
+Verwenden Sie statt einer einzelnen Manager-E-Mail den **Iterator**, um jedem Vertriebsmitarbeiter personalisierte E-Mails zu seinen eigenen ruhenden Deals zu senden.
+
+### Eskalation hinzufügen
+
+Erstellen Sie mehrere Workflows mit zunehmender Dringlichkeit:
+
+1. Tag 7: E-Mail an den Vertriebsmitarbeiter
+2. Tag 14: E-Mail an Vertriebsmitarbeiter + Manager
+3. Tag 21: Aufgabe für den Manager erstellen, um einzugreifen
+
+### In Slack einbinden
+
+Verwenden Sie **HTTP Request**, um an einen Slack-Webhook zu posten, anstelle von oder zusätzlich zu E-Mail.
+
+## Verwandt
+
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [E-Mails aus Workflows senden](/l/de/user-guide/workflows/capabilities/send-emails-from-workflows)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/crm-automations/display-number-of-emails-received.mdx

@@ -0,0 +1,69 @@
+---
+title: Anzahl empfangener E-Mails anzeigen
+description: Erstellen Sie einen Workflow, der automatisch die Anzahl der von jedem Kontakt empfangenen E-Mails zählt und anzeigt.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<img src="/images/user-guide/workflows/workflow-number-of-emails-received.png" style={{width:'100%'}} />
+
+## Übersicht
+
+Dieser Workflow wird jedes Mal ausgelöst, wenn eine neue E-Mail eingeht, und aktualisiert ein benutzerdefiniertes Feld im Personendatensatz mit der Gesamtanzahl der E-Mails dieses Absenders.
+
+## Voraussetzungen
+
+Erstellen Sie vor der Einrichtung dieses Workflows ein benutzerdefiniertes Feld am Objekt **People**:
+
+1. Gehen Sie zu **Einstellungen → Datenmodell → People**
+2. Fügen Sie ein neues Feld vom Typ **Number** hinzu
+3. Nennen Sie es etwa "Anzahl der von dieser Person empfangenen E-Mails"
+
+## Schritt-für-Schritt-Einrichtung
+
+<VimeoEmbed videoId="1148700336" title="Video-Demonstration" />
+
+### Schritt 1: Trigger konfigurieren
+
+1. Gehen Sie zu **Workflows** und erstellen Sie einen neuen Workflow
+2. Wählen Sie **Record is Created** als Auslöser
+3. Wählen Sie **Message Participants** (verfügbar unter Advanced objects)
+
+<Note>
+Ein Message Participant ist eine Kombination aus einer Nachrichten-ID und einer Personen-ID und erzeugt einen eindeutigen Datensatz pro Nachricht. Dies ist einfacher nachzuverfolgen als die Nachrichten direkt, da wir auf das Feld `handle` zugreifen können, das die E-Mail-Adresse des Absenders (oder Empfängers) enthält.
+</Note>
+
+### Schritt 2: Nach Rolle filtern
+
+1. Fügen Sie eine **Filter**-Aktion hinzu
+2. Legen Sie die Bedingung fest: **Role** ist gleich **FROM**
+
+So stellen Sie sicher, dass Sie nur Nachrichten zählen, die von dieser Person gesendet wurden, nicht Nachrichten, die an sie gesendet wurden.
+
+### Schritt 3: Alle Message Participants mit demselben Handle suchen
+
+1. Fügen Sie eine **Datensätze suchen**-Aktion hinzu
+2. Wählen Sie **Message Participants** als Objekt
+3. Fügen Sie Filter hinzu: **Handle** entspricht dem Handle aus dem Trigger (der E-Mail-Adresse des Absenders) und **Role** ist gleich **FROM**
+4. Erhöhen Sie das **Limit** von 1 auf **200** (das Maximum)
+
+Dadurch werden alle Nachrichten von dieser E-Mail-Adresse gefunden, um die Gesamtanzahl zu erhalten.
+
+<Note>
+Die Aktion Datensätze suchen ist auf die Rückgabe von maximal 200 Datensätzen beschränkt. Da Sie jedoch nur den Wert `totalCount` verwenden (nicht die einzelnen Datensätze), liefert dieser Schritt die Gesamtanzahl der von dieser Person gesendeten E-Mails.
+</Note>
+
+### Schritt 4: Den Personendatensatz mit einer Create or Update Record-Aktion aktualisieren
+
+1. Fügen Sie eine **Create or Update Record**-Aktion hinzu
+2. Wählen Sie **People** als Objekt
+3. Finden Sie die Person, indem Sie ihre E-Mail-Adresse mit dem `handle` des Message Participant abgleichen.
+4. Setzen Sie Ihr benutzerdefiniertes Feld "Anzahl empfangener E-Mails" auf `{{searchRecords.totalCount}}`
+
+Der Wert `totalCount` aus der Aktion Datensätze suchen steht für die Gesamtanzahl der von dieser Person empfangenen E-Mails.
+
+## Verwandt
+
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [Benutzerdefinierte Felder erstellen](/l/de/user-guide/data-model/how-tos/customize-your-data-model)
+* [Aktion Datensätze suchen](/l/de/user-guide/workflows/capabilities/workflow-actions#search-records)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/crm-automations/display-related-record-data.mdx

@@ -0,0 +1,170 @@
+---
+title: Daten verknüpfter Datensätze anzeigen
+description: Zeigen Sie mithilfe von Workflows Daten aus verknüpften Datensätzen an (z. B. Unternehmensinformationen in Opportunities).
+---
+
+Zeigen Sie Daten aus verknüpften Datensätzen direkt in Ihren Datensätzen an — zum Beispiel die Mitarbeiterzahl eines Unternehmens in dessen Opportunities. Dieser Workflow-Workaround ist hilfreich, bis verschachtelte Felder nativ verfügbar sind.
+
+## Häufige Anwendungsfälle
+
+| Quelle      | Ziel        | Zu kopierende Felder                                |
+| ----------- | ----------- | --------------------------------------------------- |
+| Unternehmen | Opportunity | Branche, Unternehmensgröße, ARR                     |
+| Person      | Opportunity | E-Mail, Telefon, Position                           |
+| Opportunity | Unternehmen | Betrag des letzten Deals, Datum des letzten Gewinns |
+
+## Einfache Feldkopie
+
+### Beispiel: Kontakt-E-Mail in die Opportunity kopieren
+
+**Ziel**: Wenn bei einer Opportunity ein Ansprechpartner festgelegt wird, soll dessen E-Mail für den schnellen Zugriff in die Opportunity kopiert werden.
+
+### Voraussetzung
+
+Erstellen Sie die Zielfelder in **Settings → Data Model → Opportunities**, bevor Sie den Workflow erstellen:
+
+* Kontakt-E-Mail (Typ: E-Mail)
+* Kontakt-Telefon (Typ: Telefon)
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird aktualisiert (Opportunities, Feld Ansprechpartner)
+
+2. **Filter**: Prüfen, dass der Ansprechpartner nicht leer ist
+
+3. **Datensätze durchsuchen**: Verknüpfte Person finden
+   * Objekt: People
+   * Filter: ID entspricht `{{trigger.object.pointOfContact.id}}`
+
+4. **Datensatz aktualisieren**:
+   * Objekt: Opportunities
+   * Datensatz: `{{trigger.object.id}}`
+   * Kontakt-E-Mail: `{{searchRecords[0].email}}`
+   * Kontakt-Telefon: `{{searchRecords[0].phone}}`
+
+## Mehrere Felder kopieren
+
+### Beispiel: Unternehmensinformationen mit allen verknüpften Opportunities synchronisieren
+
+**Ziel**: Wenn sich Unternehmensdetails ändern, alle verknüpften Opportunities aktualisieren.
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird aktualisiert (Companies)
+   * Felder: Branche, Unternehmensgröße, Jahresumsatz
+
+2. **Datensätze durchsuchen**: Alle Opportunities für dieses Unternehmen finden
+   * Objekt: Opportunities
+   * Filter: Unternehmens-ID entspricht `{{trigger.object.id}}`
+
+3. **Iterator**: Jede Opportunity durchlaufen
+
+4. **Datensatz aktualisieren** (innerhalb des Iterators):
+   * Objekt: Opportunities
+   * Datensatz: `{{iterator.currentItem.id}}`
+   * Unternehmensbranche: `{{trigger.object.industry}}`
+   * Unternehmensgröße: `{{trigger.object.companySize}}`
+   * Unternehmens-ARR: `{{trigger.object.annualRevenue}}`
+
+## Kopieren bei der Datensatzerstellung
+
+### Beispiel: Opportunity mit Unternehmensdaten vorbefüllen
+
+**Ziel**: Beim Erstellen einer Opportunity, die mit einem Unternehmen verknüpft ist, werden wichtige Unternehmensinformationen automatisch kopiert.
+
+### Voraussetzung
+
+Erstellen Sie die Zielfelder in **Settings → Data Model → Opportunities**:
+
+* Unternehmensbranche (Typ: Text)
+* Unternehmensgröße (Typ: Zahl)
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird erstellt (Opportunities)
+   * Filter: Unternehmen ist nicht leer
+
+2. **Datensätze durchsuchen**: Details des verknüpften Unternehmens abrufen
+   * Objekt: Companies
+   * Filter: ID entspricht `{{trigger.object.company.id}}`
+
+3. **Datensatz aktualisieren**:
+   * Objekt: Opportunities
+   * Datensatz: `{{trigger.object.id}}`
+   * Unternehmensbranche: `{{searchRecords[0].industry}}`
+   * Unternehmensgröße: `{{searchRecords[0].employees}}`
+
+<Note>
+**Einschränkung bei Aufgaben und Notizen**: Beziehungen bei Aufgaben und Notizen sind fest als Viele-zu-Viele implementiert und stehen in Workflow-Auslösern oder -Aktionen noch nicht zur Verfügung. Um auf diese Beziehungen zuzugreifen, verwenden Sie stattdessen die [API](/l/de/developers/extend/api).
+</Note>
+
+## Bidirektionale Synchronisierung
+
+### Beispiel: Hauptansprechpartner synchron halten
+
+**Ziel**: Wenn sich der Hauptansprechpartner eines Unternehmens ändert, den Kontakt aktualisieren. Wenn eine Person zum Hauptansprechpartner wird, das Unternehmen aktualisieren.
+
+### Workflow 1: Unternehmen → Person
+
+1. **Auslöser**: Datensatz wird aktualisiert (Companies, Feld Hauptansprechpartner)
+2. **Datensatz aktualisieren**: Beim Kontakt "Is Primary Contact" auf true setzen
+3. **Datensätze durchsuchen**: Vorherigen Hauptansprechpartner finden
+4. **Datensatz aktualisieren**: Beim vorherigen Kontakt "Is Primary Contact" auf false setzen
+
+### Workflow 2: Person → Unternehmen
+
+1. **Auslöser**: Datensatz wird aktualisiert (People, Is Primary Contact = true)
+2. **Datensatz aktualisieren**: Den Hauptansprechpartner des Unternehmens auf diese Person setzen
+
+<Note>
+Seien Sie bei bidirektionalen Synchronisierungen vorsichtig, um Endlosschleifen zu vermeiden. Verwenden Sie Filter, um vor dem Aktualisieren zu prüfen, ob sich der Wert tatsächlich geändert hat.
+</Note>
+
+## Code für komplexe Zuordnungen verwenden
+
+### Beispiel: Daten beim Kopieren transformieren
+
+**Ziel**: Telefonnummer von Person zur Opportunity kopieren und formatieren.
+
+```javascript
+export const main = async (params) => {
+  const { phone } = params;
+
+  if (!phone) return { formattedPhone: null };
+
+  // Remove non-numeric characters
+  const digits = phone.replace(/\D/g, '');
+
+  // Format as (XXX) XXX-XXXX
+  const formatted = digits.length === 10
+    ? `(${digits.slice(0,3)}) ${digits.slice(3,6)}-${digits.slice(6)}`
+    : phone;
+
+  return { formattedPhone: formatted };
+};
+```
+
+## Beste Praktiken
+
+### Schleifen vermeiden
+
+* Erstellen Sie keine Workflows, die sich gegenseitig endlos auslösen
+* Spezifische Feldbedingungen verwenden
+* Prüfungen hinzufügen, ob sich der Wert tatsächlich geändert hat
+
+### Fehlende Daten behandeln
+
+* Vor dem Kopieren stets prüfen, ob der Quelldatensatz existiert
+* Standardwerte für optionale Felder bereitstellen
+* Filter verwenden, um zu überspringen, wenn das Quellfeld leer ist
+
+### Leistung
+
+* Updates bündeln, wenn in viele Datensätze kopiert wird
+* Geplante Workflows für Massensynchronisierungen verwenden
+* Erwägen Sie die Verwendung von Iterator für mehrere Datensatzaktualisierungen
+
+## Verwandt
+
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/crm-automations/formula-fields.mdx

@@ -0,0 +1,202 @@
+---
+title: Formelfelder
+description: Erstellen Sie Formelfelder mithilfe von Workflows, bis native Unterstützung verfügbar ist.
+---
+
+Zwanzig unterstützen noch keine Formelfelder (ab 2026), aber Sie können das gleiche Ergebnis mit Workflows erzielen. Mit diesem Workaround können Sie Feldwerte automatisch berechnen und ausfüllen – von einfachen Verkettungen bis hin zu komplexer Geschäftslogik.
+
+## Häufige Anwendungsfälle
+
+| Anwendungsfall              | Formelbeispiel                          |
+| --------------------------- | --------------------------------------- |
+| **Vollständiger Name**      | Vorname + " " + Nachname                |
+| **Erwarteter Betrag**       | Betrag × Wahrscheinlichkeit             |
+| **Tage bis zur Fälligkeit** | Fälligkeitsdatum - Heute                |
+| **Tage in der Phase**       | Heute - Phaseneintrittsdatum            |
+| **Lead-Score**              | Punkte basierend auf mehreren Kriterien |
+
+<Tip>
+Ein vollständiges Beispiel für das Nachverfolgen der Zeit in Pipeline-Phasen finden Sie unter [Verfolgen, wie lange Chancen in jeder Phase bleiben](/l/de/user-guide/views-pipelines/how-tos/track-time-in-stage).
+</Tip>
+
+## Einfache Formel: Verkettung
+
+### Beispiel: Vollständigen Namen automatisch ausfüllen
+
+**Ziel**: Vor- und Nachname automatisch zu einem Feld für den vollständigen Namen kombinieren.
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird aktualisiert oder erstellt (Personen)
+
+2. **Filter**: Prüfen, ob sich Vorname oder Nachname geändert hat
+
+3. **Code-Aktion**:
+
+```javascript
+export const main = async (params) => {
+  const { firstName, lastName } = params;
+
+  const fullName = [firstName, lastName]
+    .filter(Boolean)
+    .join(' ');
+
+  return { fullName };
+};
+```
+
+4. **Datensatz aktualisieren**: Vollständigen Namen auf `{{code.fullName}}` setzen
+
+## Numerische Formel: Erwarteter Betrag
+
+### Beispiel: Erwarteten Umsatz berechnen
+
+**Ziel**: Den Chancenbetrag mit der Wahrscheinlichkeit multiplizieren, um den erwarteten Betrag zu erhalten.
+
+Den vollständigen Workflow finden Sie unter [Erwarteten Betrag in der Pipeline anzeigen](/l/de/user-guide/views-pipelines/how-tos/show-expected-amount-in-pipeline).
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird aktualisiert (Chancen, Feld Betrag ODER Wahrscheinlichkeit)
+
+2. **Code-Aktion**:
+
+```javascript
+export const main = async (params) => {
+  const { amount, probability } = params;
+
+  const expectedAmount = (amount || 0) * (probability || 0) / 100;
+
+  return { expectedAmount };
+};
+```
+
+3. **Datensatz aktualisieren**: Erwarteten Betrag auf `{{code.expectedAmount}}` setzen
+
+## Datumsformel: Tagesberechnung
+
+### Beispiel: Tage bis zur Fälligkeit einer Aufgabe
+
+**Ziel**: Berechnen, wie viele Tage bis zum Fälligkeitsdatum einer Aufgabe verbleiben.
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird aktualisiert oder erstellt (Aufgaben, Feld Fälligkeitsdatum)
+
+2. **Code-Aktion**:
+
+```javascript
+export const main = async (params) => {
+  const { dueDate } = params;
+
+  if (!dueDate) {
+    return { daysUntilDue: null };
+  }
+
+  const due = new Date(dueDate);
+  const today = new Date();
+  const diffTime = due - today;
+  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+
+  return { daysUntilDue: diffDays };
+};
+```
+
+3. **Datensatz aktualisieren**: Tage bis zur Fälligkeit auf `{{code.daysUntilDue}}` setzen
+
+<Note>
+Negative Werte weisen auf überfällige Aufgaben hin. Sie können dieses Feld verwenden, um Aufgaben nach Dringlichkeit zu filtern oder zu sortieren.
+</Note>
+
+## Bedingte Formel: Lead-Score
+
+### Beispiel: Lead-Score anhand von Kriterien berechnen
+
+**Ziel**: Leads anhand von Unternehmensgröße, Branche und Engagement bewerten.
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird aktualisiert (Personen oder Unternehmen)
+
+2. **Code-Aktion**:
+
+```javascript
+export const main = async (params) => {
+  const { companySize, industry, hasEmail, hasPhone, source } = params;
+
+  let score = 0;
+
+  // Company size scoring
+  if (companySize === 'Enterprise') score += 30;
+  else if (companySize === 'Mid-Market') score += 20;
+  else if (companySize === 'SMB') score += 10;
+
+  // Industry scoring
+  const targetIndustries = ['Technology', 'Finance', 'Healthcare'];
+  if (targetIndustries.includes(industry)) score += 25;
+
+  // Contact info scoring
+  if (hasEmail) score += 10;
+  if (hasPhone) score += 15;
+
+  // Source scoring
+  if (source === 'Referral') score += 20;
+  else if (source === 'Website') score += 10;
+
+  return { leadScore: score };
+};
+```
+
+3. **Datensatz aktualisieren**: Lead-Score auf `{{code.leadScore}}` setzen
+
+## Textformel: Domain-Extraktion
+
+### Beispiel: Domain aus E-Mail extrahieren
+
+**Ziel**: Die E-Mail-Domain automatisch extrahieren und speichern.
+
+### Einrichtung
+
+1. **Auslöser**: Datensatz wird aktualisiert (Personen, E-Mail-Feld)
+
+2. **Code-Aktion**:
+
+```javascript
+export const main = async (params) => {
+  const { email } = params;
+
+  if (!email) return { domain: null };
+
+  const domain = email.split('@')[1]?.toLowerCase();
+
+  return { domain };
+};
+```
+
+3. **Datensatz aktualisieren**: Feld Domain auf `{{code.domain}}` setzen
+
+## Beste Praktiken
+
+### Leistung
+
+* Nur bei relevanten Feldänderungen auslösen
+* Filter verwenden, um Datensätze ohne Berechnungsbedarf zu überspringen
+* Komplexe Berechnungen in Workflows mit hohem Volumen vermeiden
+
+### Fehlerbehandlung
+
+* Vor Berechnungen auf null/undefined-Werte prüfen
+* Standardwerte verwenden, wenn Daten fehlen
+* Klare Fehlermeldungen zurückgeben, wenn Berechnungen fehlschlagen
+
+### Tests
+
+* Mit Randfällen testen (leere Felder, Nullwerte)
+* Berechnungen vor der Aktivierung manuell überprüfen
+* Workflow-Ausführungen auf unerwartete Ergebnisse überwachen
+
+## Verwandt
+
+* [Erwarteten Betrag in der Pipeline anzeigen](/l/de/user-guide/views-pipelines/how-tos/show-expected-amount-in-pipeline)
+* [Zeit in der Phase nachverfolgen](/l/de/user-guide/views-pipelines/how-tos/track-time-in-stage)
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/crm-automations/notify-teammates-of-note-to-review.mdx

@@ -0,0 +1,127 @@
+---
+title: Teammitglieder über eine zu prüfende Notiz benachrichtigen
+description: Senden Sie automatische E-Mail-Benachrichtigungen, wenn Sie einem Kollegen die Überprüfung einer Notiz zuweisen.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<Note>
+**Das direkte Taggen von Teammitgliedern in Notizen wird noch nicht unterstützt.** Diese Funktion ist für die zweite Jahreshälfte 2026 geplant. In der Zwischenzeit bietet dieser Workflow einen praktischen Workaround.
+</Note>
+
+## Die Herausforderung
+
+Sie möchten einen Kollegen in einer Notiz taggen, damit er eine Benachrichtigung zur Überprüfung erhält. Derzeit unterstützt Twenty keine @-Erwähnungen in Notizen oder Aufgaben.
+
+## Der Workaround
+
+Anstatt im Notiztext zu taggen, können Sie:
+
+1. Erstellen Sie ein **Reviewer**-Beziehungsfeld im Objekt Notizen
+2. Weisen Sie den Reviewer beim Erstellen oder Bearbeiten der Notiz zu
+3. Lassen Sie einen Workflow automatisch eine E-Mail an den Prüfer mit einem Link zur Notiz senden
+
+<Warning>
+**Einschränkung**: Mit diesem Ansatz kann pro Feld nur ein Reviewer zugewiesen werden. Wenn Sie mehrere Personen benachrichtigen müssen, erstellen Sie zusätzliche Beziehungsfelder (z. B. Reviewer 1, Reviewer 2). Das skaliert nicht gut, wenn Sie viele Teammitglieder auf einmal taggen müssen.
+</Warning>
+
+## Schritt-für-Schritt-Einrichtung
+
+### Schritt 1: Reviewer-Feld erstellen
+
+<img src="/images/user-guide/workflows/reviewer-field-for-note.png" style={{width:'100%'}} />
+
+1. Gehen Sie zu **Einstellungen → Datenmodell → Notizen**
+2. Klicken Sie auf **Feld hinzufügen**
+3. Konfigurieren:
+
+| Einstellung            | Wert                                        |
+| ---------------------- | ------------------------------------------- |
+| **Name**               | Reviewer                                    |
+| **Typ**                | Beziehung                                   |
+| **Verknüpftes Objekt** | Arbeitsbereichsmitglied                     |
+| **Beziehungstyp**      | Viele Notizen → Ein Arbeitsbereichsmitglied |
+
+4. Speichern Sie das Feld
+
+### Schritt 2: Workflow erstellen
+
+<VimeoEmbed videoId="1151897168" title="Video-Demonstration" />
+
+#### Workflow-Trigger erstellen
+
+1. Gehen Sie zur Hauptansicht und erstellen Sie einen neuen Workflow
+2. Wählen Sie **Record Updated** als Auslöser
+3. Wählen Sie **Note** als Objekt und geben Sie das Reviewer-Feld an.
+4. Dadurch wird der Workflow immer dann ausgelöst, wenn der Reviewer einer Notiz aktualisiert wird.
+
+#### Filter hinzufügen, um zu prüfen, ob der Reviewer gerade zugewiesen wurde
+
+Fügen Sie eine **Filter**-Aktion hinzu, damit der Workflow nur fortgesetzt wird, wenn ein Reviewer zugewiesen ist:
+
+| Bedingung    | Wert           |
+| ------------ | -------------- |
+| **Reviewer** | ist nicht leer |
+
+#### Nach dem Arbeitsbereichsmitglied suchen
+
+1. Fügen Sie eine **Datensätze suchen**-Aktion hinzu
+2. Wählen Sie **Arbeitsbereichsmitglied** (unter Erweiterten Objekten)
+3. Fügen Sie einen Filter hinzu:
+
+| Bedingung | Wert                             |
+| --------- | -------------------------------- |
+| **ID**    | entspricht `{{note.reviewerId}}` |
+
+Dadurch wird der vollständige Datensatz des Arbeitsbereichsmitglieds abgerufen, einschließlich der E-Mail-Adresse und des Namens.
+
+#### Benachrichtigungs-E-Mail senden
+
+1. Fügen Sie eine **E-Mail senden**-Aktion hinzu
+2. Konfigurieren:
+
+| Feld        | Wert                                                                |
+| ----------- | ------------------------------------------------------------------- |
+| **An**      | Datensatz suchen → Erstes Arbeitsbereichsmitglied → Benutzer-E-Mail |
+| **Betreff** | Eine Notiz benötigt Ihre Überprüfung                                |
+| **Inhalt**  | Siehe Beispiel unten                                                |
+
+**Beispiel für den E-Mail-Text:**
+
+```text
+Hi {{searchRecord.firstWorkspaceMember.name.firstName}},
+
+You've been assigned to review a note.
+
+View the note here:
+https://yourSubDomain.twenty.com/object/note/{{recordIsUpdated.id}}
+
+Best,
+Twenty
+```
+
+<Note>
+Ersetzen Sie `yourSubDomain` durch die tatsächliche Subdomain Ihres Twenty-Arbeitsbereichs.
+</Note>
+
+#### Testen und Aktivieren
+
+1. Klicken Sie auf **Test**, um den Workflow manuell auszuführen
+2. Erstellen oder bearbeiten Sie eine Notiz und weisen Sie einen Reviewer zu
+3. Prüfen Sie den Posteingang des Reviewers auf die Benachrichtigungs-E-Mail
+4. Aktivieren Sie den Workflow
+
+## Verwendung
+
+Sobald eingerichtet, kann Ihr Team diesen Workflow wie folgt verwenden:
+
+1. Erstellen einer neuen Notiz (oder Bearbeiten einer bestehenden)
+2. Auswählen eines Kollegen im Feld **Reviewer**
+3. Der Kollege erhält automatisch eine E-Mail mit einem direkten Link zur Notiz
+
+## Verwandt
+
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)
+* [E-Mails aus Workflows senden](/l/de/user-guide/workflows/capabilities/send-emails-from-workflows)
+* [Benutzerdefinierte Felder erstellen](/l/de/user-guide/data-model/how-tos/create-custom-fields)
+* [Beziehungsfelder erstellen](/l/de/user-guide/data-model/how-tos/create-relation-fields)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/crm-automations/send-email-alerts-with-tasks-due.mdx

@@ -0,0 +1,106 @@
+---
+title: E-Mail-Benachrichtigungen zu fälligen Aufgaben senden
+description: Benachrichtigen Sie Teammitglieder automatisch über ihre anstehenden oder überfälligen Aufgaben.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<img src="/images/user-guide/workflows/email_tasks_due.png" style={{width:'100%'}} />
+
+Senden Sie tägliche E-Mail-Erinnerungen an jedes Teammitglied zu den heute fälligen Aufgaben.
+
+## Übersicht
+
+Dieser Workflow läuft nach einem Zeitplan und:
+
+1. Ruft alle Mitglieder des Arbeitsbereichs ab
+2. Durchläuft jedes Mitglied
+3. Ermittelt deren heute fällige Aufgaben
+4. Formatiert und sendet eine personalisierte E-Mail
+
+## Schritt-für-Schritt-Einrichtung
+
+<VimeoEmbed videoId="1147463514" title="Video-Demonstration" />
+
+### Schritt 1: Trigger konfigurieren
+
+1. Gehen Sie zu **Einstellungen → Workflows** und erstellen Sie einen neuen Workflow
+2. Wählen Sie **Nach Zeitplan** als Trigger
+3. Verwenden Sie einen Cron-Ausdruck für täglich um 8:00 Uhr: `0 8 * * *`
+
+### Schritt 2: Nach allen Arbeitsbereichsmitgliedern suchen
+
+1. Fügen Sie eine **Datensätze suchen**-Aktion hinzu
+2. Wählen Sie **Arbeitsbereichsmitglieder** (unter Erweiterten Objekten)
+3. Keine Filter erforderlich — dadurch werden alle Mitglieder zurückgegeben
+
+### Schritt 3: Einen Iterator hinzufügen
+
+1. Fügen Sie eine **Iterator**-Aktion hinzu
+2. Setzen Sie das Eingabearray auf die Arbeitsbereichsmitglieder aus dem vorherigen Schritt
+3. Alle Aktionen innerhalb des Iterators werden einmal pro Mitglied ausgeführt
+
+### Schritt 4: Nach heute fälligen Aufgaben suchen (im Iterator)
+
+1. Fügen Sie im Iterator eine **Datensätze suchen**-Aktion hinzu
+2. Wählen Sie **Aufgaben** als Objekt
+3. Filter hinzufügen:
+   * **Zuständige Person** = aktuelles Arbeitsbereichsmitglied (aus dem Iterator)
+   * **Fälligkeitsdatum** = heute
+
+### Schritt 5: Aufgaben in E-Mail-Inhalt formatieren (im Iterator)
+
+Fügen Sie eine **Code**-Aktion hinzu, um die Aufgaben in eine lesbare Liste mit Links zu formatieren:
+
+```javascript
+export const main = async (params: {
+  tasksDue?: Array<{ id: string; title: string }> | null | string;
+}) => {
+  const tasksDue =
+    typeof params.tasksDue === "string"
+      ? JSON.parse(params.tasksDue)
+      : params.tasksDue;
+
+  if (!Array.isArray(tasksDue) || tasksDue.length === 0) {
+    return {
+      formattedTasks: "No tasks due today."
+    };
+  }
+
+  const formattedTasks = tasksDue
+    .map(
+      t =>
+        `${t.title}\nhttps://yourSubDomain.twenty.com/object/task/${t.id}`
+    )
+    .join("\n\n");
+
+  return { formattedTasks };
+};
+```
+
+<Note>
+Ersetzen Sie `yourSubDomain` durch die tatsächliche Twenty-Arbeitsbereichs-Subdomain.
+</Note>
+
+### Schritt 6: E-Mail senden (im Iterator)
+
+1. Fügen Sie eine **E-Mail senden**-Aktion hinzu (weiterhin im Iterator)
+2. Konfigurieren:
+
+| Feld        | Wert                                                                               |
+| ----------- | ---------------------------------------------------------------------------------- |
+| **An**      | `{{iterator.currentItem.userEmail}}` (E-Mail-Adresse des Arbeitsbereichsmitglieds) |
+| **Betreff** | Ihre heute fälligen Aufgaben                                                       |
+| **Inhalt**  | `{{code.formattedTasks}}`                                                          |
+
+### Schritt 7: Testen und aktivieren
+
+1. Klicken Sie auf **Test**, um den Workflow manuell auszuführen
+2. Überprüfen Sie die Posteingänge auf E-Mails
+3. Aktivieren Sie den Workflow
+
+## Verwandt
+
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [E-Mails aus Workflows senden](/l/de/user-guide/workflows/capabilities/send-emails-from-workflows)
+* [Arrays in Code-Aktionen verarbeiten](/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/de/user-guide/workflows/how-tos/need-more-help/professional-services.mdx

@@ -0,0 +1,21 @@
+---
+title: Professionelle Dienstleistungen
+description: Holen Sie sich professionelle Hilfe beim Aufbau komplexer Workflows und Automatisierungen vom Team und den zertifizierten Partnern von Twenty.
+---
+
+## Wann benötigen Sie professionelle Hilfe?
+
+Erwägen Sie professionelle Dienstleistungen für:
+
+* Komplexe Multi-System-Integrationen
+* Erweiterte Geschäftslogik und Automatisierungsregeln
+* Datenverarbeitungs-Workflows im großen Maßstab
+* Entwicklung benutzerdefinierter APIs
+* Schulung des Teams und Optimierung der Workflows
+* Wenn Ihnen interne Ressourcen fehlen
+
+## Dienstleistungsoptionen
+
+### Implementierungspartner
+
+Arbeiten Sie mit zertifizierten Partnern für erweiterte Anpassungen. Kontaktieren Sie uns unter [contact@twenty.com](mailto:contact@twenty.com), um mit unseren [Implementierungspartnern](https://twenty.com/partners) in Kontakt zu treten.

packages/twenty-docs/l/de/user-guide/workflows/how-tos/need-more-help/workflow-troubleshooting.mdx

@@ -0,0 +1,170 @@
+---
+title: Workflow-Fehlerbehebung
+description: Häufige Workflow-Probleme und wie Sie sie beheben.
+---
+
+## Häufige Probleme und Lösungen
+
+### Workflow wird nicht ausgelöst
+
+**Symptome**: Ihr Workflow wird nicht ausgeführt, wenn Sie es erwarten.
+
+**Mögliche Ursachen**:
+
+1. **Workflow nicht aktiviert**: Stellen Sie sicher, dass der Workflow auf "Active" und nicht auf "Draft" gesetzt ist
+2. **Trigger-Bedingungen nicht erfüllt**: Überprüfen Sie, ob der Trigger Ihrem erwarteten Ereignis entspricht
+3. **Feld nicht überwacht**: Bei "Record is Updated"-Triggern stellen Sie sicher, dass das betreffende Feld überwacht wird
+4. **Berechtigungen**: Prüfen Sie, ob Sie die Berechtigung haben, Workflows auszuführen
+
+**Lösungen**:
+
+* Überprüfen Sie den Workflow-Status in der Workflow-Liste
+* Testen Sie mit der spezifischen Aktion, von der Sie erwarten, dass sie ihn auslöst
+* Überprüfen Sie die Trigger-Konfiguration
+* Wenden Sie sich wegen der Berechtigungen an Ihren Administrator
+
+### Workflow-Trigger zu früh (leere Felder)
+
+**Symptome**: Beim manuellen Erstellen eines Datensatzes in der UI wird Ihr Workflow ausgelöst, bevor Sie alle Felder ausfüllen konnten. Der Workflow läuft mit überwiegend leeren Feldwerten.
+
+**Warum das passiert**: Twenty speichert alles in Echtzeit — es gibt keinen separaten "edit"- vs. "read"-Modus. Wenn Sie einen Datensatz erstellen, wird er sofort gespeichert und löst das Ereignis "Record is created" aus, bevor Sie weitere Felder ausfüllen können.
+
+**Wann "Record is created" gut funktioniert**:
+
+* Über API-Aufrufe erstellte Datensätze (Felder werden in einer einzigen Anfrage befüllt)
+* Über Import erstellte Datensätze
+* Automatisches Erstellen von Datensätzen aus anderen Workflows
+
+**Lösung**: Für Datensätze, die manuell in der UI erstellt werden, verwenden Sie stattdessen **"Record is created or updated"** als Trigger. Auf diese Weise:
+
+* Der Workflow wird ausgelöst, nachdem der Benutzer das Ausfüllen und Speichern der Felder abgeschlossen hat
+* Sie erhalten die vollständigen Daten statt leerer Werte
+
+<Tip>
+Wenn der Workflow nur einmal pro Datensatz ausgeführt werden soll, fügen Sie eine Filter-Aktion hinzu, um ein Feld wie `createdAt equals updatedAt` (erste Speicherung) zu prüfen, oder verwenden Sie ein benutzerdefiniertes Kontrollkästchen, um zu verfolgen, ob der Workflow bereits ausgeführt wurde.
+</Tip>
+
+### Fehlgeschlagene Aktionen
+
+**Symptome**: Der Workflow wird ausgeführt, aber einige Aktionen schlagen fehl.
+
+**Mögliche Ursachen**:
+
+1. **Fehlende Daten**: Erforderliche Felder sind leer
+2. **Ungültige Verweise**: Variablen aus vorherigen Schritten existieren nicht
+3. **API-Fehler**: Externe Dienste liefern Fehler zurück
+4. **Berechtigungsprobleme**: Die Aktion erfordert Berechtigungen, die Sie nicht haben
+
+**Lösungen**:
+
+* Überprüfen Sie die Details der Workflow-Ausführung auf Fehlermeldungen
+* Stellen Sie sicher, dass alle Pflichtfelder Werte haben
+* Testen Sie die API-Verbindungen separat
+* Überprüfen Sie die Rollenberechtigungen
+
+### Fehler bei HTTP-Anfragen
+
+**Symptome**: HTTP-Request-Aktionen schlagen fehl oder liefern unerwartete Ergebnisse.
+
+**Häufige Fehlercodes**:
+
+* **400**: Ungültige Anfrage - überprüfen Sie das Format des Request-Body
+* **401**: Nicht autorisiert - überprüfen Sie den API-Schlüssel
+* **403**: Verboten - überprüfen Sie die API-Berechtigungen
+* **404**: Nicht gefunden - überprüfen Sie die Endpunkt-URL
+* **429**: Zu viele Anfragen - implementieren Sie eine Ratenbegrenzung
+* **500**: Serverfehler - Problem mit dem externen Dienst
+
+**Lösungen**:
+
+* Überprüfen Sie die API-Endpunkt-URL
+* Überprüfen Sie die Authentifizierungs-Header
+* Testen Sie den API-Aufruf zunächst außerhalb von Twenty
+* Fügen Sie Fehlerbehandlung in Code-Aktionen hinzu
+
+### Fehler in Code-Aktionen
+
+**Symptome**: JavaScript-Code wird nicht ausgeführt.
+
+**Häufige Probleme**:
+
+1. **Syntaxfehler**: Tippfehler oder ungültiges JavaScript
+2. **Undefinierte Variablen**: Verweise auf Variablen, die nicht existieren
+3. **Typfehler**: Operationen auf falschen Datentypen
+4. **Timeouts**: Code benötigt zu lange zur Ausführung
+
+**Lösungen**:
+
+* Verwenden Sie die integrierte Validierung des Code-Editors
+* Testen Sie die Code-Logik zuerst in einer JavaScript-Konsole
+* Fügen Sie console.log-Anweisungen zum Debuggen hinzu
+* Vereinfachen Sie komplexe Operationen
+
+### E-Mail wird nicht gesendet
+
+**Symptome**: Die Aktion "Send Email" liefert keine E-Mails aus.
+
+**Mögliche Ursachen**:
+
+1. **Kein E-Mail-Konto verbunden**: Prüfen Sie Settings → Accounts
+2. **Ungültige E-Mail-Adresse**: Die E-Mail-Adresse des Empfängers ist fehlerhaft
+3. **Sendelimits**: Ratenbegrenzung des E-Mail-Anbieters erreicht
+4. **Spamfilter**: E-Mails werden blockiert
+
+**Lösungen**:
+
+* Überprüfen Sie die Verbindung des E-Mail-Kontos
+* Validieren Sie die E-Mail-Adressen der Empfänger
+* Überprüfen Sie die Limits des E-Mail-Anbieters
+* Überprüfen Sie den E-Mail-Inhalt auf Spam-Auslöser
+
+## Workflows debuggen
+
+### Workflow-Läufe verwenden
+
+1. Gehen Sie zum Workflow-Editor
+2. Öffnen Sie das Panel **Runs**
+3. Finden Sie den fehlgeschlagenen Lauf
+4. Klicken Sie, um die Details Schritt für Schritt zu sehen
+5. Überprüfen Sie Fehlermeldungen und Ausgabedaten
+
+### Einzelschritte testen
+
+1. Für Code-Aktionen verwenden Sie die Schaltfläche **Test**
+2. Für HTTP-Anfragen testen Sie den Endpunkt separat
+3. Erstellen Sie Testdatensätze, um Workflows auszulösen
+4. Verwenden Sie manuelle Trigger für kontrollierte Tests
+
+### Häufige Debugging-Muster
+
+**Logging hinzufügen**:
+Verwenden Sie Code-Aktionen, um Zwischenwerte zum Debuggen zu protokollieren.
+
+**Schritte isolieren**:
+Testen Sie jeden Schritt unabhängig, um Fehler zu identifizieren.
+
+**Datenfluss prüfen**:
+Stellen Sie sicher, dass jeder Schritt die erwarteten Eingabedaten erhält.
+
+## Bewährte Verfahren zur Vermeidung von Problemen
+
+### Vor der Aktivierung
+
+* Testen Sie im Entwurfsmodus gründlich
+* Validieren Sie alle API-Verbindungen
+* Überprüfen Sie die Trigger-Bedingungen sorgfältig
+* Dokumentieren Sie das erwartete Verhalten
+
+### Während der Entwicklung
+
+* Verwenden Sie aussagekräftige Schrittnamen
+* Fügen Sie Kommentare in Code-Aktionen hinzu
+* Testen Sie mit realistischen Daten
+* Planen Sie für Randfälle
+
+### Nach der Aktivierung
+
+* Überwachen Sie die ersten Läufe genau
+* Richten Sie Benachrichtigungen für Fehler ein
+* Überprüfen Sie den Ausführungsverlauf regelmäßig
+* Halten Sie Workflows nach Möglichkeit einfach

packages/twenty-docs/l/de/user-guide/workflows/how-tos/need-more-help/workflows-faq.mdx

@@ -0,0 +1,236 @@
+---
+title: FAQ zu Workflows
+description: Häufig gestellte Fragen zu Workflows in Twenty.
+---
+
+<AccordionGroup>
+
+  <Accordion title="Warum kann ich einen Workflow nicht aktivieren?">
+    Dies ist wahrscheinlich ein Berechtigungsproblem. Sie benötigen Zugriff auf Workflows, um sie zu erstellen und zu aktivieren.
+
+    **Lösung**: Wenden Sie sich an Ihren Workspace-Administrator, damit er Ihnen unter **Einstellungen → Mitglieder → Rollen** Zugriff auf Workflows gewährt.
+
+    Wenn Sie den Bereich Workflows in Ihrer Seitenleiste überhaupt nicht sehen, bestätigt dies ein Berechtigungsproblem.
+  </Accordion>
+
+  <Accordion title="Warum sehe ich die Schaltfläche für manuelle Workflows nicht in der oberen Navigationsleiste?">
+    Manuelle Workflows erscheinen nur in der Navigationsleiste, wenn sie korrekt konfiguriert sind:
+
+    1. Der Workflow muss **aktiviert** sein (nicht im Entwurfsmodus)
+    2. Die Platzierung in der Navigationsleiste muss auf **Pinned** gesetzt sein
+    3. Für Single-/Bulk-Trigger müssen Sie sich auf der richtigen Objektseite befinden
+
+    **Zum Überprüfen**: Öffnen Sie den Workflow → klicken Sie auf den Trigger → prüfen Sie, dass "Navbar placement" auf "Pinned" gesetzt ist.
+
+    Unabhängig von den Navbar-Einstellungen können Sie manuelle Workflows jederzeit über **Cmd + K** (oder **Ctrl + K**) aufrufen.
+  </Accordion>
+
+  <Accordion title="Was ist der Unterschied zwischen manuellen Single-, Global- und Bulk-Triggern?">
+    | Typ | Erforderliche Datensätze | Workflow-Läufe |
+    | --- | ------------------------ | -------------- |
+    \| **Global** | Keine | Einmal, ohne Datensatzeingabe |
+    \| **Single** | Ein oder mehrere ausgewählte Datensätze | Einmal pro ausgewähltem Datensatz |
+    \| **Bulk** | Ein oder mehrere ausgewählte Datensätze | Einmal, mit allen Datensätzen als Array |
+
+    * **Global**: Verwenden Sie dies, wenn der Workflow keinen Datensatzkontext benötigt (z. B. einen Bericht erzeugen)
+    * **Single**: Verwenden Sie dies, wenn Sie jeden ausgewählten Datensatz unabhängig verarbeiten möchten (z. B. einzelne E-Mails senden)
+    * **Bulk**: Verwenden Sie dies, wenn Sie Datensätze gemeinsam verarbeiten oder den Credit-Verbrauch optimieren möchten (erfordert die Iterator-Aktion)
+
+    Siehe [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers) für Details.
+  </Accordion>
+
+  <Accordion title="Ich sehe keinen If/Else-Knoten. Was sollte ich tun?">
+    Ein expliziter If/Else-Knoten ist noch nicht verfügbar, steht aber auf unserer Roadmap.
+
+    **Aktuelle Problemumgehung**: Erstellen Sie mehrere Verzweigungen von Ihrem Schritt aus, die jeweils mit einer **Filter**-Aktion beginnen:
+
+    ```
+    Step 1
+       │
+       ├── Branch A: Filter (condition = true) → Actions...
+       │
+       └── Branch B: Filter (condition = false) → Actions...
+    ```
+
+    Nur die Verzweigung, deren Filterbedingung erfüllt ist, führt die nachfolgenden Aktionen aus.
+
+    Siehe [Verzweigungen verwenden](/l/de/user-guide/workflows/capabilities/workflow-branches) für eine Schritt-für-Schritt-Anleitung.
+  </Accordion>
+
+  <Accordion title="Laufen Workflow-Verzweigungen parallel?">
+    **Ja**, Verzweigungen laufen standardmäßig parallel.
+
+    Wenn nur eine Verzweigung ausgeführt werden soll:
+    * Fügen Sie am Anfang jeder Verzweigung eine **Filter**-Aktion hinzu
+    * Legen Sie gegensätzliche Bedingungen fest (z. B., Verzweigung A: status = "Open", Verzweigung B: status ≠ "Open")
+
+    Verzweigungen, deren Filterbedingung fehlschlägt, werden nicht weiter ausgeführt; andere laufen weiter.
+  </Accordion>
+
+  <Accordion title="Kann ich Verzweigungen wieder zusammenführen?">
+    **Ja**. Nachdem Ihre parallelen Verzweigungen abgeschlossen sind, können Sie einen Schritt hinzufügen, mit dem beide Verzweigungen verbunden werden.
+
+    Im Workflow-Editor:
+    1. Schließen Sie Ihre verzweigten Aktionen ab
+    2. Fügen Sie nach den Verzweigungen einen neuen Schritt hinzu
+    3. Ziehen Sie Verbindungen vom Ende jeder Verzweigung zu diesem neuen Schritt
+
+    Der zusammengeführte Schritt wird ausgeführt, nachdem alle verbundenen Verzweigungen abgeschlossen sind.
+  </Accordion>
+
+  <Accordion title="Wie lautet das Limit für die Ergebnisse von Search Records?">
+    **Search Records gibt maximal 200 Datensätze zurück.**
+
+    Wenn Sie mehr verarbeiten müssen:
+    * Fügen Sie spezifischere Filter hinzu, um die Ergebnisse zu reduzieren
+    * Verwenden Sie geplante Workflows, um in Batches zu verarbeiten
+    * Ziehen Sie die Verwendung der API für Massenoperationen in Betracht
+
+    Für die meisten Workflows sind 200 Datensätze ausreichend. Wenn Sie dieses Limit regelmäßig erreichen, sollten Sie Ihre Automatisierung neu strukturieren.
+  </Accordion>
+
+  <Accordion title="Kann ich Personen in Workflow-E-Mails in CC setzen?">
+    **Noch nicht.** CC- und BCC-Felder für die Aktion "Send Email" stehen auf unserer Roadmap.
+
+    **Aktuelle Problemumgehung**: Fügen Sie mehrere "Send Email"-Aktionen hinzu, um an zusätzliche Empfänger zu senden, oder verwenden Sie einen HTTP Request, um über einen externen E-Mail-Dienst zu senden, der CC unterstützt.
+  </Accordion>
+
+  <Accordion title="Wie verwende ich Ausgaben aus vorherigen Schritten?">
+    Jede Aktion erzeugt Ausgabedaten, die in nachfolgenden Schritten verwendet werden können.
+
+    **So verweisen Sie auf Daten aus vorherigen Schritten**:
+    * Verwenden Sie den Variablenauswähler, wenn Sie ein Feld konfigurieren
+    * Oder geben Sie `{{stepName.fieldName}}` direkt ein
+
+    **Beispiele**:
+    * Trigger-Daten: `{{trigger.object.email}}`
+    * Suchergebnisse: `{{searchRecords[0].name}}`
+    * Code-Ausgabe: `{{code.calculatedValue}}`
+
+    Fahren Sie in der Aktionskonfiguration mit der Maus über ein beliebiges Feld, um verfügbare Variablen aus vorherigen Schritten zu sehen.
+  </Accordion>
+
+  <Accordion title="Warum schlägt mein Iterator fehl?">
+    **Iterator erfordert eine Array-Eingabe.** Häufige Probleme:
+
+    1. **Eingabe ist kein Array**: Stellen Sie sicher, dass Sie Ergebnisse von Search Records oder einer anderen Aktion übergeben, die ein Array zurückgibt
+    2. **Array ist leer**: Fügen Sie vor Iterator einen Filter hinzu, um `{{searchRecords.length}} > 0` zu prüfen
+    3. **Falsche Variable ausgewählt**: Stellen Sie sicher, dass Sie das Array selbst auswählen, nicht einen einzelnen Datensatz
+
+    **Korrekte Einrichtung**:
+    1. Search Records (gibt ein Array zurück)
+    2. Filter: length > 0
+    3. Iterator: Wählen Sie `{{searchRecords}}` aus
+    4. Aktionen innerhalb des Iterators verwenden `{{iterator.currentItem.fieldName}}`
+  </Accordion>
+
+  <Accordion title="Wie lang ist die maximale Ausführungszeit für Code-Aktionen?">
+    Code-Aktionen (Logikfunktionen) haben ein **Standard-Timeout von 5 Minuten** (300 Sekunden).
+
+    Das maximal konfigurierbare Timeout beträgt **15 Minuten** (900 Sekunden).
+
+    Wenn Ihr Code dieses Limit überschreitet, schlägt die Aktion mit einem Timeout-Fehler fehl.
+
+    **Tipps zur Vermeidung von Timeouts**:
+    * Zerlegen Sie große Operationen mithilfe des Iterators in kleinere Teile
+    * Vermeiden Sie rechenintensive Vorgänge; verwenden Sie für aufwändige Verarbeitung externe Dienste über HTTP Request
+    * Optimieren Sie Ihren Code, um die Ausführungszeit zu reduzieren
+    * Wenn Sie längere Verarbeitung benötigen, sollten Sie geplante Workflows verwenden, die Daten in Batches verarbeiten
+  </Accordion>
+
+  <Accordion title="Wie lese ich Workflow-Ausführungen?">
+    Workflow-Ausführungen zeigen die Ausführungshistorie und helfen beim Debuggen von Problemen.
+
+    **Auf Ausführungen zugreifen**:
+    * Im Workflow-Editor → **Runs**-Bereich auf der rechten Seite
+    * Oder gehen Sie in der Seitenleiste zu **Workflow Runs**
+
+    **Eine Ausführung verstehen**:
+    * **Status**: Running, Completed, Failed, Waiting
+    * **Schritte**: Sehen Sie, welche Schritte ausgeführt wurden und deren Ausgabe
+    * **Fehler**: Klicken Sie auf fehlgeschlagene Schritte, um Fehlermeldungen zu sehen
+    * **Daten**: Betrachten Sie Eingabe-/Ausgabedaten in jedem Schritt
+
+    Siehe [Workflow-Ausführungen](/l/de/user-guide/workflows/capabilities/workflow-runs) für Details.
+  </Accordion>
+
+  <Accordion title="Warum sehe ich meine Workflow-Ausführungen nicht?">
+    Workflow-Ausführungen schlagen möglicherweise aufgrund von Rate Limits sofort fehl. Twenty erzwingt ein hartes Limit von 5.000 Ausführungen pro Stunde und Workspace.
+
+    Wenn Sie dieses Limit überschreiten, werden Workflows sofort als fehlgeschlagen markiert und erscheinen nicht in Ihrer Ausführungsliste.
+
+    **Häufige Szenarien, die dieses Limit erreichen**:
+    * Auswahl von mehr als 5.000 Datensätzen mit einem manuellen Single-Trigger
+    * Mehrere Workflows, die gleichzeitig in Ihrem Workspace ausgeführt werden
+    * Hochfrequente automatisierte Trigger (z. B. Record Updated bei einem stark genutzten Objekt)
+
+    **Lösungen**:
+    * Verwenden Sie **Bulk**-Trigger statt Single, um viele Datensätze in einer Ausführung zu verarbeiten
+    * Staffeln Sie große Batch-Vorgänge zeitlich
+    * Verwenden Sie Filter, um die Triggerfrequenz zu reduzieren
+    * Planen Sie umfangreiche Workflows außerhalb der Stoßzeiten
+  </Accordion>
+
+  <Accordion title="Wie lauten die Workflow-Rate-Limits?">
+    Twenty hat zwei Rate-Limits, um die Systemstabilität sicherzustellen:
+
+    | Limit | Wert | Verhalten |
+    | ----- | ---- | --------- |
+    \| **Weiches Limit** | 100 Ausführungen/Minute | Ausführungen werden im Status "Not Started" in die Warteschlange gestellt und nach und nach verarbeitet |
+    \| **Hartes Limit** | 5.000 Ausführungen/Stunde | Ausführungen schlagen sofort fehl |
+
+    **Weiches Limit (100/Min.)**: Ihre Workflows schlagen nicht fehl – sie warten lediglich in der Warteschlange und werden mit der Zeit verarbeitet. Sie können mehr als 100 Datensätze auslösen; die Ausführung wird langsamer sein.
+
+    **Hartes Limit (5.000/Stunde)**: Dies gilt für Ihren gesamten Workspace. Wenn alle Ihre Workflows zusammen in einer Stunde mehr als 5.000 Ausführungen erreichen, schlagen zusätzliche Ausführungen sofort fehl.
+
+    **Tipps, um innerhalb der Limits zu bleiben**:
+    * Verwenden Sie für große Batches Bulk-Trigger mit Iterator statt Single-Triggern
+    * Kombinieren Sie verwandte Automatisierungen in weniger Workflows
+    * Verwenden Sie geplante Workflows, um die Last über die Zeit zu verteilen
+  </Accordion>
+
+  <Accordion title="Kann ich eine fehlgeschlagene Workflow-Ausführung erneut ausführen?">
+    **Nein, derzeit gibt es keine automatische Wiederholungsfunktion.**
+
+    Wenn eine Workflow-Ausführung fehlschlägt, müssen Sie:
+    1. Den Fehler prüfen unter **Einstellungen → Workflows → [Ihr Workflow] → Runs**
+    2. Das Problem beheben (Daten, Konfiguration oder externer Dienst)
+    3. Den Workflow erneut manuell für die betroffenen Datensätze auslösen
+
+    **Tipps zur Reduzierung von Fehlschlägen**:
+    * Fügen Sie **Filter**-Knoten hinzu, um Daten vor Aktionen zu validieren
+    * Verwenden Sie **Search Records**, um zu prüfen, ob verknüpfte Datensätze existieren
+    * Testen Sie gründlich mit einigen Datensätzen, bevor Sie Massenoperationen durchführen
+
+    Eine automatische Wiederholungsfunktion steht auf unserer Roadmap für eine zukünftige Version.
+  </Accordion>
+
+  <Accordion title="Sollte ich Workflows vor CSV-Importen deaktivieren?">
+    **Ja, wenn Ihre Workflows durch das Erstellen oder Aktualisieren von Datensätzen ausgelöst werden.**
+
+    Wenn Sie Daten per CSV importieren, kann jeder erstellte oder aktualisierte Datensatz Workflows auslösen. Ein großer Import (Tausende von Datensätzen) könnte:
+    * Das Limit von 5.000 Ausführungen/Stunde erreichen
+    * Erhebliche Workflow-Credits verbrauchen
+    * Unerwartete E-Mails oder Benachrichtigungen senden
+    * Doppelte Aufgaben oder Datensätze erstellen
+
+    **Vor einem Massenimport**:
+    1. Gehen Sie zu **Einstellungen → Workflows**
+    2. Identifizieren Sie Workflows, die durch das Objekt ausgelöst werden, das Sie importieren
+    3. **Deaktivieren** Sie diese vorübergehend
+    4. Führen Sie Ihren CSV-Import aus
+    5. **Reaktivieren** Sie die Workflows, wenn Sie fertig sind
+
+    **Alternative**: Wenn die Workflows für importierte Daten ausgeführt werden sollen, importieren Sie in kleineren Batches, um innerhalb der Rate-Limits zu bleiben.
+  </Accordion>
+
+  <Accordion title="Wie bereinige ich mein Workflow-Layout?">
+    Wenn Ihre Workflow-Canvas unübersichtlich aussieht, mit verstreuten Knoten, können Sie sie automatisch organisieren:
+
+    1. Klicken Sie mit der rechten Maustaste irgendwo auf der Workflow-Canvas
+    2. Klicken Sie auf **Tidy up workflow**
+
+    Dadurch werden alle Knoten automatisch in ein übersichtliches, organisiertes Layout gebracht.
+  </Accordion>
+
+</AccordionGroup>

packages/twenty-docs/l/de/user-guide/workflows/overview.mdx

@@ -0,0 +1,81 @@
+---
+title: Workflows
+description: Erfahren Sie, wie Sie Automatisierungen in Twenty erstellen.
+---
+
+## Warum Workflows wichtig sind
+
+Twenty wurde entwickelt, um den Nutzern maximale Flexibilität zu bieten. Anstatt Sie dazu zu zwingen, Ihre Geschäftsprozesse an starre, vorgefertigte Funktionen anzupassen, ermöglichen Ihnen Workflows, Automatisierungen zu erstellen, mit denen Sie Ihr CRM so gestalten, dass es Ihre individuellen geschäftlichen Anwendungsfälle optimal unterstützt.
+
+Workflows sind die In-App-Funktion von Twenty zum Erstellen dieser Automatisierungen. Sie bieten Ihnen die Bausteine, um genau das zu schaffen, was Ihr Unternehmen braucht, wann es das braucht.
+
+## Was kann ich mit Workflows machen?
+
+Wir empfehlen, Automatisierungen für zwei Hauptzwecke zu entwickeln:
+
+1. **Interne Automatisierungen, um den Alltag Ihres Teams zu erleichtern**: Reduzieren Sie die Menge manueller Eingaben und sich wiederholender Aufgaben, die Ihr Team verlangsamen.
+2. **Daten in und aus Twenty bringen**: Verbinden Sie Twenty über API-Aufrufe und Webhooks mit Ihrer Datenbank und anderen Werkzeugen.
+
+## Den ersten Workflow erstellen
+
+### Schritt 1: Neuen Workflow erstellen
+
+1. Gehen Sie zu **Workflows**, zu finden unterhalb der anderen Objekte
+2. Klicken Sie auf **+ Neuer Datensatz**
+3. Geben Sie Ihrem Workflow einen Namen
+
+### Schritt 2: Einen Trigger hinzufügen
+
+Jeder Workflow beginnt mit einem Trigger. Wählen Sie aus:
+
+* **Datensatzereignisse**: Wenn ein Datensatz erstellt, aktualisiert oder gelöscht wird
+* **Zeitplan**: Zu bestimmten Zeiten ausführen (täglich, wöchentlich usw.)
+* **Manuell**: Durch eine Benutzeraktion ausgelöst
+* **Webhook**: Durch einen Webhook ausgelöst
+
+<img src="/images/user-guide/workflows/workflow_triggers.png" style={{width:'100%'}} />
+
+### Schritt 3: Aktionen hinzufügen
+
+Fügen Sie nach Ihrem Trigger eine oder mehrere Aktionen hinzu:
+
+* **Datensatz erstellen**: Neue Datensätze zu einem beliebigen Objekt hinzufügen
+* **Datensatz aktualisieren**: Daten eines vorhandenen Datensatzes ändern
+* **Datensatz löschen**: Datensätze aus Objekten entfernen
+* **Datensätze suchen**: Datensätze finden, die den Kriterien entsprechen
+* **Upsert**: Erstellen oder aktualisieren basierend auf übereinstimmenden Kriterien
+* **Iterator**: Über Arrays von Datensätzen iterieren
+* **Filter**: Steuern, welche Datensätze weiterverarbeitet werden
+* **Verzögerung**: Vor dem Fortfahren warten (Dauer oder geplanter Zeitpunkt)
+* **E-Mail senden**: E-Mails über Ihr verbundenes Konto senden
+* **Code**: Benutzerdefiniertes JavaScript ausführen
+* **HTTP-Anfrage**: Externe APIs aufrufen
+* **Formular**: Eingaben von Benutzern innerhalb der Twenty-Oberfläche zum Zeitpunkt der Ausführung abfragen
+* **KI-Agent** (Bald verfügbar): Intelligente KI-Aufgaben ausführen
+
+<img src="/images/user-guide/workflows/workflow_actions.png" style={{width:'100%'}} />
+
+### Schritt 4: Testen und aktivieren
+
+1. Verwenden Sie die Schaltfläche **Test**, um Ihren Workflow mit Beispieldaten auszuführen
+2. Überprüfen Sie die Ergebnisse, um sicherzustellen, dass alles wie erwartet funktioniert
+3. Schalten Sie den Workflow auf **Aktiv**, sobald er bereit ist
+
+## Workflow Best Practices
+
+* **Schrittbezeichnungen bearbeiten**: Benennen Sie Ihre Workflow-Schritte um, um klar zu beschreiben, was jeder Schritt tut. Dies erleichtert die Wartung und die Übergabe an Kollegen
+* **Vorherige Schritt-Daten nutzen**: Sie können Felder aus Datensätzen verwenden, die von einem vorherigen Schritt in Ihrem Workflow zurückgegeben wurden.
+* **Einfach anfangen**: Beginnen Sie mit einfachen Workflows und erhöhen Sie die Komplexität im Laufe der Zeit, wenn Sie mit dem System vertrauter werden.
+* **Planen, bevor Sie loslegen**: Skizzieren Sie die Logik Ihres Workflows, bevor Sie beginnen, um zu vermeiden, dass Sie auf halbem Weg stecken bleiben.
+
+## Nächste Schritte
+
+* [Workflow-Trigger](/l/de/user-guide/workflows/capabilities/workflow-triggers)
+* [Workflow-Aktionen](/l/de/user-guide/workflows/capabilities/workflow-actions)
+* [CRM-Automatisierungen](/l/de/user-guide/workflows/how-tos/crm-automations/closed-won-automations)
+
+## Brauchen Sie Hilfe?
+
+<Tip>
+  Möchten Sie Hilfe bei der Automatisierung Ihrer Workflows? [Finde einen zertifizierten Zwanzig Partner](https://twenty.com/partners/list?categories=SOLUTIONING\&ref=docs-workflows) zum Entwerfen und Bauen deiner Automatisierungen Ende-zu-Ende-zu-Ende.
+</Tip>