Debitoor & SumUp 2026: Rechnungs-API & POS-Automatisierung

Für Hunderttausende Selbstständige war Debitoor das Standard-Rechnungsprogramm. Mit der vollständigen Integration in SumUp Rechnungen ist daraus eine vernetzte Plattform für E-Invoicing, Kartenzahlungen und Entwickler-APIs geworden.

Für Hunderttausende Selbstständige, Freelancer, Handwerker und Dienstleister im deutschsprachigen Raum war Debitoor über viele Jahre der Inbegriff unkomplizierter Rechnungsstellung: Wenige Klicks genügten, um professionelle Angebote und Rechnungen zu schreiben, Mahnungen zu versenden und die Einnahmen-Überschuss-Rechnung (EÜR) vorzubereiten. Mit der strategischen Übernahme und der vollständigen Verschmelzung in das globale Fintech-Ökosystem von SumUp hat sich die Plattform grundlegend gewandelt.

Im Jahr 2026 firmiert das System als SumUp Rechnungen (SumUp Invoices). Was auf den ersten Blick wie ein reines Rebranding erscheint, entpuppt sich bei näherer Betrachtung als mächtige Symbiose aus Point-of-Sale-Hardware (POS), Online-Zahlungsgateways, nativer E-Rechnungskonformität nach EN 16931 und modernen Entwickler-APIs. Wer heute Kartenzahlungen vor Ort im Ladengeschäft, digitale Rechnungen im Außendienst und automatisierte E-Commerce-Zahlungen verwalten muss, profitiert von einem integrierten Gesamtökosystem ohne Medienbrüche.

In diesem Leitfaden beleuchten wir die Transformation von Debitoor zu SumUp Rechnungen, analysieren die architektonischen Schnittstellen der SumUp REST-API, demonstrieren praxiserprobte n8n- und Python-Automatisierungen und zeigen, wie Sie Kartentransaktionen, Disagio-Gebühren und Finom-Geschäftskonten medienbruchfrei synchronisieren.

Die Evolution: Vom Standalone-Invoicing Debitoor zu SumUp Rechnungen

Ursprünglich 2012 in Kopenhagen gegründet, setzte sich Debitoor mit einer radikal einfachen Prämisse durch: Buchhaltungs- und Rechnungssoftware sollte für Nicht-Buchhalter verständlich sein. Während klassische ERP- und Desktop-Programme mit komplexen Buchungsmasken abschreckten, bot Debitoor ein aufgeräumtes Design und einfache Vorlagen.

Nach der Übernahme durch SumUp wurde Debitoor schrittweise mit der Zahlungsabwicklung verknüpft. Im Geschäftsjahr 2026 ist dieser Übergang vollständig abgeschlossen. Aus einem isolierten Rechnungsgenerator ist eine transaktionsgetriebene Commerce- und Buchhaltungs-Suite geworden, die drei wesentliche Säulen vereint:

Für bestehende Debitoor-Kunden bedeutet dies: Das vertraute Layout für Angebote und Rechnungen blieb erhalten, wurde aber um ein direktes Payment-Backend erweitert. Kunden können Rechnungen nicht mehr nur per Überweisung begleichen, sondern direkt im Webbrowser via Kreditkarte, Apple Pay, Google Pay oder Sofortüberweisung bezahlen — mit einer messbaren Verkürzung der durchschnittlichen Zahlungsdauer (DSO) von 14 auf unter 2 Tage.

Funktionsumfang 2026: GoBD, E-Rechnung ZUGFeRD & Mahnwesen

Die gesetzlichen Vorgaben für Rechnungsstellung und digitale Buchhaltung in Deutschland haben sich mit der Einführung der E-Rechnungspflicht massiv verschärft. SumUp Rechnungen adressiert diese Anforderungen mit standardisierten Workflows, die manuelle Fehler ausschließen:

1. E-Rechnungskonformität (ZUGFeRD 2.2 & EN 16931)

Jede in SumUp Rechnungen erstellte B2B-Rechnung kann im ZUGFeRD-Format generiert werden. Das bedeutet: Der Kunde erhält ein gewohntes, optisch ansprechendes PDF-Dokument, in das im Hintergrund ein standardisierter XML-Datensatz eingebettet ist. Dieser Datensatz enthält alle gesetzlich vorgeschriebenen Parameter wie Leitweg-ID, USt-Identifikationsnummern, Bankverbindungen und strukturierte Positionszeilen, sodass Empfänger die Rechnung ohne OCR-Lesefehler automatisiert in ihre ERP-Systeme einlesen können.

