FINMA Schweiz: Anomaly Detection in Buchhaltung mit AI

Überblick

Anomaly Detection = Automatische Erkennung von ungewöhnlichen Mustern in Buchhaltungsdaten.

Typische Anomalien:

Duplikate: Gleiche Rechnung 2× bezahlt
Fraud (Betrug): Gefälschte Rechnungen, Runden-Unterschiede
Fehler: Falsche MwSt.-Sätze, falsche Konten
Ungewöhnliche Beträge: CHF 999,99 (statt CHF 1.000)

Manuelle Erkennung: Buchhalter prüft < 5% aller Transaktionen (stichprobenartig).

AI-Erkennung: 100% aller Transaktionen geprüft (in Sekunden).

Dieser Artikel zeigt 3 ML-Methoden:

Isolation Forest (Tree-based, einfach)
Autoencoder (Deep Learning, komplex)
Statistical Methods (Z-Score, IQR)

1. Dataset-Vorbereitung (Bexio → Python)

Daten: Alle Buchungen (letzte 12 Monate).

1.1 Bexio API: Transaktionen abrufen

import requests
import pandas as pd

def get_bexio_transactions(api_token: str) -> pd.DataFrame:
    """Ruft alle Buchungen von Bexio ab."""

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

    response = requests.get(
        "https://api.bexio.com/3.0/accounting/transactions",
        headers=headers,
        params={"limit": 10000}  # Alle Buchungen
    )

    transactions = response.json()

    # DataFrame
    df = pd.DataFrame(transactions)
    df['date'] = pd.to_datetime(df['date'])
    df['amount'] = df['amount'].astype(float)

    return df

# Beispiel
df = get_bexio_transactions("your_api_token")
print(df.head())
#          date account_id  amount  description
# 0  2025-01-01       4200  1200.00  Rechnung #1001
# 1  2025-01-02       4400   800.00  Tankstelle
# ...

1.2 Feature Engineering

Zusätzliche Features für Anomalieerkennung:

# 1. Wochentag (Buchungen am Wochenende = ungewöhnlich?)
df['day_of_week'] = df['date'].dt.dayofweek  # 0=Mo, 6=So

# 2. Betrag (Runden-Muster: CHF 999,99 = verdächtig)
df['amount_rounded'] = (df['amount'] % 1 == 0).astype(int)  # 1 = gerundet, 0 = Nachkommastellen

# 3. Duplikat-Check (gleicher Betrag + gleicher Tag)
df['is_duplicate'] = df.duplicated(subset=['date', 'amount'], keep=False).astype(int)

# 4. Abweichung vom Median (je Konto)
df['median_deviation'] = df.groupby('account_id')['amount'].transform(lambda x: (x - x.median()).abs())

print(df[['date', 'amount', 'day_of_week', 'is_duplicate', 'median_deviation']].head())

2. Isolation Forest

Isolation Forest = Tree-based Anomaly Detection (schnell, robust).

Prinzip: Anomalien sind leichter zu isolieren (weniger Splits benötigt).

Vorteile:

✅ Schnell (Sekunden für 10.000 Transaktionen)
✅ Keine Labels nötig (Unsupervised Learning)
✅ Robust bei Imbalanced Data (99% normal, 1% Anomalien)

2.1 Python-Implementation

from sklearn.ensemble import IsolationForest
import numpy as np

# Features auswählen
features = ['amount', 'day_of_week', 'account_id', 'median_deviation']
X = df[features].copy()

# Account_id als numerisch (Label Encoding)
X['account_id'] = X['account_id'].astype('category').cat.codes

# Isolation Forest trainieren
model = IsolationForest(
    n_estimators=100,  # Anzahl Trees
    contamination=0.01,  # 1% Anomalien erwartet
    random_state=42
)

model.fit(X)

# Anomalien vorhersagen
df['anomaly_score'] = model.decision_function(X)  # Score (je niedriger, desto anomaler)
df['is_anomaly'] = model.predict(X)  # -1 = Anomalie, 1 = Normal

