""" rechner.py – Vergleich: staatlich gefördertes Altersvorsorgedepot (AVD) vs. freies ETF-Depot. Diese Datei läuft auf der Webseite direkt im Browser. Möglich macht das "Pyodide": ein komplettes Python, das nach WebAssembly übersetzt wurde. Die Webseite (JavaScript) ruft nur die Funktion ``berechne_json`` auf und bekommt ein JSON-Ergebnis zurück. Man kann die Datei aber genauso normal mit ``python3`` benutzen und testen (siehe tests/test_rechner.py). Modell in Kürze --------------- Ansparphase (ab 2027 bis zum Auszahlungsbeginn), Monat für Monat: * Du zahlst jeden Monat denselben Eigenbeitrag in beide Depots. * AVD: Einmal pro Jahr kommen Grund- und Kinderzulage dazu. Keine Steuern während der Ansparphase. * Freies Depot: keine Zulagen. Jedes Jahr fällt auf ETFs die "Vorabpauschale" an (eine vorgezogene Mindestbesteuerung). Auszahlphase (Auszahlungsbeginn bis Alter X, Standard 85): * Beide Depots werden per Auszahlplan so entnommen, dass sie mit Alter X leer sind. * AVD: Jede Auszahlung wird KOMPLETT mit deinem persönlichen Steuersatz besteuert (nachgelagerte Besteuerung). * Freies Depot: Nur der GEWINNANTEIL jeder Entnahme wird versteuert (Abgeltungsteuer, 30 % Teilfreistellung bei Aktien-ETFs). Bewusste Vereinfachungen (stehen auch auf der Seite): * Zulagen werden am Jahresende gutgeschrieben (real zahlt die Zulagenstelle oft erst im Folgejahr aus -> unser Modell ist leicht optimistisch). * Freies Depot: Gewinnanteil nach Durchschnittskosten statt FIFO-Prinzip. * Konstante Rendite, keine Schwankungen. Echte Märkte schwanken stark! * Keine 30-%-Einmalauszahlung, kein Sonderausgabenabzug im Depotwert. """ from __future__ import annotations import json from dataclasses import dataclass, field, asdict # --------------------------------------------------------------------------- # Gesetzliche Werte (Stand Recherche November 2026 – auf der Seite belegt) # --------------------------------------------------------------------------- STARTJAHR = 2027 # Förderung gibt es ab dem 1.1.2027 MINDEST_EIGENBEITRAG = 120.0 # darunter: KEINE Zulage, auch nicht anteilig GRUNDZULAGE_STUFE1 = 360.0 # bis hier: 50 Cent je Euro GRUNDZULAGE_STUFE2 = 1800.0 # bis hier: 25 Cent je Euro (darüber: nichts) KINDERZULAGE_MAX = 300.0 # 1 € je Euro Eigenbeitrag, max. 300 € je Kind BERUFSEINSTEIGER_BONUS = 200.0 # einmalig, wenn jünger als 25 BERUFSEINSTEIGER_ALTER = 25 ABGELTUNGSTEUER = 0.25 SOLI = 0.055 MONATE = 12 # --------------------------------------------------------------------------- # Eingaben # --------------------------------------------------------------------------- @dataclass class Eingaben: """Alle Werte, die man auf der Webseite einstellen kann. Prozentwerte werden als Dezimalzahl übergeben: 6 % -> 0.06 """ alter: int = 35 # Alter im Startjahr 2027 auszahlungsbeginn: int = 67 # AVD: frühestens 65, spätestens 70 auszahlung_bis: int = 85 # Auszahlplan bis mindestens 85 eigenbeitrag_monat: float = 150.0 # gleicher Betrag in beide Depots # Für jedes Kind: wie viele Jahre (ab 2027) gibt es noch Kindergeld? # Beispiel [10, 14] = zwei Kinder, Kindergeld noch 10 bzw. 14 Jahre. kinder_jahre: list[int] = field(default_factory=list) rendite: float = 0.06 # erwartete Rendite p.a. (nach Fondskosten) rendite_auszahlphase: float = 0.04 # oft vorsichtiger angesetzt (mehr Anleihen) kosten_avd: float = 0.002 # Depot-/Vertragskosten AVD p.a. kosten_frei: float = 0.0 # Depotkosten freies Depot p.a. steuersatz_alter: float = 0.20 # Einkommensteuer auf AVD-Auszahlungen kirchensteuer: float = 0.0 # 0, 0.08 (BY, BW) oder 0.09 teilfreistellung: float = 0.30 # 30 % bei Aktien-ETFs, 15 % Misch-, 0 % Anleihe-ETFs basiszins: float = 0.032 # für Vorabpauschale (2026: 3,20 %) sparerpauschbetrag: float = 1000.0 # 0 eintragen, wenn schon anderweitig ausgeschöpft kv_satz_alter: float = 0.0 # KV/PV-Beitrag auf Auszahlungen (siehe FAQ) inflation: float = 0.02 # nur für die Umrechnung in "heutige Kaufkraft" # Günstigerprüfung (Sonderausgabenabzug): Angabe aus EINER Quelle, daher optional guenstigerpruefung: bool = False grenzsteuersatz_heute: float = 0.30 def pruefen(self) -> list[str]: """Gibt eine Liste mit Fehlermeldungen zurück (leer = alles in Ordnung).""" fehler = [] if not 16 <= self.alter <= 69: fehler.append("Das Alter muss zwischen 16 und 69 liegen.") if not 65 <= self.auszahlungsbeginn <= 70: fehler.append("Der Auszahlungsbeginn muss beim AVD zwischen 65 und 70 liegen.") if self.auszahlungsbeginn <= self.alter: fehler.append("Der Auszahlungsbeginn muss nach deinem heutigen Alter liegen.") if not 85 <= self.auszahlung_bis <= 100: fehler.append("Der Auszahlplan muss mindestens bis 85 laufen (höchstens 100).") if not 0 <= self.eigenbeitrag_monat <= GRUNDZULAGE_STUFE2 / MONATE: fehler.append("Der Eigenbeitrag muss zwischen 0 und 150 € im Monat liegen " "(mehr wird nicht gefördert, siehe FAQ).") if any(j < 0 or j > 25 for j in self.kinder_jahre): fehler.append("Kindergeld-Jahre pro Kind müssen zwischen 0 und 25 liegen.") if not -0.05 <= self.rendite <= 0.15 or not -0.05 <= self.rendite_auszahlphase <= 0.15: fehler.append("Renditen bitte zwischen -5 % und 15 % wählen.") return fehler # --------------------------------------------------------------------------- # Kleine Hilfsfunktionen – jede beantwortet genau eine Frage # --------------------------------------------------------------------------- def grundzulage(eigenbeitrag_jahr: float) -> float: """Grundzulage für einen Jahres-Eigenbeitrag. >>> grundzulage(100) # unter 120 € -> nichts 0.0 >>> grundzulage(360) # 50 % von 360 180.0 >>> grundzulage(1800) # 180 + 25 % von 1440 540.0 """ if eigenbeitrag_jahr < MINDEST_EIGENBEITRAG: return 0.0 stufe1 = min(eigenbeitrag_jahr, GRUNDZULAGE_STUFE1) * 0.50 stufe2 = max(0.0, min(eigenbeitrag_jahr, GRUNDZULAGE_STUFE2) - GRUNDZULAGE_STUFE1) * 0.25 return stufe1 + stufe2 def kinderzulage(eigenbeitrag_jahr: float, anzahl_kinder: int) -> float: """Kinderzulage: 100 % des Eigenbeitrags, höchstens 300 € je Kind. Nach Mehrheit der Quellen reicht EIN gemeinsamer Eigenbeitrag für alle Kinder (300 € Eigenbeitrag -> 2 Kinder bekommen je 300 €). Eine Quelle sieht das anders – das steht auch so auf der Seite. >>> kinderzulage(300, 2) 600.0 >>> kinderzulage(200, 1) 200.0 """ if eigenbeitrag_jahr < MINDEST_EIGENBEITRAG: return 0.0 return float(anzahl_kinder * min(eigenbeitrag_jahr, KINDERZULAGE_MAX)) def steuersatz_abgeltung(kirchensteuer: float) -> float: """Effektiver Abgeltungsteuersatz inkl. Soli und ggf. Kirchensteuer. Ohne Kirchensteuer: 25 % * 1,055 = 26,375 %. Mit Kirchensteuer wird die Abgeltungsteuer etwas gesenkt, weil die Kirchensteuer abzugsfähig ist (Formel aus § 32d EStG): AbgSt = 25 % / (1 + 25 % * KiSt-Satz) """ abgst = ABGELTUNGSTEUER / (1 + ABGELTUNGSTEUER * kirchensteuer) return abgst * (1 + SOLI + kirchensteuer) def monatsrate(kapital: float, zins_monat: float, restmonate: int) -> float: """Annuitätenformel: gleich hohe Monatsrate, die das Kapital in ``restmonate`` Monaten genau aufbraucht (bei konstantem Zins). Wir rufen sie JEDEN Monat neu auf. Dadurch korrigiert sich die Rate automatisch, wenn z. B. Steuern das Kapital verringert haben. """ if restmonate <= 0: return kapital if abs(zins_monat) < 1e-12: # Sonderfall 0 % Zins: einfach gleichmäßig teilen return kapital / restmonate return kapital * zins_monat / (1 - (1 + zins_monat) ** -restmonate) def monatszins(jahreszins: float) -> float: """Wandelt einen Jahreszins in den passenden Monatszins um. Nicht einfach /12 teilen! 6 % p.a. sind (1,06) ** (1/12) - 1 = 0,487 % pro Monat. Mit /12 (= 0,5 %) käme man durch den Zinseszins auf 6,17 % pro Jahr. """ return (1 + jahreszins) ** (1 / MONATE) - 1 # --------------------------------------------------------------------------- # Die Simulation # --------------------------------------------------------------------------- def berechne(e: Eingaben) -> dict: """Führt beide Simulationen durch und gibt ein Ergebnis-Dictionary zurück.""" fehler = e.pruefen() if fehler: return {"ok": False, "fehler": fehler} abgeltung = steuersatz_abgeltung(e.kirchensteuer) eigen_jahr = e.eigenbeitrag_monat * MONATE # Zinsen nach Kosten. Kosten werden vereinfacht von der Rendite abgezogen. z_avd = monatszins(e.rendite - e.kosten_avd) z_frei = monatszins(e.rendite - e.kosten_frei) z_avd_aus = monatszins(e.rendite_auszahlphase - e.kosten_avd) z_frei_aus = monatszins(e.rendite_auszahlphase - e.kosten_frei) # --- Zustände der beiden Depots --------------------------------------- avd = 0.0 # Depotwert AVD frei = 0.0 # Depotwert freies Depot frei_einstand = 0.0 # Anschaffungskosten freies Depot (für Gewinnberechnung) # Summen für die Auswertung s = { "eigenbeitraege": 0.0, "grundzulagen": 0.0, "kinderzulagen": 0.0, "bonus": 0.0, "steuer_vorab": 0.0, "steuer_avd_aus": 0.0, "steuer_frei_aus": 0.0, "kv_avd": 0.0, "kv_frei": 0.0, "netto_avd": 0.0, "netto_frei": 0.0, "steuererstattung": 0.0, } verlauf = [] # eine Zeile pro Jahr für Diagramm und Tabelle erste_rente = {} # Ø Monatswerte im ersten Auszahlungsjahr jahre_anspar = e.auszahlungsbeginn - e.alter jahre_aus = e.auszahlung_bis - e.auszahlungsbeginn gesamtmonate_aus = jahre_aus * MONATE for j in range(jahre_anspar + jahre_aus): jahr = STARTJAHR + j alter = e.alter + j anspar = j < jahre_anspar frei_jahresanfang = frei einzahlungen_jahr = 0.0 vorab_basis = frei_jahresanfang * e.basiszins * 0.7 # Basisertrag (Grundformel) sparer_rest = e.sparerpauschbetrag # Freibetrag gilt pro Jahr netto_avd_jahr = netto_frei_jahr = 0.0 brutto_frei_jahr = 0.0 # Summe der Entnahmen aus dem freien Depot im Jahr brutto_avd_jahr = 0.0 for m in range(MONATE): if anspar: # 1) Einzahlung zu Monatsbeginn, dann verzinsen avd += e.eigenbeitrag_monat frei += e.eigenbeitrag_monat frei_einstand += e.eigenbeitrag_monat einzahlungen_jahr += e.eigenbeitrag_monat s["eigenbeitraege"] += e.eigenbeitrag_monat # Vorabpauschale: Käufe im Jahr zählen nur anteilig – für jeden # vollen Monat VOR dem Kauf wird 1/12 abgezogen (§ 18 Abs. 2 InvStG). vorab_basis += e.eigenbeitrag_monat * e.basiszins * 0.7 * (MONATE - m) / MONATE avd *= 1 + z_avd frei *= 1 + z_frei else: # 2) Auszahlplan. Reihenfolge ist wichtig: Die Annuitätenformel # geht davon aus, dass die Rate EINE Periode nach dem # Kapitalstand fällig wird. Also: Rate aus dem Kapital VOR # der Verzinsung berechnen, dann verzinsen, dann abziehen. # (Erst verzinsen und dann rechnen ließ das Depot am Ende # leicht ins Minus laufen – das hat ein Test aufgedeckt.) restmonate = gesamtmonate_aus - ((j - jahre_anspar) * MONATE + m) # --- AVD: Auszahlung voll steuer- (und ggf. KV-)pflichtig --- brutto_avd = monatsrate(avd, z_avd_aus, restmonate) avd = avd * (1 + z_avd_aus) - brutto_avd brutto_avd_jahr += brutto_avd steuer = brutto_avd * e.steuersatz_alter kv = brutto_avd * e.kv_satz_alter s["steuer_avd_aus"] += steuer s["kv_avd"] += kv netto = brutto_avd - steuer - kv s["netto_avd"] += netto netto_avd_jahr += netto # --- Freies Depot: nur der Gewinnanteil wird versteuert --- brutto_frei = monatsrate(frei, z_frei_aus, restmonate) frei *= 1 + z_frei_aus if frei > 0: gewinnanteil = max(0.0, 1 - frei_einstand / frei) # Durchschnittskosten einstand_weg = brutto_frei * (1 - gewinnanteil) else: gewinnanteil, einstand_weg = 0.0, 0.0 frei -= brutto_frei brutto_frei_jahr += brutto_frei frei_einstand = max(0.0, frei_einstand - einstand_weg) gewinn = brutto_frei * gewinnanteil steuerpflichtig = gewinn * (1 - e.teilfreistellung) frei_nutzung = min(sparer_rest, steuerpflichtig) sparer_rest -= frei_nutzung steuer = (steuerpflichtig - frei_nutzung) * abgeltung # KV (nur freiwillig Versicherte): auf Kapitalerträge = Gewinn kv = gewinn * e.kv_satz_alter s["steuer_frei_aus"] += steuer s["kv_frei"] += kv netto = brutto_frei - steuer - kv s["netto_frei"] += netto netto_frei_jahr += netto # --- Jahresende: Zulagen & Vorabpauschale --------------------------- if anspar: gz = grundzulage(eigen_jahr) kinder = sum(1 for k in e.kinder_jahre if k > j) # Kinder mit Kindergeld in diesem Jahr kz = kinderzulage(eigen_jahr, kinder) bonus = BERUFSEINSTEIGER_BONUS if (j == 0 and e.alter < BERUFSEINSTEIGER_ALTER and eigen_jahr >= MINDEST_EIGENBEITRAG) else 0.0 avd += gz + kz + bonus s["grundzulagen"] += gz s["kinderzulagen"] += kz s["bonus"] += bonus # Günstigerprüfung: Sonderausgabenabzug (Eigenbeitrag + Zulage, max. 1.800 € + Zulage) # Erstattet wird nur, was über die Zulage hinausgeht. Geht NICHT ins Depot. if e.guenstigerpruefung: abzug = min(eigen_jahr, GRUNDZULAGE_STUFE2) + gz + kz s["steuererstattung"] += max(0.0, abzug * e.grenzsteuersatz_heute - (gz + kz)) # Vorabpauschale: gedeckelt auf den tatsächlichen Wertzuwachs des Jahres wertzuwachs = frei - frei_jahresanfang - einzahlungen_jahr if not anspar: wertzuwachs += brutto_frei_jahr # Entnahmen sind kein Wertverlust -> wieder addieren vorab = max(0.0, min(vorab_basis, wertzuwachs)) steuerpflichtig = vorab * (1 - e.teilfreistellung) frei_nutzung = min(sparer_rest, steuerpflichtig) steuer_vorab = (steuerpflichtig - frei_nutzung) * abgeltung # Im letzten Auszahlungsjahr ist das Depot leer: Für verkaufte Anteile # fällt keine Vorabpauschale mehr an -> nie mehr Steuer als Depotwert. steuer_vorab = min(steuer_vorab, max(frei, 0.0)) # Vereinfachung: Steuer wird aus dem Depot bezahlt (Broker belastet das Verrechnungskonto) frei -= steuer_vorab # Bereits versteuerte Vorabpauschale erhöht die Anschaffungskosten, # damit beim Verkauf nicht doppelt besteuert wird. frei_einstand += vorab s["steuer_vorab"] += steuer_vorab # Erstes Auszahlungsjahr: Monatsdurchschnitt merken. Durchschnitt statt # erster Monat, weil beim freien Depot der Sparerpauschbetrag die ersten # Monate steuerfrei stellt – das würde ein zu schönes Bild ergeben. if j == jahre_anspar: erste_rente = { "avd_brutto": brutto_avd_jahr / MONATE, "avd_netto": netto_avd_jahr / MONATE, "frei_brutto": brutto_frei_jahr / MONATE, "frei_netto": netto_frei_jahr / MONATE, } verlauf.append({ "jahr": jahr, "alter": alter + 1, "avd": round(avd, 2), "frei": round(max(frei, 0.0), 2), "eingezahlt": round(s["eigenbeitraege"], 2), "netto_avd_jahr": round(netto_avd_jahr, 2), "netto_frei_jahr": round(netto_frei_jahr, 2), }) # --- Ergebnis zusammenstellen ------------------------------------------- stand = verlauf[jahre_anspar - 1] kaufkraft = (1 + e.inflation) ** jahre_anspar # Faktor "Euro dann" -> "Euro heute" zulagen = s["grundzulagen"] + s["kinderzulagen"] + s["bonus"] return { "ok": True, "jahre_anspar": jahre_anspar, "jahre_aus": jahre_aus, "kapital_avd": round(stand["avd"], 2), "kapital_frei": round(stand["frei"], 2), "zulagen_gesamt": round(zulagen, 2), "zulage_pro_jahr_aktuell": round(grundzulage(eigen_jahr) + kinderzulage(eigen_jahr, sum(1 for k in e.kinder_jahre if k > 0)), 2), "foerderquote": round(zulagen / s["eigenbeitraege"], 4) if s["eigenbeitraege"] else 0.0, "summen": {k: round(v, 2) for k, v in s.items()}, "rente_monat": {k: round(v, 2) for k, v in erste_rente.items()}, "rente_monat_heute": {k: round(v / kaufkraft, 2) for k, v in erste_rente.items()}, "vorteil_avd_netto": round(s["netto_avd"] - s["netto_frei"], 2), "abgeltung_satz": round(abgeltung, 5), "verlauf": verlauf, } def berechne_json(eingaben_json: str) -> str: """Brücke für die Webseite: JSON rein, JSON raus. JavaScript kann Python-Objekte nicht direkt benutzen – Text (JSON) aber schon. """ roh = json.loads(eingaben_json) # Nur bekannte Felder übernehmen; Unbekanntes ignorieren (robust gegen Tippfehler) erlaubt = set(Eingaben.__dataclass_fields__) e = Eingaben(**{k: v for k, v in roh.items() if k in erlaubt}) e.kinder_jahre = [int(k) for k in e.kinder_jahre] return json.dumps(berechne(e)) if __name__ == "__main__": # Schnelltest auf der Kommandozeile: python3 site/rechner.py import doctest doctest.testmod(verbose=False) erg = berechne(Eingaben()) print(json.dumps({k: v for k, v in erg.items() if k != "verlauf"}, indent=2, ensure_ascii=False))