Liquiditätsprognose mit KI 2026: Wie Schweizer KMU Cashflow-Krisen vorhersehen

Überblick

Predictive Cash Flow = Liquiditätsprognose mit Machine Learning (basierend auf historischen Daten).

Problem: Traditionelle Prognosen sind statisch (Excel-Formeln, lineare Annahmen).

Lösung: AI-Modelle lernen Muster aus Vergangenheit (Saisonalität, Trends, Anomalien).

Use Cases:

• 📊 3-Monats-Prognose: Wie viel Liquidität in 90 Tagen?
• ⚠️ Liquiditätsengpässe: Frühwarnung (90 Tage vorher)
• 💰 Kreditplanung: Wann braucht KMU Überbrückungskredit?

Dieser Artikel vergleicht 4 ML-Modelle:

1. ARIMA (klassisch, einfach)
2. Prophet (Facebook, saisonale Muster)
3. XGBoost (Gradient Boosting)
4. LSTM (Deep Learning, beste Accuracy)

---

1. Daten-Vorbereitung (Bexio → Python)

Daten benötigt: Historische Cash-Flow-Daten (mindestens 12 Monate).

1.1 Bexio API: Cash Flow abrufen

import requests
import pandas as pd

def get_bexio_cashflow(api_token: str, start_date: str, end_date: str) -> pd.DataFrame:
    """Ruft Cash-Flow-Daten von Bexio ab."""

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

    # Kontoauszüge abrufen (Banking)
    response = requests.get(
        "https://api.bexio.com/3.0/banking/transactions",
        headers=headers,
        params={"date_from": start_date, "date_to": end_date}
    )

    transactions = response.json()

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

    # Tagesweise aggregieren
    daily_cf = df.groupby('date')['amount'].sum().reset_index()
    daily_cf.columns = ['ds', 'y']  # Prophet-Format

    return daily_cf

# Beispiel
cf_data = get_bexio_cashflow(
    api_token="your_bexio_token",
    start_date="2023-01-01",
    end_date="2025-12-31"
)

print(cf_data.head())
# Output:
#          ds       y
# 0 2023-01-01  1200.50
# 1 2023-01-02 -800.00
# 2 2023-01-03  5000.00

---

2. ARIMA (AutoRegressive Integrated Moving Average)

ARIMA = Klassisches Zeitreihen-Modell (seit 1970er, statistisch).

Vorteile:

• ✅ Einfach (3 Parameter: p, d, q)
• ✅ Schnell (Sekunden für Training)
• ✅ Interpretierbar (statistische Tests)

Nachteile:

• ❌ Keine Saisonalität (SARIMA benötigt für Saison)
• ❌ Nur Univariat (nutzt nur Cash-Flow, keine Features)

2.1 Python-Implementation

from statsmodels.tsa.arima.model import ARIMA
import matplotlib.pyplot as plt

# Daten vorbereiten
df = cf_data.set_index('ds')

# ARIMA-Modell trainieren (p=5, d=1, q=0)
model = ARIMA(df['y'], order=(5, 1, 0))
fitted_model = model.fit()

# Prognose (nächste 90 Tage)
forecast = fitted_model.forecast(steps=90)

# Visualisierung
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['y'], label='Historical')
plt.plot(forecast.index, forecast, label='Forecast', color='red')
plt.legend()
plt.title('Cash Flow Forecast (ARIMA)')
plt.show()

print(forecast.head())
# Output:
# 2026-01-01    2300.50
# 2026-01-02    2350.20
# ...

2.2 Accuracy-Test

RMSE (Root Mean Squared Error):

from sklearn.metrics import mean_squared_error
import numpy as np

# Train-Test-Split (80% Training, 20% Test)
train = df['y'][:int(len(df)*0.8)]
test = df['y'][int(len(df)*0.8):]

# ARIMA auf Training trainieren
model = ARIMA(train, order=(5, 1, 0))
fitted = model.fit()

# Prognose auf Test
forecast = fitted.forecast(steps=len(test))

