KI-Rechnungsprüfung:
Kompletter Implementierungs-Guide für KMUs

Das Problem: Manuelle Rechnungsprüfung kostet 18.000€/Jahr

Kennen Sie das? Ihre Buchhaltung verbringt 3-4 Stunden pro Tag mit manueller Rechnungsprüfung:

• Rechnung aus E-Mail herunterladen
• PDF öffnen, Betrag, Datum, Rechnungsnummer ablesen
• Daten in ERP/Buchhaltungs-Software eintippen
• Rechnung mit Bestellung abgleichen (falls vorhanden)
• Bei Unstimmigkeiten: E-Mail an Lieferanten
• Rechnung archivieren (GoBD-konform)

Zeit pro Rechnung: 45 Minuten (Durchschnitt)
Fehlerquote: 8-12% (Tippfehler, falsches Feld, vergessene Rechnungen)

Beispiel: Bauunternehmen mit 1.200 Rechnungen/Jahr

Die Lösung: KI-gestützte Automatisierung

Stellen Sie sich vor:

1. Rechnung kommt per E-Mail rein
2. KI extrahiert automatisch: Betrag, Datum, Rechnungsnummer, Lieferant, USt-ID
3. KI validiert: Betrag > 0? Datum plausibel? USt-ID korrekt?
4. KI prüft Duplikate: Wurde diese Rechnung schon erfasst?
5. Confidence Score > 90%? → Auto-Approve + E-Mail an Prüfer
6. Confidence Score < 90%? → Manuelle Prüfung + Felder sind schon vorausgefüllt

Zeit pro Rechnung: 2 Minuten (nur Validierung, falls Confidence < 90%)
Fehlerquote: 1-2% (nur bei schlechten Scans oder Handschrift)

Was macht die KI konkret?

Zeitersparnis: 768 Sekunden (12,8 Min.) pro Rechnung = 98,5% schneller

ROI-Berechnung: 127% im ersten Jahr

Ausgangssituation (wie oben)

• 1.200 Rechnungen/Jahr
• 900 Stunden manueller Aufwand
• 36.000€ Personalkosten
• 1.920€ Fehler-Kosten
• GESAMT: 37.920€/Jahr

Mit KI-Rechnungsprüfung

ROI-Rechnung

Technische Architektur (Intrexx + n8n + Claude)

┌─────────────────────────────────────────────────────────┐
│              EINGANGSRECHNUNG (E-Mail/Upload)           │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│                  INTREXX (Low-Code)                     │
│  • PDF-Upload via Drag-&-Drop                           │
│  • Datenbank-Eintrag erstellt (Status: "Neu")          │
│  • afterSave-Trigger feuert Groovy Hook                │
└────────────────────────┬────────────────────────────────┘
                         │
                         │ Groovy Hook sendet:
                         │ - PDF (Base64)
                         │ - Invoice ID
                         │ - Supplier Name (falls bekannt)
                         ▼
┌─────────────────────────────────────────────────────────┐
│                   n8n WEBHOOK NODE                      │
│  • Empfängt Request von Intrexx                         │
│  • Validiert API-Key                                    │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│              n8n: BASE64 → BINARY NODE                  │
│  • PDF dekodieren                                       │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│           CLAUDE VISION API (OCR + EXTRAKTION)          │
│  Prompt:                                                │
│  "Extrahiere aus dieser Rechnung:                       │
│   1. Rechnungsnummer                                    │
│   2. Rechnungsbetrag (Brutto in EUR)                    │
│   3. Rechnungsdatum (Format: YYYY-MM-DD)                │
│   4. Lieferant (Firma)                                  │
│   5. USt-ID                                             │
│   6. Confidence Score (0-100%)                          │
│                                                         │
│   Antwort als JSON."                                    │
└────────────────────────┬────────────────────────────────┘
                         │
                         │ Response:
                         │ {
                         │   "invoice_number": "RE-2026-001",
                         │   "amount": 1234.56,
                         │   "date": "2026-01-10",
                         │   "supplier": "Baustoff GmbH",
                         │   "vat_id": "DE123456789",
                         │   "confidence": 96
                         │ }
                         ▼
┌─────────────────────────────────────────────────────────┐
│              n8n: VALIDATION NODE                       │
│  • Betrag > 0?                                          │
│  • Datum in Vergangenheit < 90 Tage?                    │
│  • Rechnungsnummer nicht leer?                          │
│  • USt-ID-Format korrekt (DE + 9 Ziffern)?             │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│           n8n: DUPLIKATE-CHECK NODE                     │
│  • Query Intrexx DB: Gibt es schon Rechnung mit        │
│    gleicher Rechnungsnummer?                            │
│  • Gibt es Rechnung mit gleichem Betrag + Lieferant    │
│    + Datum (±3 Tage)?                                   │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│               n8n: IF NODE (Confidence)                 │
│  Confidence > 90% && Keine Duplikate?                   │
│    ├─ JA: Status = "Auto-Approved"                      │
│    └─ NEIN: Status = "Manuelle Prüfung"                 │
└────────────────────────┬────────────────────────────────┘
                         │
                         │ Callback an Intrexx REST API
                         │ (Extrahierte Daten + Status)
                         ▼