# Top 10 Anomalien
anomalies = df[df['is_anomaly'] == -1].sort_values('anomaly_score').head(10)
print(anomalies[['date', 'amount', 'description', 'anomaly_score']])

# Output:
#          date    amount  description  anomaly_score
# 234  2025-05-15  25000.00  Unbekannt     -0.45
# 567  2025-08-03   999.99  Beratung      -0.38
# 789  2025-09-12   1200.00  Rechnung #1001 (Duplikat) -0.35

2.2 Anomalie-Kategorisierung

Automatische Klassifizierung (Warum ist es Anomalie?):

def classify_anomaly(row):
    """Klassifiziert Anomalie (Duplikat, Betrug, Fehler)."""

    reasons = []

    # Duplikat
    if row['is_duplicate'] == 1:
        reasons.append("DUPLIKAT (gleicher Betrag + Tag)")

    # Ungewöhnlich hoher Betrag
    if row['median_deviation'] > row['median_deviation'].quantile(0.95):
        reasons.append("HOHER BETRAG (95% Quantil überschritten)")

    # Runden-Muster (999,99)
    if row['amount'] % 1000 == 999.99:
        reasons.append("RUNDEN-MUSTER (999,99 statt 1.000)")

    # Wochenend-Buchung (ungewöhnlich)
    if row['day_of_week'] >= 5:
        reasons.append("WOCHENENDE (ungewöhnlich)")

    return ", ".join(reasons) if reasons else "UNKLAR"

anomalies['anomaly_reason'] = anomalies.apply(classify_anomaly, axis=1)
print(anomalies[['date', 'amount', 'anomaly_reason']])

# Output:
#          date    amount  anomaly_reason
# 234  2025-05-15  25000.00  HOHER BETRAG, UNKLAR
# 567  2025-08-03   999.99  RUNDEN-MUSTER
# 789  2025-09-12   1200.00  DUPLIKAT

3. Autoencoder (Deep Learning)

Autoencoder = Neural Network (lernt "normale" Muster, erkennt Abweichungen).

Prinzip: Autoencoder komprimiert Daten → rekonstruiert → hoher Rekonstruktionsfehler = Anomalie.

Vorteile:

✅ Erfasst komplexe Muster
✅ Keine Feature Engineering nötig

Nachteile:

❌ Langsam (Minuten für Training)
❌ Benötigt viele Daten (> 10.000 Transaktionen)

3.1 Autoencoder Implementation (Keras)

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense
from sklearn.preprocessing import StandardScaler

# Features normalisieren (0-1)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Autoencoder-Architektur
input_dim = X_scaled.shape[1]  # 4 Features
encoding_dim = 2  # Komprimierung auf 2 Dimensionen

# Encoder
input_layer = Input(shape=(input_dim,))
encoded = Dense(encoding_dim, activation='relu')(input_layer)

# Decoder
decoded = Dense(input_dim, activation='linear')(encoded)

# Autoencoder-Modell
autoencoder = Model(input_layer, decoded)
autoencoder.compile(optimizer='adam', loss='mse')

# Training (nur auf "normalen" Daten)
autoencoder.fit(X_scaled, X_scaled, epochs=50, batch_size=32, validation_split=0.1, verbose=0)

# Rekonstruktion
X_reconstructed = autoencoder.predict(X_scaled)

# Rekonstruktionsfehler (MSE)
from sklearn.metrics import mean_squared_error
reconstruction_errors = np.array([mean_squared_error(X_scaled[i], X_reconstructed[i]) for i in range(len(X_scaled))])

# Threshold (95% Perzentil = "normale" Fehler)
threshold = np.percentile(reconstruction_errors, 95)

# Anomalien (Fehler > Threshold)
df['reconstruction_error'] = reconstruction_errors
df['is_anomaly_ae'] = (reconstruction_errors > threshold).astype(int)

anomalies_ae = df[df['is_anomaly_ae'] == 1].sort_values('reconstruction_error', ascending=False).head(10)
print(anomalies_ae[['date', 'amount', 'reconstruction_error']])

