Überblick

GPT-4 Vision = Multimodales LLM (versteht Text + Bilder) → perfekt für Rechnungsverarbeitung.

Problem: Manuelle Rechnungskategorisierung (Buchhalter muss jede Rechnung lesen + Konto zuordnen).

Lösung: GPT-4 Vision liest Rechnung (PDF/JPG) + kategorisiert automatisch (z.B. "Konto 4200 - Büromaterial").

Accuracy: 95%+ (bei korrekt trainiertem Few-Shot-Prompt).

Dieser Guide zeigt:

✅ PDF → Bild-Konvertierung
✅ GPT-4 Vision API-Call (mit Schweizer Kontenplan)
✅ Few-Shot Learning (Beispiel-Rechnungen)
✅ Bexio-Integration (automatische Verbuchung)

Grundlagen: GPT-4 Vision

GPT-4 Vision (Modell: gpt-4-vision-preview oder gpt-4-turbo) = GPT-4 mit Bild-Input.

Unterstützte Formate:

✅ PNG, JPG, WEBP, GIF (non-animated)
✅ NICHT PDF (muss zu Bild konvertiert werden)

Input-Methoden:

URL: https://example.com/invoice.jpg
Base64: Bild als String (für lokale Dateien)

Kosten (Stand 2026):

Input (Bild): USD 0,01 / Bild (1024×1024 px)
Input (Text): USD 0,01 / 1k Token
Output (Text): USD 0,03 / 1k Token

Beispiel (Rechnung 1-seitig, 2k Antwort-Tokens):

Bild: USD 0,01
Antwort: 2k × USD 0,03 / 1k = USD 0,06
TOTAL: USD 0,07 ≈ CHF 0,06

PDF zu Bild konvertieren

Problem: GPT-4 Vision akzeptiert KEINE PDFs (nur Bilder).

Lösung: pdf2image (Python-Library).

2.1 Installation

# pdf2image installieren
pip install pdf2image pillow

# poppler-utils (erforderlich für pdf2image)
# Windows: choco install poppler
# Mac: brew install poppler
# Linux: sudo apt install poppler-utils

2.2 PDF → PNG konvertieren (Python)

from pdf2image import convert_from_path
import base64

def pdf_to_base64_image(pdf_path: str) -> str:
    """Konvertiert PDF-Rechnung zu Base64-Bild (erste Seite)."""

    # PDF → PIL Image (erste Seite)
    images = convert_from_path(pdf_path, dpi=300, first_page=1, last_page=1)
    image = images[0]

    # Image → Base64
    from io import BytesIO
    buffer = BytesIO()
    image.save(buffer, format="PNG")
    img_bytes = buffer.getvalue()
    img_base64 = base64.b64encode(img_bytes).decode("utf-8")

    return f"data:image/png;base64,{img_base64}"

# Beispiel
invoice_image = pdf_to_base64_image("rechnung_001.pdf")
print(f"Base64-Länge: {len(invoice_image)} Zeichen")

Ausgabe: Base64-String (ca. 500k Zeichen für 1-seitige Rechnung).

3. Few-Shot Learning (Schweizer Kontenplan)

Few-Shot Learning = Beispiele im Prompt (GPT-4 lernt aus Beispielen).

Schweizer Kontenplan (KMU-Standard):

4200 - Büromaterial
4400 - Fahrzeugkosten
4500 - Raumkosten (Miete)
4600 - Werbung
4900 - Beratung
5000 - Löhne
6000 - Zinsaufwand

3.1 Few-Shot Prompt erstellen

System Prompt:

system_prompt = """Du bist ein Buchhaltungs-Assistent für Schweizer KMU.

Deine Aufgabe: Analysiere Rechnung (Bild) und kategorisiere sie gemäß Schweizer Kontenplan.

KONTENPLAN (KMU):
- 4200: Büromaterial (Stifte, Papier, Toner)
- 4400: Fahrzeugkosten (Benzin, Versicherung, Reparatur)
- 4500: Raumkosten (Miete, Nebenkosten, Reinigung)
- 4600: Werbung (Online-Ads, Printanzeigen, Social Media)
- 4900: Beratung (Steuerberatung, Rechtsberatung, Consulting)
- 5000: Löhne (Gehälter, Sozialversicherungen)
- 6000: Zinsaufwand (Bankzinsen, Kreditkarten-Zinsen)

WICHTIG:
- Gib NUR die Kontonummer zurück (z.B. "4200")
- Falls unklar: Gib "UNKLAR" zurück
- Schweizer MwSt.-Sätze: 8,1% (Normal), 2,6% (reduziert), 3,8% (Beherbergung)

BEISPIELE:

Rechnung: "Migros - Bürobedarf CHF 45,50"
→ 4200 (Büromaterial)

Rechnung: "Shell Tankstelle CHF 80,00"
→ 4400 (Fahrzeugkosten)

Rechnung: "Google Ads CHF 500,00"
→ 4600 (Werbung)

Rechnung: "Treuhand AG - Jahresabschluss CHF 2.500"
→ 4900 (Beratung)
"""

