> ## Documentation Index
> Fetch the complete documentation index at: https://docs.localmind.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Item Management

> Verwaltung und Manipulation von Items in Automate-Workflows

Items sind die grundlegenden Dateneinheiten in Automate-Workflows: JSON-Objekte, die Daten von Node zu Node transportieren (`Trigger → Node 1 → Node 2 → …`). Jeder Node kann Items empfangen, verarbeiten und neue Items ausgeben. Jedes Item hat diese Struktur:

```json theme={null}
{
  "json": {
    "field1": "value1",
    "field2": "value2"
  },
  "binary": {},
  "pairedItem": {}
}
```

## Item-Zugriff

### Auf aktuelle Item-Daten zugreifen

<CodeGroup>
  ```javascript Expression Editor theme={null}
  // Zugriff auf JSON-Felder
  {{ $json.fieldName }}

  // Verschachtelte Felder
  {{ $json.user.email }}

  // Array-Zugriff
  {{ $json.items[0].name }}

  // Mit Null-Check
  {{ $json.user?.email || 'default@example.com' }}
  ```

  ```javascript Code-Node theme={null}
  // Im Code-Node
  const email = $input.item.json.email;
  const userName = $input.item.json.user?.name;

  // Zugriff auf alle Item-Daten
  const allData = $input.item.json;
  ```
</CodeGroup>

### Auf vorherige Nodes zugreifen

<CodeGroup>
  ```javascript Spezifischer Node theme={null}
  // Zugriff auf Daten eines bestimmten Nodes
  {{ $('Node Name').item.json.fieldName }}

  // Erstes Item eines Nodes
  {{ $('HTTP Request').first().json.data }}

  // Letztes Item eines Nodes
  {{ $('HTTP Request').last().json.data }}

  // Alle Items eines Nodes
  {{ $('HTTP Request').all() }}
  ```

  ```javascript Code-Node theme={null}
  // Im Code-Node
  const previousNodeData = $('HTTP Request').item.json;
  const allItems = $('HTTP Request').all();
  ```
</CodeGroup>

<Tip>
  Verwenden Sie den Expression Editor, um Item-Zugriffe zu validieren — die Autovervollständigung zeigt verfügbare Felder an.
</Tip>

## Item-Manipulation

### Set Node — Felder setzen und ändern