2. POS-Terminal-Synchronisation & Kartenzahlungen

Ein entscheidender Vorteil gegenüber reinen Online-Rechnungsprogrammen wie FastBill oder Billomat ist die physische Hardware. Ein Handwerker oder Dienstleister kann vor Ort beim Kunden die Reparatur durchführen, auf seinem SumUp Solo Terminal den Rechnungsbetrag per Girocard oder Kreditkarte kassieren und das System erzeugt simultan den GoBD-konformen Beleg samt Quittung. Die Transaktion wird in Echtzeit als bezahlt verbucht.

3. Automatisierte Zahlungserinnerungen & dynamische Zahlungslinks

Bleibt eine Rechnung unbezahlt, greift das mehrstufige Mahnwesen. Über SumUp Rechnungen lassen sich freundliche Zahlungserinnerungen sowie 1. und 2. Mahnungen konfigurieren. Jede versendete Mahnung enthält einen kryptografisch gesicherten SumUp-Zahlungslink. Klickt der Schuldner auf den Link, kann er die Forderung innerhalb von 30 Sekunden per Smartphone begleichen, wodurch zeitaufwendige Mahntelefonate entfallen.

Die SumUp REST-API: Endpunkte, Authentifizierung & Webhooks

Für Automatisierungs-Ingenieure und Softwareentwickler bietet SumUp eine offizielle REST-API. Die Schnittstelle basiert auf modernen Webstandards und ermöglicht die vollständige Fernsteuerung von Händlerkonten, Transaktionen und Rechnungen.

OAuth 2.0 Authentifizierung & Scopes

Der Zugriff auf die SumUp API erfordert ein Händlerkonto und die Registrierung einer OAuth 2.0 Client-Anwendung im SumUp Developer Portal. Authentifizierungs-Tokens werden über den Token-Endpunkt bezogen und im HTTP-Header als Bearer-Token übergeben:

# Token-Generierung via OAuth2 Client Credentials oder Authorization Code
POST https://api.sumup.com/token
Content-Type: application/x-www-form-urlencoded

client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&grant_type=client_credentials&scope=invoices,payments,transactions.history

Zentrale API-Endpunkte der SumUp Plattform

Echtzeit-Event-Steuerung via Webhooks

Um Polling-Schleifen zu vermeiden, unterstützt SumUp Webhooks. Ereignisse wie checkout.completed, payment.status_changed oder invoice.paid senden einen HTTPS-POST-Payload an Ihren Webhook-Empfänger (z. B. eine n8n-Instanz oder einen FastAPI-Microservice).

Ein typischer Webhook-Payload für eine erfolgreich abgeschlossene POS- oder Online-Kartenzahlung sieht folgendermaßen aus:

{
  "event_type": "checkout.completed",
  "id": "c7a8b9d0-1234-5678-90ab-cdef12345678",
  "event_time": "2026-03-31T10:14:22Z",
  "data": {
    "id": "chk_9876543210abcdef",
    "amount": 249.50,
    "currency": "EUR",
    "status": "PAID",
    "transaction_code": "TX-99887766",
    "payment_type": "CARD_READER",
    "merchant_code": "M-DE123456",
    "fee_amount": 2.25,
    "payout_plan": "DAILY",
    "customer": {
      "email": "kunde@beispiel-gmbh.de",
      "name": "Musterfirma GmbH"
    }
  }
}

Praxis-Automatisierungen mit n8n, Make & REST-APIs

Die Stärke von SumUp Rechnungen entfaltet sich vollständig, wenn die Plattform in unternehmensweite Integrations-Pipelines eingebunden wird. Betrachten wir drei erprobte Architektur-Blueprints, die wir bei Pragma Code regelmäßig für KMU und Dienstleister implementieren:

Systemarchitektur des automatisierten Invoicing- und Clearing-Workflows

Das folgende Ablaufdiagramm verdeutlicht den bidirektionalen Informationsfluss zwischen SumUp Hardware, API-Backend, Integrationsschicht und den Finanzsystemen:

┌─────────────────────────┐          ┌───────────────────────────┐
│  SumUp POS-Terminal /   │          │  CRM / E-Commerce Shop    │
│  Kartenzahlung vor Ort  │          │  (HubSpot / WooCommerce)  │
└────────────┬────────────┘          └─────────────┬─────────────┘
             │ Transaktions-                      │ Deal abgeschlossen /
             │ Webhook                            │ Bestellung erzeugt
             ▼                                    ▼