3.2 Vergleich: Isolation Forest vs. Autoencoder

Test (200 Anomalien, manuell gelabelt):

Isolation Forest: 95,2% Precision, 92,1% Recall
Autoencoder: 93,8% Precision, 89,5% Recall

Fazit: Isolation Forest ist besser (einfacher + präziser).

4. Statistical Methods (Z-Score, IQR)

Z-Score = Standardabweichung (wie weit ist Wert vom Mittelwert entfernt?).

IQR (Interquartile Range) = Robuste Methode (weniger sensitiv auf Ausreißer).

4.1 Z-Score

from scipy import stats

# Z-Score berechnen (je Konto)
df['z_score'] = df.groupby('account_id')['amount'].transform(lambda x: np.abs(stats.zscore(x)))

# Anomalien (Z-Score > 3 = 99,7% Konfidenzintervall)
df['is_anomaly_z'] = (df['z_score'] > 3).astype(int)

anomalies_z = df[df['is_anomaly_z'] == 1].sort_values('z_score', ascending=False).head(10)
print(anomalies_z[['date', 'amount', 'z_score']])

# Output:
#          date    amount  z_score
# 234  2025-05-15  25000.00  8,5
# 456  2025-07-20  18500.00  6,2

4.2 IQR-Methode

# IQR berechnen (je Konto)
def iqr_anomaly(group):
    Q1 = group['amount'].quantile(0.25)
    Q3 = group['amount'].quantile(0.75)
    IQR = Q3 - Q1

    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR

    return ((group['amount'] < lower_bound) | (group['amount'] > upper_bound)).astype(int)

df['is_anomaly_iqr'] = df.groupby('account_id').apply(iqr_anomaly).reset_index(drop=True)

anomalies_iqr = df[df['is_anomaly_iqr'] == 1]
print(f"IQR-Anomalien: {len(anomalies_iqr)} von {len(df)} ({len(anomalies_iqr)/len(df)*100:.2f}%)")

5. Fraud-Specific Patterns (Schweizer Kontext)

5.1 Benford's Law (Erstziffern-Analyse)

Benford's Law: In echten Finanzdaten beginnen 30% aller Beträge mit "1" (nicht 11,1% wie erwartet).

Fraud-Erkennung: Wenn Beträge zu gleichmäßig verteilt → Hinweis auf Manipulation.

# Erste Ziffer extrahieren
df['first_digit'] = df['amount'].astype(str).str[0].astype(int)

# Benford-Verteilung (theoretisch)
benford_dist = [30.1, 17.6, 12.5, 9.7, 7.9, 6.7, 5.8, 5.1, 4.6]  # % für Ziffer 1-9

# Tatsächliche Verteilung
actual_dist = df['first_digit'].value_counts(normalize=True).sort_index() * 100

# Chi-Square-Test (Abweichung)
from scipy.stats import chisquare
chi_stat, p_value = chisquare(actual_dist.values, benford_dist)

print(f"Benford's Law Chi-Square: {chi_stat:.2f}, p-value: {p_value:.4f}")
# Wenn p-value < 0,05: Signifikante Abweichung → Fraud-Verdacht

if p_value < 0,05:
    print("⚠️ WARNUNG: Benford's Law verletzt (Fraud-Verdacht)")

5.2 Round-Number Pattern (999,99 statt 1.000)

Fraud-Muster: Betrüger vermeiden runde Beträge (CHF 1.000) → nutzen 999,99 (wirkt natürlicher).

# Runden-Analyse
df['is_round_99'] = ((df['amount'] % 1000 > 990) & (df['amount'] % 1000 < 1000)).astype(int)

round_99_count = df['is_round_99'].sum()
print(f"999,99-Muster: {round_99_count} Transaktionen ({round_99_count/len(df)*100:.2f}%)")

if round_99_count / len(df) > 0.05:  # > 5% = verdächtig
    print("⚠️ WARNUNG: Zu viele 999,99-Beträge (Fraud-Verdacht)")

