Stripe vs. Direkter Bankeinzug: Payment-Optionen für SaaS

Als europäisches SaaS-Unternehmen stellt sich früher oder später die Frage: Kann man Zahlungen auch ohne Payment-Provider wie Stripe direkt über die Hausbank abwickeln? Dieser Artikel analysiert die technischen Möglichkeiten, Kosten und Vor-/Nachteile.

Inhaltsverzeichnis

1. Ausgangssituation
2. Option 1: Stripe (Status Quo)
3. Option 2: Schweizer Bankeinzug (LSV+)
4. Option 3: Deutscher Bankeinzug (FinTS/HBCI)
5. Option 4: Stripe SEPA-Lastschrift (Kompromiss)
6. Vergleichsmatrix
7. Entscheidung & Empfehlung
8. Quellen

Ausgangssituation

ManaCore verwendet aktuell eine umfangreiche Stripe-Integration für Monetarisierung:

Aktuelles Zwei-Säulen-Modell

┌─────────────────────────────────────────────────────────────────┐
│                    ManaCore Monetarisierung                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Säule 1: Subscriptions              Säule 2: Credits           │
│  ┌─────────────────────────┐        ┌─────────────────────────┐ │
│  │ Free    €0/Monat        │        │ 100 Credits   €0.99     │ │
│  │ Plus    €4.99/Monat     │        │ 500 Credits   €4.99     │ │
│  │ Pro     €11.99/Monat    │        │ 1000 Credits  €8.99     │ │
│  │ Ultra   €24.99/Monat    │        │ 5000 Credits  €39.99    │ │
│  └─────────────────────────┘        └─────────────────────────┘ │
│                                                                  │
│  + Jahresabos mit ~17% Rabatt       + Gift Codes für Gutscheine │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Stripe-Gebühren (aktuell)

Frage: Können wir diese Gebühren eliminieren, indem wir direkt mit der Hausbank arbeiten?

Option 1: Stripe (Status Quo)

Vorteile

Nachteile

Aktuelle Implementation

// services/mana-core-auth/src/stripe/stripe.service.ts
@Injectable()
export class StripeService {
  private stripe: Stripe;

  constructor(private configService: ConfigService) {
    this.stripe = new Stripe(configService.get('STRIPE_SECRET_KEY'), {
      apiVersion: '2025-02-24.acacia',
    });
  }

  async createPaymentIntent(customerId: string, amountCents: number) {
    return this.stripe.paymentIntents.create({
      amount: amountCents,
      currency: 'eur',
      customer: customerId,
      automatic_payment_methods: { enabled: true },
    });
  }
}

Option 2: Schweizer Bankeinzug (LSV+)

Was ist LSV+?

LSV+ (Lastschriftverfahren) ist das Schweizer Pendant zur SEPA-Lastschrift. Es ermöglicht Unternehmen, Beträge direkt von Kundenkonten einzuziehen.

┌─────────────────────────────────────────────────────────────────┐
│                      LSV+ Ablauf                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. Kunde unterschreibt          2. Unternehmen erstellt        │
│     LSV-Mandat (Papier!)            XML-Datei (pain.008)        │
│                                                                  │
│  3. Upload via E-Banking         4. SIX Interbank Clearing      │
│     oder payCOMweb                  verarbeitet Lastschrift     │
│                                                                  │
│  5. Geld wird eingezogen         6. Kunde kann 30 Tage          │
│     (T+2 Werktage)                  widersprechen (LSV+)        │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Raiffeisen Schweiz: Technische Möglichkeiten

Kritische Einschränkung: Einstellung 2028

LSV+ und Business Direct Debit (BDD) werden am 30. September 2028 eingestellt. Ab 2026 werden keine neuen Biller mehr für LSV+/BDD aktiviert.

Die Schweizer Banken führen stattdessen eBill Debit Direct ein (Sommer 2025).

Technische Implementation (theoretisch)