3.2 GPT-4 Vision API-Call (Python)

import openai
import base64

client = openai.OpenAI(api_key="your_openai_api_key")

def classify_invoice(image_base64: str) -> dict:
    """Kategorisiert Rechnung mit GPT-4 Vision."""

    response = client.chat.completions.create(
        model="gpt-4-vision-preview",  # oder gpt-4-turbo
        messages=[
            {
                "role": "system",
                "content": system_prompt  # Few-Shot-Prompt von oben
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": "Welches Konto? (Nur Nummer angeben)"
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": image_base64,  # Base64-String
                            "detail": "high"  # high = bessere Accuracy
                        }
                    }
                ]
            }
        ],
        max_tokens=100
    )

    # Antwort extrahieren
    account_code = response.choices[0].message.content.strip()

    return {
        "account_code": account_code,
        "confidence": "high" if account_code != "UNKLAR" else "low"
    }

# Beispiel
invoice_img = pdf_to_base64_image("rechnung_migros.pdf")
result = classify_invoice(invoice_img)
print(result)
# Output: {"account_code": "4200", "confidence": "high"}

4. Datenextraktion (Betrag, Lieferant, Datum)

Zusätzliche Aufgabe: GPT-4 soll NICHT nur kategorisieren, sondern auch Daten extrahieren.

Erweiteter Prompt:

extraction_prompt = """Analysiere Rechnung und extrahiere:
1. Lieferant (Name)
2. Betrag (CHF, netto ohne MwSt.)
3. MwSt.-Satz (%, z.B. 8.1)
4. Datum (YYYY-MM-DD)
5. Kontonummer (Kategorisierung, siehe Kontenplan oben)

Ausgabe als JSON:
{
  "supplier": "...",
  "amount": 123.45,
  "vat_rate": 8.1,
  "date": "2026-02-01",
  "account_code": "4200"
}

Falls Feld nicht erkennbar: null
"""

# API-Call (mit extraction_prompt)
response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {"role": "system", "content": system_prompt + "\n\n" + extraction_prompt},
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Extrahiere Daten aus Rechnung (JSON):"},
                {"type": "image_url", "image_url": {"url": invoice_img, "detail": "high"}}
            ]
        }
    ],
    max_tokens=300,
    response_format={"type": "json_object"}  # GPT-4 gibt JSON zurück
)

# JSON parsen
import json
invoice_data = json.loads(response.choices[0].message.content)
print(invoice_data)
# Output:
# {
#   "supplier": "Migros",
#   "amount": 45.50,
#   "vat_rate": 8.1,
#   "date": "2026-02-01",
#   "account_code": "4200"
# }

5. Bexio-Integration (Automatische Buchung)

Workflow: GPT-4 extrahiert Daten → Kreditorenrechnung in Bexio erstellen.

5.1 Lieferant in Bexio suchen/erstellen

import requests

def get_or_create_bexio_supplier(supplier_name: str, bexio_token: str) -> int:
    """Sucht Lieferanten in Bexio, erstellt falls nicht vorhanden."""

    headers = {"Authorization": f"Bearer {bexio_token}"}

    # Suche
    search_response = requests.get(
        "https://api.bexio.com/3.0/contacts",
        headers=headers,
        params={"name": supplier_name}
    )
    contacts = search_response.json()

    if contacts:
        return contacts[0]["id"]  # Lieferant gefunden

    # Erstellen (falls nicht gefunden)
    create_response = requests.post(
        "https://api.bexio.com/3.0/contacts",
        headers=headers,
        json={
            "contact_type_id": 2,  # 2 = Lieferant
            "name_1": supplier_name
        }
    )
    return create_response.json()["id"]

5.2 Kreditorenrechnung erstellen