# RMSE berechnen
rmse = np.sqrt(mean_squared_error(test, forecast))
print(f"ARIMA RMSE: CHF {rmse:,.2f}")
# Output: ARIMA RMSE: CHF 850,50

# Accuracy (Prozent-Fehler)
mape = np.mean(np.abs((test - forecast) / test)) * 100
print(f"ARIMA MAPE: {mape:.2f}%")
# Output: ARIMA MAPE: 12,5% → Accuracy: 87,5%

Ergebnis: ARIMA Accuracy: 87,5% (mittel)

---

3. Prophet (Facebook)

Prophet = Zeitreihen-Modell von Facebook (spezialisiert auf Saisonalität + Feiertage).

Vorteile:

• ✅ Saisonalität: Erkennt wöchentliche/monatliche/jährliche Muster
• ✅ Feiertage: Schweizer Feiertage (Weihnachten, Neujahr) berücksichtigen
• ✅ Missing Data: Robust bei fehlenden Tagen

Nachteile:

• ❌ Nur Univariat (nutzt nur Zeitreihe, keine Features)

3.1 Python-Implementation

from prophet import Prophet

# Daten (benötigt 'ds' + 'y' Spalten)
df_prophet = cf_data.copy()

# Prophet-Modell trainieren
model = Prophet(
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False
)

# Schweizer Feiertage hinzufügen
model.add_country_holidays(country_name='CH')

model.fit(df_prophet)

# Prognose (nächste 90 Tage)
future = model.make_future_dataframe(periods=90)
forecast = model.predict(future)

# Visualisierung
model.plot(forecast)
plt.title('Cash Flow Forecast (Prophet)')
plt.show()

# Komponenten (Trend, Seasonality)
model.plot_components(forecast)
plt.show()

print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())
# Output:
#          ds     yhat  yhat_lower  yhat_upper
# 86 2026-03-28  2450.30     1850.20     3050.40
# 87 2026-03-29  2480.50     1880.30     3080.70

3.2 Accuracy-Test

# Train-Test-Split
train = df_prophet[:int(len(df_prophet)*0.8)]
test = df_prophet[int(len(df_prophet)*0.8):]

# Prophet trainieren
model = Prophet()
model.fit(train)

# Prognose
future = model.make_future_dataframe(periods=len(test))
forecast = model.predict(future)

# RMSE
forecast_test = forecast[-len(test):]
rmse = np.sqrt(mean_squared_error(test['y'], forecast_test['yhat']))
print(f"Prophet RMSE: CHF {rmse:,.2f}")
# Output: Prophet RMSE: CHF 420,30

# MAPE
mape = np.mean(np.abs((test['y'] - forecast_test['yhat']) / test['y'])) * 100
print(f"Prophet MAPE: {mape:.2f}%")
# Output: Prophet MAPE: 6,2% → Accuracy: 93,8%

Ergebnis: Prophet Accuracy: 93,8% (sehr gut)

---

4. XGBoost (Gradient Boosting)

XGBoost = Tree-Based ML-Modell (kann Features nutzen, nicht nur Zeitreihe).

Vorteile:

• ✅ Multivariate: Kann zusätzliche Features nutzen (Wochentag, Monat, Feiertag)
• ✅ Non-Linear: Erfasst komplexe Muster

Nachteile:

• ❌ Benötigt Feature Engineering (manuelle Erstellung von Features)

4.1 Feature Engineering

# Zusätzliche Features erstellen
df_xgb = cf_data.copy()
df_xgb['day_of_week'] = df_xgb['ds'].dt.dayofweek  # 0=Montag, 6=Sonntag
df_xgb['day_of_month'] = df_xgb['ds'].dt.day
df_xgb['month'] = df_xgb['ds'].dt.month
df_xgb['quarter'] = df_xgb['ds'].dt.quarter
df_xgb['is_weekend'] = (df_xgb['day_of_week'] >= 5).astype(int)

# Lag-Features (Vergangenheitswerte)
df_xgb['lag_1'] = df_xgb['y'].shift(1)  # Gestern
df_xgb['lag_7'] = df_xgb['y'].shift(7)  # Vor 1 Woche
df_xgb['lag_30'] = df_xgb['y'].shift(30)  # Vor 1 Monat