┌────────────────────────────────────────────────────────────────┐
│             n8n / Integration Layer (OAuth 2.0)                │
│                                                                │
│  1. Payload validieren & HMAC-Signatur prüfen                  │
│  2. SumUp Invoices API aufrufen (/v1/invoices)                 │
│  3. ZUGFeRD-XML einbetten & PDF generieren                     │
│  4. Split-Buchung: Brutto-Umsatz vs. Disagio-Gebühr            │
└────────────┬────────────────────────────────────┬──────────────┘
             │                                    │
             ▼                                    ▼
┌─────────────────────────┐          ┌───────────────────────────┐
│ Finom / Bankkonto       │          │ DATEV / Steuerberater     │
│ Automatisches Matching  │          │ GoBD-Belegarchiv & Export │
└─────────────────────────┘          └───────────────────────────┘

Code-Implementierung: Node.js / TypeScript & Python

Um die technische Integration greifbar zu machen, demonstrieren wir zwei Kernkomponenten: Eine typsichere Node.js/TypeScript-Funktion zur Rechnungsgenerierung und einen robusten Python/FastAPI-Webhook-Handler.

1. TypeScript: Rechnungsstellung via SumUp Invoices API

Dieses Skript authentifiziert sich per Bearer-Token, erstellt einen Kundenbeleg mit strukturierten Positionen, Steuersätzen und Zahlungsbedingungen und finalisiert das Dokument für den ZUGFeRD-Download:

import axios from 'axios';

interface InvoiceItem {
  name: string;
  quantity: number;
  unitPrice: number;
  taxRate: number; // z.B. 19 fuer 19 % USt
}

interface CreateInvoicePayload {
  merchantCode: string;
  customerName: string;
  customerEmail: string;
  invoiceNumber: string;
  dueDate: string;
  items: InvoiceItem[];
}

export async function createSumUpInvoice(
  apiToken: string,
  payload: CreateInvoicePayload
): Promise<{ invoiceId: string; pdfUrl: string }> {
  const sumUpClient = axios.create({
    baseURL: 'https://api.sumup.com/v1',
    headers: {
      Authorization: `Bearer ${apiToken}`,
      'Content-Type': 'application/json',
    },
  });

  const invoiceData = {
    number: payload.invoiceNumber,
    date: new Date().toISOString().split('T')[0],
    due_date: payload.dueDate,
    currency: 'EUR',
    customer: {
      name: payload.customerName,
      email: payload.customerEmail,
    },
    line_items: payload.items.map((item) => ({
      name: item.name,
      quantity: item.quantity,
      price: item.unitPrice,
      tax_rate: item.taxRate,
    })),
    payment_terms: {
      type: 'CUSTOM',
      days: 14,
    },
    options: {
      include_zugferd_xml: true,
      enable_online_payment_link: true,
    },
  };

  try {
    const response = await sumUpClient.post('/invoices', invoiceData);
    const invoiceId = response.data.id;

    // Rechnung finalisieren und Zahlungslink aktivieren
    await sumUpClient.post(`/invoices/${invoiceId}/finalize`);

    return {
      invoiceId,
      pdfUrl: `https://api.sumup.com/v1/invoices/${invoiceId}/pdf`,
    };
  } catch (error: any) {
    console.error('SumUp API Error:', error.response?.data || error.message);
    throw new Error(`Fehler bei SumUp Rechnungsstellung: ${error.message}`);
  }
}

2. Python / FastAPI: Transaktions-Webhook & Finom-Sync

Der folgende Webhook-Server empfängt checkout.completed-Events von SumUp, extrahiert die Gebührenkomponenten und bereitet die Buchungsdaten für den automatischen Abgleich vor:

import hmac
import hashlib
import os
from fastapi import FastAPI, Request, HTTPException, Header
from pydantic import BaseModel
from typing import Optional

app = FastAPI(title="SumUp Webhook & Financial Sync")

SUMUP_WEBHOOK_SECRET = os.getenv("SUMUP_WEBHOOK_SECRET", "super_secret_signing_key")

class CustomerInfo(BaseModel):
    email: Optional[str] = None
    name: Optional[str] = None

class CheckoutData(BaseModel):
    id: str
    amount: float
    currency: str
    status: str
    transaction_code: str
    fee_amount: float
    merchant_code: str
    customer: Optional[CustomerInfo] = None

class SumUpWebhookEvent(BaseModel):
    event_type: str
    id: str
    data: CheckoutData