// ISO-20022 pain.008 XML Generierung
function generateSepaDirectDebit(mandate: Mandate, amount: number): string {
  return `<?xml version="1.0" encoding="UTF-8"?>
<Document xmlns="urn:iso:std:iso:20022:tech:xsd:pain.008.001.02">
  <CstmrDrctDbtInitn>
    <GrpHdr>
      <MsgId>${generateMessageId()}</MsgId>
      <CreDtTm>${new Date().toISOString()}</CreDtTm>
      <NbOfTxs>1</NbOfTxs>
      <CtrlSum>${amount}</CtrlSum>
    </GrpHdr>
    <PmtInf>
      <PmtInfId>${mandate.id}</PmtInfId>
      <PmtMtd>DD</PmtMtd>
      <NbOfTxs>1</NbOfTxs>
      <CtrlSum>${amount}</CtrlSum>
      <!-- ... weitere 200+ Zeilen XML ... -->
    </PmtInf>
  </CstmrDrctDbtInitn>
</Document>`;
}

// Upload zu Bank (manuell oder via SFTP)
async function uploadToBank(xmlContent: string) {
  // Keine API - manueller Upload oder SFTP-Batch
  throw new Error('Keine automatisierte API verfügbar');
}

Fazit Schweiz

Option 3: Deutscher Bankeinzug (FinTS/HBCI)

Was ist FinTS/HBCI?

FinTS (Financial Transaction Services), früher HBCI, ist ein bankenübergreifendes Protokoll für Online-Banking in Deutschland. Es wurde von den deutschen Bankenverbänden entwickelt und wird von ~3000 Kreditinstituten unterstützt.

┌─────────────────────────────────────────────────────────────────┐
│                    FinTS/HBCI Architektur                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Deine App          FinTS-Library         Sparkasse/Bank        │
│  ┌─────────┐        ┌─────────────┐       ┌─────────────┐       │
│  │ NestJS  │───────>│ libfintx    │──────>│ FinTS 3.0   │       │
│  │ Backend │        │ python-fints │       │ Server      │       │
│  │         │<───────│ Subsembly   │<──────│             │       │
│  └─────────┘        └─────────────┘       └─────────────┘       │
│                                                                  │
│  Authentifizierung: PIN/TAN (chipTAN, smsTAN, pushTAN)          │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Sparkasse: Technische Möglichkeiten

Verfügbare Open-Source-Libraries

// Option 1: libfintx (.NET)
// https://github.com/libfintx/libfintx
const client = new FinTsClient({
  blz: '12345678',
  userId: 'username',
  pin: 'pin',
  url: 'https://banking.sparkasse.de/fints'
});

await client.sepaDirectDebit({
  iban: 'DE89370400440532013000',
  bic: 'COBADEFFXXX',
  amount: 9.99,
  mandate: mandateReference,
});

// Option 2: python-fints
// https://github.com/raphaelm/python-fints

SEPA-Firmenlastschrift vs. Basislastschrift

Herausforderungen

1. TAN-Pflicht: Jede Transaktion erfordert TAN-Bestätigung
2. Keine Webhooks: Polling für Statusupdates erforderlich
3. Komplexes Protokoll: FinTS ist deutlich komplexer als REST
4. Mandate-Management: Selbst zu implementieren
5. PSD2-Einschränkungen: Zugang über Drittanbieter reguliert

Drittanbieter: finAPI

Für eine modernere API gibt es Anbieter wie finAPI, die als Middleware zwischen App und Bank fungieren:

// finAPI Direct Debit API
const response = await fetch('https://api.finapi.io/v1/payments/directDebit', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    accountId: customerAccountId,
    amount: 9.99,
    currency: 'EUR',
    mandateId: mandateReference,
    executionDate: '2026-02-20',
  }),
});

Aber: finAPI hat eigene Gebühren und ist selbst ein Payment-Provider.

Fazit Deutschland

Option 4: Stripe SEPA-Lastschrift (Kompromiss)

Der beste beider Welten

Stripe bietet SEPA Direct Debit als Zahlungsmethode an - mit den Vorteilen beider Ansätze:

// Minimale Code-Änderung in bestehender Integration
const paymentIntent = await stripe.paymentIntents.create({
  amount: 1199, // €11.99
  currency: 'eur',
  payment_method_types: ['sepa_debit'], // Statt 'card'
  customer: stripeCustomerId,
  mandate_data: {
    customer_acceptance: {
      type: 'online',
      online: {
        ip_address: req.ip,
        user_agent: req.headers['user-agent'],
      },
    },
  },
});

Gebührenvergleich