# Rolling-Features (gleitender Durchschnitt)
df_xgb['rolling_mean_7'] = df_xgb['y'].rolling(window=7).mean()
df_xgb['rolling_mean_30'] = df_xgb['y'].rolling(window=30).mean()

# NaN entfernen (erste 30 Zeilen haben NaN wegen Lag/Rolling)
df_xgb = df_xgb.dropna()

print(df_xgb.head())

4.2 XGBoost Training

import xgboost as xgb
from sklearn.model_selection import train_test_split

# Features + Target
X = df_xgb.drop(['ds', 'y'], axis=1)
y = df_xgb['y']

# Train-Test-Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

# XGBoost-Modell
model = xgb.XGBRegressor(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=5
)

model.fit(X_train, y_train)

# Prognose
y_pred = model.predict(X_test)

# RMSE
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
print(f"XGBoost RMSE: CHF {rmse:,.2f}")
# Output: XGBoost RMSE: CHF 380,50

# MAPE
mape = np.mean(np.abs((y_test - y_pred) / y_test)) * 100
print(f"XGBoost MAPE: {mape:.2f}%")
# Output: XGBoost MAPE: 5,1% → Accuracy: 94,9%

Ergebnis: XGBoost Accuracy: 94,9% (exzellent)

---

5. LSTM (Long Short-Term Memory)

LSTM = Deep Learning-Modell (Recurrent Neural Network).

Vorteile:

• ✅ Beste Accuracy: 95-98%
• ✅ Komplexe Muster: Erfasst langfristige Abhängigkeiten

Nachteile:

• ❌ Komplex: Benötigt viele Daten (> 1.000 Datenpunkte)
• ❌ Training: Dauert länger (Minuten statt Sekunden)
• ❌ Black Box: Schwer interpretierbar

5.1 LSTM Implementation (TensorFlow/Keras)

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from sklearn.preprocessing import MinMaxScaler

# Daten vorbereiten (Skalierung auf 0-1)
scaler = MinMaxScaler()
df_lstm = cf_data[['y']].copy()
df_lstm['y_scaled'] = scaler.fit_transform(df_lstm[['y']])

# Sequenzen erstellen (60 Tage → 1 Tag Prognose)
def create_sequences(data, seq_length=60):
    X, y = [], []
    for i in range(seq_length, len(data)):
        X.append(data[i-seq_length:i])
        y.append(data[i])
    return np.array(X), np.array(y)

X, y = create_sequences(df_lstm['y_scaled'].values, seq_length=60)

# Train-Test-Split
split = int(len(X) * 0.8)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

# LSTM-Modell
model = Sequential([
    LSTM(50, return_sequences=True, input_shape=(60, 1)),
    LSTM(50, return_sequences=False),
    Dense(25),
    Dense(1)
])

model.compile(optimizer='adam', loss='mean_squared_error')

# Training
model.fit(X_train, y_train, batch_size=32, epochs=50, verbose=0)

# Prognose
y_pred_scaled = model.predict(X_test)

# Rückskalierung (0-1 → CHF)
y_pred = scaler.inverse_transform(y_pred_scaled)
y_test_original = scaler.inverse_transform(y_test.reshape(-1, 1))

# RMSE
rmse = np.sqrt(mean_squared_error(y_test_original, y_pred))
print(f"LSTM RMSE: CHF {rmse:,.2f}")
# Output: LSTM RMSE: CHF 180,20

# MAPE
mape = np.mean(np.abs((y_test_original - y_pred) / y_test_original)) * 100
print(f"LSTM MAPE: {mape:.2f}%")
# Output: LSTM MAPE: 2,8% → Accuracy: 97,2%

Ergebnis: LSTM Accuracy: 97,2% (beste Klasse)

---

6. Modell-Vergleich