┌─────────────────────────────────────────────────────────┐
│                INTREXX REST API HANDLER                 │
│  • Datenbank-Update:                                    │
│    - invoice_number = "RE-2026-001"                     │
│    - amount = 1234.56                                   │
│    - invoice_date = "2026-01-10"                        │
│    - supplier_name = "Baustoff GmbH"                    │
│    - vat_id = "DE123456789"                             │
│    - ai_confidence = 96                                 │
│    - processing_status = "Auto-Approved"                │
│  • Workflow-Trigger: E-Mail an Prüfer                   │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│                 USER NOTIFICATION                       │
│  E-Mail: "Rechnung RE-2026-001 geprüft (Auto-Approved)"│
│  Link: https://intrexx.firma.de/invoices/1234          │
└─────────────────────────────────────────────────────────┘

Technologie-Stack

Implementierung in 3 Wochen (Schritt-für-Schritt)

Woche 1: Setup & Foundation

Tag 1-2: Intrexx Datenbank + UI

1. Datenbank-Tabelle invoices erstellen:
   • id (Primary Key)
   • invoice_number (VARCHAR 50)
   • amount (DECIMAL 10,2)
   • invoice_date (DATE)
   • supplier_name (VARCHAR 200)
   • vat_id (VARCHAR 20)
   • invoice_pdf (FILE)
   • processing_status (VARCHAR 50)
   • ai_confidence (INT 0-100)
   • created_at, updated_at (DATETIME)
2. Upload-Formular bauen (Drag-&-Drop für PDF)
3. Übersichts-Seite (Tabelle mit allen Rechnungen)
4. Detail-Seite (einzelne Rechnung anzeigen + PDF-Preview)

Tag 3: n8n Setup

5. n8n installieren (Docker oder Cloud)
6. Ersten Webhook erstellen (Test mit Postman)
7. Claude API-Key in n8n hinterlegen

Tag 4-5: Intrexx Groovy Hook

8. afterSave-Event Handler in Intrexx
9. Groovy Script schreiben (PDF → Base64 → n8n Webhook)
10. Error-Handling (Try-Catch, Logging)

Woche 2: n8n Workflow + KI-Integration

Tag 6-7: n8n Workflow bauen

11. Webhook Node (Empfang von Intrexx)
12. Function Node (Base64 → Binary)
13. Claude Vision Node (OCR + Extraktion)
14. Function Node (JSON-Parsing + Validierung)
15. IF Node (Confidence > 90%?)

Tag 8: Duplikate-Check

16. HTTP Request Node (Intrexx REST API Query)
17. Function Node (Duplikate-Logik: Rechnungsnummer + Betrag+Datum)
18. IF Node (Duplikat gefunden?)

Tag 9-10: Callback an Intrexx

19. HTTP Request Node (Intrexx REST API Update)
20. Error-Trigger Node (bei Fehlern: Slack/E-Mail Alert)
21. Testing (10 Test-Rechnungen durchlaufen lassen)

Woche 3: Testing, Optimierung, Rollout

Tag 11-12: User Acceptance Testing

22. 50 echte Rechnungen durchlaufen lassen
23. Fehleranalyse (welche Rechnungen hatten Confidence <90%?)
24. Prompt-Optimierung (Claude Prompt anpassen für bessere Extraktion)

Tag 13: GoBD-Archivierung

25. PDF/A-Konvertierung in Intrexx aktivieren
26. Audit-Log (wer hat wann welche Rechnung validiert?)
27. Backup-Strategie testen

Tag 14-15: Training & Rollout

28. User-Training (Buchhaltung): Wie funktioniert das System?
29. Dokumentation schreiben (Prozess-Diagramm, FAQ)
30. Go-Live: System für alle Mitarbeiter freischalten

Code-Beispiele (Groovy, n8n, Claude Prompt)

1. Intrexx Groovy Hook (afterSave)

// ==========================================
// Intrexx Event Handler: afterSave
// Trigger: Rechnung wurde hochgeladen
// ==========================================

import groovy.json.JsonOutput
import groovy.json.JsonSlurper

def invoiceFile = g_record.getFile("invoice_pdf")
if (invoiceFile == null) {
    g_log.error("Keine Rechnung gefunden für ID: ${g_record.getIntegerValue('id')}")
    return
}

// PDF zu Base64 konvertieren
def invoiceBase64 = invoiceFile.getBytes().encodeBase64().toString()

// n8n Webhook URL (aus Intrexx Config)
def n8nWebhookUrl = "https://n8n.your-company.de/webhook/invoice-check"
def apiKey = "YOUR_SECRET_API_KEY"