Bei 1000 Transaktionen/Monat: €320 Ersparnis

Vorteile gegenüber direktem Bankeinzug

Implementation

// Frontend: SEPA-Mandat einholen
const { error } = await stripe.confirmSepaDebitPayment(clientSecret, {
  payment_method: {
    sepa_debit: {
      iban: 'DE89370400440532013000',
    },
    billing_details: {
      name: 'Max Mustermann',
      email: '[email protected]',
    },
  },
});

// Backend: Webhook wie gehabt
@Post('webhook')
async handleWebhook(@Req() req: Request) {
  const event = this.stripe.webhooks.constructEvent(/*...*/);

  switch (event.type) {
    case 'payment_intent.succeeded':
      // Funktioniert identisch wie bei Kreditkarten
      await this.handlePaymentSuccess(event.data.object);
      break;
    case 'payment_intent.payment_failed':
      // SEPA kann auch fehlschlagen (Kontodeckung, etc.)
      await this.handlePaymentFailure(event.data.object);
      break;
  }
}

Vergleichsmatrix

Entscheidung & Empfehlung

Entscheidung: Stripe SEPA-Lastschrift aktivieren

Nach Analyse aller Optionen ist die Empfehlung:

1. Stripe SEPA-Lastschrift als primäre Zahlungsmethode für DACH-Kunden
2. Kreditkarte als Fallback für internationale Kunden
3. Kein direkter Bankeinzug - Aufwand/Nutzen-Verhältnis nicht gegeben

Begründung

┌─────────────────────────────────────────────────────────────────┐
│                    Kosten-Nutzen-Analyse                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Direkter Bankeinzug:                                           │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ Entwicklungsaufwand:     ~80-160 Stunden                │    │
│  │ Wartungsaufwand:         ~10 Stunden/Monat              │    │
│  │ Ersparnis pro Transaktion: €0.05-0.10                   │    │
│  │ Break-Even bei:          >10.000 Transaktionen/Monat   │    │
│  │ Risiko:                  Hoch (Compliance, Edge Cases)  │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
│  Stripe SEPA-Lastschrift:                                       │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ Entwicklungsaufwand:     ~2-4 Stunden                   │    │
│  │ Wartungsaufwand:         ~0 Stunden/Monat               │    │
│  │ Ersparnis pro Transaktion: €0.32 vs. Kreditkarte        │    │
│  │ Break-Even bei:          Sofort                         │    │
│  │ Risiko:                  Niedrig (Stripe übernimmt)     │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Nächste Schritte

Bereits erledigt (Code)

• stripe.service.ts - SEPA zu Checkout Sessions hinzugefügt
• subscriptions.service.ts - SEPA für Subscriptions aktiviert
• stripe-webhook.controller.ts - SEPA-Dokumentation und processing Event

Manuell im Stripe Dashboard

1. SEPA-Lastschrift aktivieren:

   • Öffne: https://dashboard.stripe.com/settings/payment_methods
   • Finde “SEPA Direct Debit” → Klicke “Turn on”
   • Akzeptiere die SEPA-Bedingungen

2. Webhook-Event hinzufügen:

   • Öffne: https://dashboard.stripe.com/webhooks
   • Klicke auf deinen Webhook (Endpoint: /webhooks/stripe)
   • Klicke “Update details” → Events
   • Füge hinzu: payment_intent.processing
   • Speichern

3. Deployment:

   # Auf dem Server
   ssh mana-server
   cd ~/projects/manacore-monorepo
   git pull
   ./scripts/mac-mini/deploy.sh

Langfristige Option

Falls das Transaktionsvolumen >10.000/Monat erreicht, kann eine direkte Bank-Integration erneut evaluiert werden - dann aber mit eBill Debit Direct (Schweiz, ab 2025) oder einem PSD2-konformen Aggregator (EU).

Quellen

Schweiz

• Raiffeisen LSV+
• SIX Direct Debits
• Moneyland Direct Debit FAQ
• Guide to Swiss Payments (Atlar)

Deutschland

• Sparkasse SEPA-Lastschrift
• FinTS Wikipedia
• libfintx GitHub
• python-fints GitHub
• Subsembly FinTS API
• finAPI

Stripe

• Stripe SEPA Direct Debit
• Stripe Pricing

Changelog