def create_bexio_expense(invoice_data: dict, bexio_token: str) -> int:
    """Erstellt Kreditorenrechnung in Bexio."""

    headers = {"Authorization": f"Bearer {bexio_token}"}

    # Lieferant abrufen/erstellen
    supplier_id = get_or_create_bexio_supplier(invoice_data["supplier"], bexio_token)

    # Rechnung erstellen
    expense_response = requests.post(
        "https://api.bexio.com/3.0/purchase_invoices",
        headers=headers,
        json={
            "contact_id": supplier_id,
            "title": f"Rechnung {invoice_data['supplier']}",
            "date": invoice_data["date"],
            "due_date": invoice_data["date"],  # Vereinfacht: Fälligkeit = Rechnungsdatum
            "currency_id": 1,  # 1 = CHF
            "positions": [
                {
                    "amount": 1,
                    "unit_price": invoice_data["amount"],
                    "account_id": int(invoice_data["account_code"]),  # Konto aus GPT-4
                    "tax_id": get_tax_id(invoice_data["vat_rate"])  # MwSt.-Satz-ID
                }
            ]
        }
    )

    return expense_response.json()["id"]

def get_tax_id(vat_rate: float) -> int:
    """Konvertiert MwSt.-Satz zu Bexio Tax ID."""
    # Vereinfachte Mapping (in Praxis: Bexio API abfragen)
    tax_map = {
        8.1: 7,   # 8,1% Normal
        2.6: 3,   # 2,6% reduziert
        3.8: 4,   # 3,8% Beherbergung
        0.0: 22   # 0% (Reverse Charge, Export)
    }
    return tax_map.get(vat_rate, 7)  # Default: 8,1%

5.3 End-to-End-Workflow

# 1. PDF → Bild
invoice_img = pdf_to_base64_image("rechnung_migros.pdf")

# 2. GPT-4 Vision: Daten extrahieren
invoice_data = classify_invoice_with_extraction(invoice_img)
print(f"Extrahiert: {invoice_data}")

# 3. Bexio: Rechnung erstellen
bexio_token = "your_bexio_api_token"
expense_id = create_bexio_expense(invoice_data, bexio_token)
print(f"✅ Kreditorenrechnung erstellt in Bexio: ID {expense_id}")

Resultat: Vollautomatische Rechnungsverarbeitung (PDF → Bexio, 0 manuelle Eingaben).

6. Accuracy-Testing

Ziel: 95%+ Accuracy (bei Kategorisierung).

6.1 Test-Dataset erstellen

100 Rechnungen (manuell kategorisiert als Ground Truth):

rechnung_001.pdf → 4200 (Büromaterial)
rechnung_002.pdf → 4400 (Fahrzeugkosten)
rechnung_003.pdf → 4600 (Werbung)
...

6.2 Batch-Testing (Python)

import pandas as pd

# Test-Dataset
test_data = pd.read_csv("test_invoices.csv")  # Spalten: filename, true_account_code

results = []

for idx, row in test_data.iterrows():
    # GPT-4 Prediction
    invoice_img = pdf_to_base64_image(f"invoices/{row['filename']}")
    prediction = classify_invoice(invoice_img)

    # Ground Truth
    true_account = row["true_account_code"]
    predicted_account = prediction["account_code"]

    # Accuracy
    is_correct = (predicted_account == true_account)

    results.append({
        "filename": row["filename"],
        "true": true_account,
        "predicted": predicted_account,
        "correct": is_correct
    })

    print(f"{idx+1}/100: {row['filename']} → {predicted_account} (True: {true_account}) {'✅' if is_correct else '❌'}")

# Accuracy berechnen
results_df = pd.DataFrame(results)
accuracy = results_df["correct"].mean() * 100
print(f"\nAccuracy: {accuracy:.2f}%")

Erwartetes Ergebnis: 95-98% Accuracy (bei guter Few-Shot-Prompt-Qualität).

6.3 Fehleranalyse

Häufige Fehler:

Ambivalente Kategorien: "Consulting" könnte 4900 (Beratung) oder 4600 (Marketing-Consulting) sein
- Lösung: Klarere Kontenplan-Beschreibungen im Prompt
Schlechte Bildqualität: Verschwommene/gescannte Rechnungen
- Lösung: DPI erhöhen (300 → 600 DPI)
Fremdsprachen: Rechnung auf Englisch/Französisch
- Lösung: Mehrsprachige Beispiele im Few-Shot-Prompt

7. Kostenoptimierung

Problem: GPT-4 Vision ist teuer (CHF 0,06/Rechnung).

Optimierungen:

7.1 Image Compression (kleinere Dateien)

Vorher: 1024×1024 px (USD 0,01) Nachher: 512×512 px (USD 0,005, 50% günstiger)

from PIL import Image