Der Set Node (in der UI „Edit Fields") ist der primäre Weg zur Item-Manipulation. Sie definieren unter **Fields to Set** die gewünschten Felder mit Name, Typ und Wert; die Option **Include Other Input Fields** steuert, ob die übrigen Input-Felder erhalten bleiben.

<CodeGroup>
  ```json Fields to Set theme={null}
  {
    "fields": [
      { "name": "fullName", "type": "string", "value": "={{ $json.firstName }} {{ $json.lastName }}" },
      { "name": "email", "type": "string", "value": "={{ $json.email }}" },
      { "name": "timestamp", "type": "string", "value": "={{ $now.toISO() }}" }
    ]
  }
  ```

  ```json Input theme={null}
  {
    "firstName": "Max",
    "lastName": "Mustermann",
    "email": "max@example.com"
  }
  ```

  ```json Output theme={null}
  {
    "fullName": "Max Mustermann",
    "email": "max@example.com",
    "timestamp": "2026-07-10T10:30:00.000Z"
  }
  ```
</CodeGroup>

**Felder umbenennen oder reduzieren:** Setzen Sie die neuen Feldnamen unter **Fields to Set** (z.B. `userEmail` = `{{ $json.email }}`) und lassen Sie **Include Other Input Fields** deaktiviert — das Output-Item enthält dann nur die gesetzten Felder, alle übrigen (z.B. `email`, `password`) sind entfernt. In älteren Workflows finden Sie dafür noch die Legacy-Option `keepOnlySet`; die moderne Set-Node-Darstellung ersetzt sie durch **Fields to Set** + **Include Other Input Fields**.

### Merge Node — Items kombinieren

Der Merge Node kombiniert Daten aus verschiedenen Quellen und bietet drei Modi:

* **Append:** hängt die Items aller Inputs nacheinander an einen gemeinsamen Stream an
* **Combine:** führt Items zusammen — nach übereinstimmenden Feldern (Matching Fields), nach Position oder als alle möglichen Kombinationen
* **Choose Branch:** gibt nur die Items eines gewählten Inputs weiter

```json Beispiel: Combine (By Position) theme={null}
// Input 1 (Node A)
{ "id": 1, "name": "Max" }

// Input 2 (Node B)
{ "email": "max@example.com" }

// Output
{ "id": 1, "name": "Max", "email": "max@example.com" }
```

Die Modi `mergeByIndex`, `mergeByKey`, `append` und `multiplex` stammen aus der Legacy-Version des Merge Node und existieren in aktuellen Automate-Versionen nicht mehr.

### Code-Node — Komplexe Manipulationen

<CodeGroup>
  ```javascript Item transformieren theme={null}
  // Komplexe Transformation
  const items = $input.all();

  const transformedItems = items.map(item => {
    return {
      json: {
        id: item.json.id,
        fullName: `${item.json.firstName} ${item.json.lastName}`,
        email: item.json.email.toLowerCase(),
        processedAt: new Date().toISOString(),
        metadata: {
          originalData: item.json
        }
      }
    };
  });

  return transformedItems;
  ```

  ```javascript Items filtern theme={null}
  // Items basierend auf Bedingungen filtern
  const items = $input.all();

  const filteredItems = items.filter(item => {
    return item.json.status === 'active' && 
           item.json.amount > 100;
  });

  return filteredItems;
  ```
</CodeGroup>

## Item-Filterung

### Filter Node

Der Filter Node lässt nur Items durch, die alle konfigurierten Bedingungen erfüllen. Typische Filter-Expressions:

```javascript Filter-Beispiele theme={null}
// Status gleich "active"
{{ $json.status === 'active' }}

// Betrag größer als 100
{{ $json.amount > 100 }}

// E-Mail enthält Domain
{{ $json.email.includes('@company.com') }}
```

Für ODER-Verknüpfungen oder mehrstufige Bedingungen nutzen Sie den Code-Node (siehe „Items filtern" oben).

### IF Node — Bedingte Verarbeitung

Der IF Node verzweigt Items basierend auf Bedingungen in einen True- und einen False-Branch (z.B. `Premium Processing` vs. `Standard Processing`):

```javascript IF-Bedingung theme={null}
// Einfache Bedingung
{{ $json.userType === 'premium' }}

// Komplexe Bedingung
{{ $json.status === 'active' && $json.balance > 0 }}

// Mit Null-Check
{{ $json.user?.subscription?.active === true }}
```

## Transformation und Validierung

Für generische Datentransformationen (Typ-Konvertierung, Datums-Formatierung, Array-Operationen) und Validierungs-Patterns nutzen Sie JavaScript-Expressions bzw. den Code-Node. Eine vollständige Referenz aller eingebauten Funktionen und Variablen finden Sie in der [offiziellen n8n-Dokumentation zu Datenstrukturen und Transformationen](https://docs.n8n.io/data/).

<Tip>
  Validieren Sie Items so früh wie möglich im Workflow — z.B. mit einem Filter Node direkt nach dem Trigger, der unvollständige Items aussortiert: `{{ $json.id !== undefined && $json.email !== undefined }}`
</Tip>

## Häufige Patterns

### Item-Enrichment

Reichern Sie Items mit zusätzlichen Daten an (`Trigger → Get Base Data → Enrich with API → Merge → Output`):

```json Enrichment-Workflow theme={null}
// Schritt 1: Basis-Daten
{ "userId": 123, "name": "Max" }

// Schritt 2: API-Daten abrufen
{ "email": "max@example.com", "role": "admin" }

// Schritt 3: Zusammenführen
{
  "userId": 123,
  "name": "Max",
  "email": "max@example.com",
  "role": "admin"
}
```

### Item-Normalisierung

Normalisieren Sie unterschiedliche Input-Formate für konsistente Verarbeitung:

```javascript Normalisierung theme={null}
// Verschiedene Input-Formate
{ "first_name": "Max", "last_name": "Mustermann" }
{ "firstName": "Max", "lastName": "Mustermann" }

// Normalisiertes Format
{
  "firstName": "={{ $json.first_name || $json.firstName }}",
  "lastName": "={{ $json.last_name || $json.lastName }}",
  "fullName": "={{ $json.firstName }} {{ $json.lastName }}"
}
```

### Item-Splitting

Teilen Sie komplexe Items in einfachere auf:

```javascript Item splitten theme={null}
// Input: Ein Item mit Array
{
  "orderId": 123,
  "items": [
    { "productId": 1, "quantity": 2 },
    { "productId": 2, "quantity": 1 }
  ]
}

// Output: Mehrere Items
// Item 1
{ "orderId": 123, "productId": 1, "quantity": 2 }

// Item 2
{ "orderId": 123, "productId": 2, "quantity": 1 }
```

## Best Practices

* **Konsistente Feldnamen:** einheitliche Namenskonventionen über den gesamten Workflow hinweg verwenden.
* **Null-Checks:** immer für verschachtelte Felder implementieren — `{{ $json.user?.email }}`.
* **Frühe Validierung:** Items so früh wie möglich im Workflow validieren, nicht erst am Ende.
* **Dokumentation:** festhalten, welche Item-Struktur jeder Node erwartet und produziert.
* **Transformation isolieren:** Set Nodes für klare Transformationen nutzen, keine komplexen Expressions in anderen Nodes.
* **Performance:** unnötige Item-Kopien vermeiden; im Set Node nur benötigte Felder weitergeben (**Include Other Input Fields** deaktiviert lassen).

## Checkliste

* [ ] Item-Struktur ist dokumentiert
* [ ] Null-Checks sind implementiert
* [ ] Datentypen sind konsistent
* [ ] Validierung erfolgt früh im Workflow
* [ ] Feldnamen folgen Namenskonventionen
* [ ] Items werden nicht unnötig kopiert
* [ ] Transformationen sind klar und nachvollziehbar

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Batching" icon="layers" href="/automate/batching">
    Items in Batches verarbeiten.
  </Card>

  <Card title="Performance" icon="gauge" href="/automate/performance">
    Item-Verarbeitung für bessere Performance optimieren.
  </Card>

  <Card title="Basics" icon="settings-2" href="/automate/basics">
    Grundlagen von Automate-Workflows.
  </Card>

  <Card title="Testing" icon="flask-conical" href="/automate/testing">
    Item-Manipulationen gründlich testen.
  </Card>
</CardGroup>