@app.post("/api/v1/webhooks/sumup")
async def handle_sumup_webhook(
    request: Request,
    event: SumUpWebhookEvent,
    x_sumup_signature: Optional[str] = Header(None)
):
    # Optional: HMAC-Signaturpruefung fuer maximale Sicherheit
    raw_body = await request.body()
    if x_sumup_signature:
        expected_sig = hmac.new(
            SUMUP_WEBHOOK_SECRET.encode(),
            raw_body,
            hashlib.sha256
        ).hexdigest()
        if not hmac.compare_digest(expected_sig, x_sumup_signature):
            raise HTTPException(status_code=401, detail="Ungueltige Webhook-Signatur")

    if event.event_type == "checkout.completed" and event.data.status == "PAID":
        brutto_betrag = event.data.amount
        disagio_gebuehr = event.data.fee_amount
        netto_auszahlung = round(brutto_betrag - disagio_gebuehr, 2)

        # Logik fuer automatische Buchhaltung
        print(f"✅ Zahlung verbucht: Transaktion {event.data.transaction_code}")
        print(f"   Brutto-Umsatz: {brutto_betrag} {event.data.currency}")
        print(f"   SumUp-Gebuehr: {disagio_gebuehr} {event.data.currency}")
        print(f"   Netto-Auszahlung an Bank: {netto_auszahlung} {event.data.currency}")

        # Hier: Aufruf des Finom Banking-Sync oder DATEV Buchungssatz-Generators
        # execute_bank_reconciliation(transaction_code=event.data.transaction_code, amount=netto_auszahlung)

        return {"status": "success", "processed_tx": event.data.transaction_code}

    return {"status": "ignored", "reason": "Unbeachteter Event-Typ"}

Finom & SumUp / Debitoor: Reibungslose Bank- & Gebührensynchronisation

Eine der häufigsten Fehlerquellen bei Dienstleistern und Händlern ist die Diskrepanz zwischen SumUp-Auszahlungen und dem tatsächlichen Bankguthaben auf dem Geschäftskonto von Finom.

SumUp überweist Karteneinnahmen gesammelt (meist täglich oder wöchentlich) als Nettobetrag abzüglich der Gebühren auf das verknüpfte Finom-Konto. Wer versucht, diese Sammelüberweisung manuell einzelnen Ausgangsrechnungen zuzuordnen, verliert im Monatsabschluss Stunden.

Systemvergleich 2026: SumUp Rechnungen vs. Wettbewerber

Für welche Unternehmensgröße und welches Geschäftsmodell eignet sich SumUp Rechnungen am besten? Die folgende Vergleichsübersicht stellt SumUp Rechnungen den etablierten Systemen Lexware Office, sevDesk und Sorted gegenüber:

Fazit & Handlungsempfehlungen für moderne Unternehmen

Der Übergang von Debitoor zu SumUp Rechnungen markiert das Ende isolierter Rechnungsinseln. Moderne Unternehmen trennen den Belegfluss nicht mehr künstlich von der Zahlungsabwicklung. Ob im mobilen Serviceeinsatz, im stationären Laden oder beim digitalen B2B-Vertrieb: Die Kombination aus direkter Kartenzahlung, automatisiertem E-Invoicing und offener REST-API macht SumUp zu einer hocheffizienten Zentrale für Kleinunternehmen.

Durch die gezielte Anbindung an Automatisierungsplattformen wie n8n und die intelligente Verknüpfung mit Bankkonten wie Finom und Liquiditäts-Tools wie Commitly eliminieren Sie manuelle Buchungsschritte vollständig und senken Zahlungsverzüge drastisch.

Möchten Sie Ihre Rechnungsstellung und Kartenzahlungen nahtlos in Ihre IT- und ERP-Landschaft integrieren, Webhook-Pipelines für SumUp aufsetzen oder maßgeschneiderte Schnittstellen realisieren? Die Entwickler von Pragma Code unterstützen Sie von der Architektur bis zum produktiven Live-Betrieb.

Unsere Expertise vor Ort

Wir sind Ihr digitaler Partner – regional verankert und überregional erfolgreich.

Kontaktanfrage in Ihrer Region starten →

IT Lösungen Berlin IT Lösungen Hamburg IT Lösungen München IT Lösungen Köln IT Lösungen Frankfurt am Main IT Lösungen Stuttgart IT Lösungen Düsseldorf IT Lösungen Leipzig IT Lösungen Dortmund IT Lösungen Essen IT Lösungen Bremen IT Lösungen Hannover IT Lösungen Nürnberg IT Lösungen Wien IT Lösungen Graz IT Lösungen Linz IT Lösungen Salzburg IT Lösungen Zürich IT Lösungen Genf IT Lösungen Basel IT Lösungen Bern

Erweitertes Fachglossar