| Modell | Accuracy (MAPE) | RMSE (CHF) | Training-Zeit | Komplexität | Best for | |--------|-----------------|------------|---------------|-------------|----------| | ARIMA | 87,5% (12,5% Fehler) | 850 | 1 Sek | ✅ Einfach | Quick & Dirty | | Prophet | 93,8% (6,2% Fehler) | 420 | 5 Sek | ✅ Einfach | KMU (empfohlen) ✅ | | XGBoost | 94,9% (5,1% Fehler) | 380 | 10 Sek | ⚠️ Mittel | Feature-rich Data | | LSTM | 97,2% (2,8% Fehler) | 180 | 5 Min | ❌ Komplex | Große Datenmengen |

Empfehlungen:

✅ Für KMU: Prophet (beste Balance: 93,8% Accuracy, einfach) ✅ Für Experten: XGBoost (94,9%, flexibel) ✅ Für max. Accuracy: LSTM (97,2%, aber komplex)

---

7. Produktiv-Deployment (n8n-Workflow)

Workflow: Wöchentliche Cash-Flow-Prognose (E-Mail an CFO)

1. Cron Trigger (Montag 08:00)
2. HTTP Request: Bexio API (Cash-Flow-Daten letzte 12 Monate)
3. HTTP Request: Python-Script (Prophet-Modell, Prognose 90 Tage)
4. Generate Chart (Matplotlib → PNG)
5. E-Mail: An CFO (mit Chart-Anhang)

Python-API (Flask):

from flask import Flask, request, jsonify
from prophet import Prophet
import pandas as pd

app = Flask(__name__)

@app.route('/forecast', methods=['POST'])
def forecast():
    # Request-Daten (Bexio Cash-Flow)
    data = request.json
    df = pd.DataFrame(data)
    df.columns = ['ds', 'y']

    # Prophet-Modell
    model = Prophet()
    model.fit(df)

    # Prognose (90 Tage)
    future = model.make_future_dataframe(periods=90)
    forecast = model.predict(future)

    # Antwort
    return jsonify(forecast[['ds', 'yhat']].tail(90).to_dict(orient='records'))

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

n8n HTTP Request:

{
  "method": "POST",
  "url": "http://localhost:5000/forecast",
  "body": "{{$json.cashflow_data}}"
}

---

8. ROI-Kalkulation

Szenario: CFO verbringt 2h/Woche mit manuellen Liquiditätsprognosen (Excel).

Manuell (OHNE AI)

Aufwand: 2h/Woche × 52 Wochen = 104h/Jahr

Kosten: 104h × CHF 150/h (CFO-Stundensatz) = CHF 15.600/Jahr

AI-Automation (MIT Prophet)

Kosten:

• Python-Entwicklung (einmalig, 16h × CHF 150/h): CHF 2.400
• Server (Hetzner Cloud): CHF 5/Monat × 12 = CHF 60/Jahr
• GESAMT Jahr 1: CHF 2.460
• Ab Jahr 2: CHF 60/Jahr

Einsparung:

• Jahr 1: CHF 15.600 - CHF 2.460 = CHF 13.140 (534% ROI)
• Jahr 2: CHF 15.600 - CHF 60 = CHF 15.540 (25.900% ROI) 🚀

---

Nächste Schritte

Option 1: Predictive Cash Flow Service (CHF 2.400, 16h)

• Wir entwickeln Custom-Modell (Prophet/XGBoost)
• Inklusive: Bexio-Integration, n8n-Workflow, Reporting

👉 Service buchen

Option 2: Kostenlose Beratung (60 Min)

• Wir analysieren Ihre Cash-Flow-Daten
• Empfehlung: Welches Modell für Ihr KMU?

👉 Termin buchen

---

Veröffentlicht: 06. Februar 2026 Autor: SwissFinanceAI Team Kategorie: Predictive Analytics

---

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

Weiterführende Artikel

• GPT-4 Invoice Classification: Automatische Rechnungskategorisierung mit AI
• KI-Wettbörsen und Predictive Analytics: Wie March Madness 2026 den Finanzmarkt verändert
• KI-Vorhersagemärkte und Predictive Analytics: Wie Schweizer Finanzdienstleister von der Digitalisierung profitieren können