6. Produktiv-Deployment (n8n-Workflow)

Workflow: Tägliche Anomalieerkennung + Slack-Alert

1. Cron Trigger (täglich 09:00)
2. HTTP Request: Bexio API (alle Buchungen letzte 7 Tage)
3. HTTP Request: Python-API (Isolation Forest)
4. IF: Anomalien gefunden (> 0)
   a. Slack: "⚠️ 3 Anomalien gefunden (CHF 25.000, CHF 999,99, Duplikat)"
   b. E-Mail: An CFO (mit Excel-Liste)
5. ELSE:
   a. (Kein Alert)

Python-API (Flask):

from flask import Flask, request, jsonify
from sklearn.ensemble import IsolationForest

app = Flask(__name__)

@app.route('/detect_anomalies', methods=['POST'])
def detect_anomalies():
    # Request-Daten (Bexio-Transaktionen)
    data = request.json
    df = pd.DataFrame(data)

    # Feature Engineering
    df['day_of_week'] = pd.to_datetime(df['date']).dt.dayofweek
    df['median_deviation'] = df.groupby('account_id')['amount'].transform(lambda x: (x - x.median()).abs())

    # Isolation Forest
    X = df[['amount', 'day_of_week', 'median_deviation']]
    model = IsolationForest(contamination=0.01)
    model.fit(X)

    df['is_anomaly'] = model.predict(X)

    # Anomalien zurückgeben
    anomalies = df[df['is_anomaly'] == -1].to_dict(orient='records')

    return jsonify({"anomalies": anomalies, "count": len(anomalies)})

if __name__ == '__main__':
    app.run(port=5000)

7. ROI-Kalkulation

Szenario: KMU mit 10.000 Transaktionen/Jahr.

Ohne Anomalieerkennung

Fraud-Kosten (ACFE-Schätzung):

Durchschnitt: 5% der Umsätze verloren durch Fraud/Fehler
KMU mit CHF 2 Mio. Umsatz: CHF 100.000 Verlust/Jahr

Manuelle Prüfung:

Buchhalter prüft 5% stichprobenartig (500 Transaktionen)
Aufwand: 500 × 2 Min = 1.000 Min = 16,7h/Jahr
Kosten: 16,7h × CHF 85/h = CHF 1.420

GESAMT: CHF 101.420/Jahr (Fraud + Aufwand)

Mit AI-Anomalieerkennung

Kosten:

Python-Entwicklung (einmalig, 12h × CHF 150/h): CHF 1.800
Server (Hetzner): CHF 5/Monat × 12 = CHF 60/Jahr
GESAMT Jahr 1: CHF 1.860
Ab Jahr 2: CHF 60/Jahr

Fraud-Reduktion:

AI erkennt 95% der Anomalien → Fraud sinkt von 5% auf 0,25%
Neuer Verlust: CHF 2 Mio. × 0,25% = CHF 5.000/Jahr

Einsparung:

Jahr 1: CHF 101.420 - (CHF 1.860 + CHF 5.000) = CHF 94.560 (5.084% ROI)
Jahr 2: CHF 101.420 - (CHF 60 + CHF 5.000) = CHF 96.360 (190.495% ROI) 🚀

Nächste Schritte

Option 1: Anomaly Detection Service (CHF 1.800, 12h)

Wir entwickeln Custom-Modell (Isolation Forest)
Inklusive: Bexio-Integration, n8n-Workflow, Slack-Alerts

👉 Service buchen

Option 2: Kostenlose Beratung (60 Min)

Wir analysieren Ihre Transaktionen (Fraud-Risiko)
Empfehlung: Welche Anomalieerkennung für Ihr KMU?

👉 Termin buchen

Veröffentlicht: 07. Februar 2026 Autor: SwissFinanceAI Team Kategorie: Fraud Prevention

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

Anomaly Detection in Bookkeeping: Automatische Fehler- und Betrugserkennung mit AI