// Payload erstellen
def payload = [
    invoice_id: g_record.getIntegerValue("id"),
    pdf_base64: invoiceBase64,
    supplier_name: g_record.getStringValue("supplier_name") ?: "",
    upload_timestamp: new Date().format("yyyy-MM-dd'T'HH:mm:ss'Z'")
]

try {
    def connection = new URL(n8nWebhookUrl).openConnection()
    connection.setRequestMethod("POST")
    connection.doOutput = true
    connection.setRequestProperty("Content-Type", "application/json")
    connection.setRequestProperty("X-API-Key", apiKey)
    connection.setConnectTimeout(5000)  // 5 Sek.
    connection.setReadTimeout(30000)    // 30 Sek.

    def writer = new OutputStreamWriter(connection.outputStream, "UTF-8")
    writer.write(JsonOutput.toJson(payload))
    writer.flush()
    writer.close()

    def responseCode = connection.responseCode

    if (responseCode == 200) {
        def response = connection.inputStream.text
        def json = new JsonSlurper().parseText(response)

        g_record.setValue("processing_status", "In Verarbeitung")
        g_record.setValue("n8n_workflow_id", json.workflow_id ?: "")

        g_log.info("n8n Workflow gestartet für Invoice ID: ${g_record.getIntegerValue('id')}")
    } else {
        g_log.error("n8n HTTP Error ${responseCode} für Invoice ID: ${g_record.getIntegerValue('id')}")
        g_record.setValue("processing_status", "Fehler beim Senden")
    }

} catch (Exception e) {
    g_log.error("n8n Request fehlgeschlagen: ${e.message}")
    g_record.setValue("processing_status", "Fehler: ${e.message}")
}

2. Claude Vision Prompt (in n8n)

// n8n Node: Claude Vision API Call

{
  "model": "claude-3-7-sonnet-20250219",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "base64",
            "media_type": "application/pdf",
            "data": "{{ $json.pdf_base64 }}"
          }
        },
        {
          "type": "text",
          "text": `Du bist ein Experte für Rechnungsprüfung.
Extrahiere aus dieser Rechnung folgende Daten:

1. **Rechnungsnummer** (z.B. RE-2026-001, Inv-12345, etc.)
2. **Rechnungsbetrag** (Brutto in EUR, nur die Zahl)
3. **Rechnungsdatum** (Format: YYYY-MM-DD)
4. **Lieferant** (Firmenname)
5. **USt-ID** (Format: DE + 9 Ziffern, z.B. DE123456789)
6. **Confidence Score** (0-100%): Wie sicher bist du bei der Extraktion?

WICHTIG:
- Wenn ein Feld nicht gefunden werden kann: null
- Betrag ohne € Symbol, nur Zahl (z.B. 1234.56)
- Datum im ISO-Format (YYYY-MM-DD)
- Confidence Score: 100% = absolut sicher, 50% = unsicher

Antwort als JSON (ohne Erklärung):

{
  "invoice_number": "...",
  "amount": 1234.56,
  "date": "2026-01-10",
  "supplier": "Firma XY GmbH",
  "vat_id": "DE123456789",
  "confidence": 95
}`
        }
      ]
    }
  ]
}

3. n8n Duplikate-Check (Function Node)

// n8n Function Node: Duplikate-Check

const extractedData = $input.first().json;
const invoiceNumber = extractedData.invoice_number;
const amount = extractedData.amount;
const date = extractedData.date;
const supplier = extractedData.supplier;

// Intrexx REST API abfragen (vorherige Node hat Datenbank-Abfrage gemacht)
const existingInvoices = $('Intrexx_Query').all();

let isDuplicate = false;
let duplicateReason = "";

// Check 1: Rechnungsnummer exakt gleich
for (const invoice of existingInvoices) {
    if (invoice.json.invoice_number === invoiceNumber) {
        isDuplicate = true;
        duplicateReason = `Duplikat: Rechnungsnummer ${invoiceNumber} existiert bereits (ID: ${invoice.json.id})`;
        break;
    }
}

// Check 2: Betrag + Lieferant + Datum (±3 Tage) gleich
if (!isDuplicate) {
    const invoiceDate = new Date(date);

    for (const invoice of existingInvoices) {
        const existingDate = new Date(invoice.json.invoice_date);
        const daysDiff = Math.abs((invoiceDate - existingDate) / (1000 * 60 * 60 * 24));

        if (
            invoice.json.amount === amount &&
            invoice.json.supplier_name === supplier &&
            daysDiff <= 3
        ) {
            isDuplicate = true;
            duplicateReason = `Duplikat-Verdacht: Gleicher Betrag (${amount}€) vom gleichen Lieferanten (${supplier}) am ${date} (±3 Tage)`;
            break;
        }
    }
}

return {
    ...extractedData,
    is_duplicate: isDuplicate,
    duplicate_reason: duplicateReason
};

Häufig gestellte Fragen (FAQ)

Weiterführende Artikel:

• Backend-KI-Workflows: Kompletter Guide
• n8n + Intrexx Integration: Technischer Guide
• Backend-KI vs Company GPT: 7 Gründe