def compress_image(image_path: str, max_size: int = 512) -> str:
    """Komprimiert Bild auf max_size × max_size px."""
    img = Image.open(image_path)
    img.thumbnail((max_size, max_size))

    # Base64
    from io import BytesIO
    buffer = BytesIO()
    img.save(buffer, format="PNG")
    img_bytes = buffer.getvalue()
    img_base64 = base64.b64encode(img_bytes).decode("utf-8")
    return f"data:image/png;base64,{img_base64}"

Trade-off: Accuracy kann sinken (98% → 95%).

7.2 Detail-Level reduzieren

GPT-4 Vision Detail-Levels:

"high": Beste Accuracy, höchste Kosten (USD 0,01)
"low": Schlechtere Accuracy, niedrigere Kosten (USD 0,005)

# Low-Detail (50% günstiger)
response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[...],
    max_tokens=100,
    # Bild-Config
    {
        "type": "image_url",
        "image_url": {
            "url": invoice_img,
            "detail": "low"  # ← 50% günstiger
        }
    }
)

7.3 Hybrid-Ansatz (GPT-4 + Claude)

Strategie: GPT-4 Vision für Kategorisierung (teuer, aber genau) + Claude Haiku für Datenextraktion (günstig).

Workflow:

GPT-4 Vision: Kategorisierung (Konto 4200) → CHF 0,01
Claude Haiku: Text-Extraktion (Betrag, Datum) → CHF 0,001 (10× günstiger)

TOTAL: CHF 0,011 (statt CHF 0,06, 82% günstiger)

8. ROI-Kalkulation

Szenario: 200 Rechnungen/Monat (manuelle Kategorisierung).

Manuell (OHNE AI)

Aufwand:

200 Rechnungen × 3 Min (lesen + kategorisieren) = 600 Min/Monat = 10h/Monat
Kosten: 10h × CHF 85/h = CHF 850/Monat

AI-Automation (MIT GPT-4 Vision)

Kosten:

GPT-4 Vision: 200 × CHF 0,06 = CHF 12/Monat
Entwicklung (einmalig, 20h × CHF 150/h): CHF 3.000
Jahr 1: CHF 3.000 + CHF 144 = CHF 3.144
Ab Jahr 2: CHF 144/Jahr

Einsparung:

Jahr 1: CHF 10.200 (12 × CHF 850) - CHF 3.144 = CHF 7.056 (224% ROI)
Jahr 2: CHF 10.200 - CHF 144 = CHF 10.056 (6.983% ROI) 🚀

9. Häufige Fragen

F: Funktioniert GPT-4 Vision auch mit handgeschriebenen Rechnungen? A: Ja, aber Accuracy sinkt (98% → 85%). Getippte/digitale Rechnungen sind besser.

F: Kann GPT-4 Vision mehrere Seiten verarbeiten? A: Ja, aber jede Seite = separater API-Call (Kosten steigen). Besser: Nur erste Seite.

F: Wie sicher sind meine Rechnungen bei OpenAI? A: OpenAI speichert KEINE API-Daten für Training (Enterprise-Plan). Trotzdem: Verschlüsselung (TLS 1.3) nutzen.

F: Gibt es Alternativen zu GPT-4 Vision? A: Ja: Claude 3 Opus (Anthropic), Google Gemini Pro Vision. Ähnliche Accuracy, unterschiedliche Preise.

F: Kann ich GPT-4 Vision für QR-Rechnungen nutzen? A: Ja, aber OCR-Libraries (pyzbar) sind günstiger + schneller für QR-Codes.

Nächste Schritte

Option 1: GPT-4 Invoice-Automation-Service (CHF 3.000, 20h)

Wir entwickeln Custom-Lösung für Ihre Buchhaltung
Inklusive: PDF-Konvertierung, GPT-4 Vision, Bexio-Integration, Testing

👉 Service buchen

Option 2: Kostenlose Beratung (60 Min)

Wir analysieren Ihre Rechnungs-Workflows
ROI-Berechnung: Lohnt sich GPT-4 Vision für Ihr KMU?

👉 Termin buchen

Veröffentlicht: 02. Februar 2026 Autor: SwissFinanceAI Team Kategorie: AI Automation

Haftungsausschluss: Dieser Artikel dient ausschliesslich zu Informationszwecken und stellt keine Finanzberatung dar. Konsultieren Sie einen zugelassenen Finanzberater, bevor Sie Anlageentscheide treffen.

GPT-4 Invoice Classification: Automatische Rechnungskategorisierung mit AI