Home / Blog / Article

Debitoor & SumUp 2026: Payment API, POS Payments & Workflow Automation Guide

Comprehensive 2026 developer and business guide to Debitoor & SumUp: Payment API, POS card readers, ZUGFeRD e-invoicing, webhooks, and n8n.

🤖 AI & Automation Published on October 13, 2026 | Read time: approx. 14 minutes | Author: Pragma-Code Editorial
Debitoor and SumUp Invoices 3D Header with card reader terminal, ZUGFeRD e-invoices, and REST API pipelines

For many European freelancers, Debitoor was the gold standard for simple billing. Fully transitioned into SumUp Invoices, it now forms an integrated suite connecting card terminals, e-invoicing, and developer APIs.

Part of our Themen-Hub series:

This article is an in-depth expert contribution from our content cluster. Discover the complete overview on our main page: AI & Workflow Automation →

For many independent contractors, freelancers, tradespeople, and small business owners across Europe, Debitoor stood for effortless, intuitive invoicing: creating polished quotes and customer bills required just a few clicks, overdue reminders were sent effortlessly, and basic revenue-surplus accounting (EÜR) was simplified. With its acquisition and complete absorption into SumUp's international fintech ecosystem, the product landscape has evolved dramatically.

In 2026, the software operates under the banner of SumUp Invoices (SumUp Rechnungen). What might appear as a conventional rebranding is, in reality, a unified commerce platform connecting physical point-of-sale (POS) hardware, online payment gateways, strict compliance with EN 16931 e-invoicing standards, and modern developer APIs. Today, businesses accepting in-person card payments, issuing field-service invoices, and running automated e-commerce checkouts can orchestrate their entire billing lifecycle without manual data transfers.

In this comprehensive guide, we examine the evolution from standalone Debitoor to SumUp Invoices, evaluate the technical capabilities of the SumUp REST API, showcase production-ready n8n and Python automation pipelines, and explain how to synchronize card payouts, merchant processing fees, and modern business accounts like Finom seamlessly.

The Evolution: From Standalone Debitoor to SumUp Invoices

Founded in Copenhagen in 2012, Debitoor solved a clear market problem: accounting software was notoriously complex, designed by accountants for accountants, leaving non-financial entrepreneurs intimidated. Debitoor countered with radical simplicity, elegant templates, and zero bookkeeping jargon.

Following its acquisition by SumUp, the platform systematically merged invoicing with payment processing. The standalone Debitoor application has since been discontinued. The system has transformed from an isolated billing generator into an omnichannel transactional suite anchored by three pillars:

Compliant E-Invoicing 2026

Creation of quotes, delivery notes, credit notes, and legally compliant e-invoices (ZUGFeRD 2.2 / XRechnung 3.0) with automated numbering series and PDF downloads.

Omnichannel Payment Processing

Direct pairing with physical card readers (SumUp Solo, Air), instant WhatsApp/email payment links, and dynamic QR code billing with real-time settlement tracking.

Financial Data & Banking Sync

Automated payment matching, merchant processing fee separation (gross revenue vs. interchange deductions), and native data exports to DATEV and Finom.

For existing Debitoor users, the familiar user interface was preserved while gaining immediate access to modern payment rails. Customers receiving invoices no longer have to enter IBANs manually in their online banking portal; instead, they click a hosted payment link to settle invoices instantly via credit card, Apple Pay, Google Pay, or instant SEPA transfer—slashing Days Sales Outstanding (DSO) from 14 days to under 48 hours.

Feature Breakdown 2026: E-Invoicing, Hardware & Automated Dunning

Legal mandates across the European Union have raised the compliance bar for commercial billing. SumUp Invoices addresses these requirements with standardized, automated workflows designed to eliminate manual audit risks:

1. European E-Invoicing Compliance (EN 16931 & ZUGFeRD 2.2)

Every commercial B2B invoice generated inside SumUp Invoices can be formatted as a hybrid ZUGFeRD document. The recipient receives a visually rendered PDF document with an embedded, standardized XML payload containing all required electronic fields (buyer reference, VAT registration numbers, line item tax codes, and structured payment terms). Receiving enterprise accounting systems and tax portals parse these files instantaneously without OCR errors.

2. POS Hardware Synchronization & On-Site Card Payments

A defining advantage over pure-play online software like FastBill or Billomat is native hardware integration. Mobile service technicians, craftspeople, and boutique retailers can finalize a job on-site, accept a card or contactless phone payment via a handheld SumUp Solo terminal, and immediately generate a compliant invoice receipt. The invoice is instantly tagged as paid within the cloud backend.

When an invoice crosses its due date, configurable dunning schedules take over. SumUp Invoices triggers staged friendly payment reminders and formal escalation notices. Crucially, each notification includes a cryptographic payment URL, allowing the client to resolve the open liability in seconds from their smartphone, virtually eliminating prolonged debt-collection friction.

Pro-Tip: Automate Merchant Processing Fee Booking

When processing card payments, SumUp retains an interchange transaction fee (interchange fee depending on plan). From an accounting standpoint, recording only the net bank deposit as revenue is a serious compliance error! By deploying automated API sync scripts, we split the gross invoice revenue and merchant fee expenses into discrete ledger accounts, ensuring your tax advisor receives audit-ready bookkeeping records at month-end.

SumUp REST API Architecture: Endpoints, OAuth 2.0 & Webhooks

For automation engineers and software developers, SumUp provides a robust REST API. Built on modern web protocols, the API allows programmatic control over merchant accounts, customer directories, payment checkouts, and transaction data.

OAuth 2.0 Authentication & Access Scopes

Interacting with the SumUp API requires a registered Merchant Account and an active OAuth 2.0 Application configured in the SumUp Developer Portal (for single-merchant integrations, an API key (sup_sk_…) is sufficient). Access tokens are obtained via standard client credentials or authorization code grants and passed as Bearer tokens in HTTP request headers:

# Requesting access token via OAuth 2.0 client credentials
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=transactions.history user.profile_readonly

Core API Endpoints of the SumUp Platform

Endpoint HTTP Method Purpose & Integration Role
/v0.1/me GET Retrieves merchant profile metadata, default currency settings, and active merchant codes.
/v0.1/checkouts POST / GET Creates online hosted payment sessions, card authorizations, and payment links.
/v0.1/checkouts/{checkout_id} GET / PATCH / PUT Retrieves, processes, or updates checkout sessions.
Transactions (see API reference) GET Queries complete transaction logs across POS terminals and online checkouts with fee breakdowns.

Real-Time Webhook Architecture

Rather than utilizing inefficient polling mechanisms, SumUp delivers webhook notifications via a return_url specified when creating a checkout. SumUp currently reports checkout status transitions via the CHECKOUT_STATUS_CHANGED event (for Solo card readers via the Cloud API, the event is solo.transaction.updated). Upon receiving the webhook, the middleware queries the checkout via API to verify the current status. SumUp retries delivery after 1 min, 5 min, 20 min, and 2 hours if unreachable.

A typical webhook payload appears as follows:

{
  "event_type": "CHECKOUT_STATUS_CHANGED",
  "id": "chk_9876543210abcdef"
}

Production Automation Workflows with n8n & Make

SumUp Invoices delivers maximum operational ROI when connected to enterprise data pipelines. Here are two enterprise blueprints frequently deployed by Pragma Code for SMEs and professional service providers:

CRM Integration

CRM Deal to Payment Link

When a deal moves to "Closed-Won" in HubSpot or Pipedrive, an automated n8n workflow triggers the SumUp REST API to create a checkout session with an embedded payment link, while the invoice is recorded in SumUp Invoices or connected billing software.

POS & Banking

POS Payment to Finom

A card transaction event on a SumUp Solo reader delivers status updates via Cloud API using return_url. The payment is fetched via API, reconciled against the open invoice, and matched with Finom bank records.

Architectural Data Flow of the Invoicing & Clearing Pipeline

The following diagram illustrates the bidirectional communication between SumUp hardware terminals, cloud APIs, integration middleware, and financial repositories:

┌─────────────────────────┐          ┌───────────────────────────┐
│  SumUp POS Card Reader  │          │  CRM / E-Commerce System  │
│  On-Site Contactless    │          │  (HubSpot / WooCommerce)  │
└────────────┬────────────┘          └─────────────┬─────────────┘
             │ Cloud API                          │ Deal Closed /
             │ return_url                         │ Order Placed
             ▼                                    ▼
┌────────────────────────────────────────────────────────────────┐
│           n8n / Integration Middleware (API Key / OAuth 2.0)   │
│                                                                │
│  1. Receive webhook & query checkout via API                   │
│  2. Dispatch checkout creation (/v0.1/checkouts)               │
│  3. Reconcile invoice in SumUp Invoices / accounting tool      │
│  4. Split accounting ledger: Gross revenue vs. Merchant fees   │
└────────────┬────────────────────────────────────┬──────────────┘
             │                                    │
             ▼                                    ▼
┌─────────────────────────┐          ┌───────────────────────────┐
│ Finom / Bank Account    │          │ DATEV / Tax Advisor       │
│ Automated Reconciliation│          │ Compliant Audit Archive   │
└─────────────────────────┘          └───────────────────────────┘

Code Implementations: Node.js / TypeScript & Python

To demonstrate how developers can integrate SumUp programmatically, below are two production-ready scripts: a type-safe TypeScript service for automated checkout creation and a resilient Python/FastAPI webhook listener.

1. TypeScript: Create Checkout via SumUp REST API

This modular TypeScript function authenticates with an API key and creates a checkout session with amount, currency, and a return_url for status notifications:

interface CreateCheckoutPayload {
  checkout_reference: string;
  amount: number;
  currency: string;
  merchant_code: string;
  description: string;
  return_url: string;
}

export async function createSumUpCheckout(
  payload: CreateCheckoutPayload
): Promise<{ id: string; status: string }> {
  const apiKey = process.env.SUMUP_API_KEY;
  if (!apiKey) {
    throw new Error('SUMUP_API_KEY is not configured');
  }

  const response = await fetch('https://api.sumup.com/v0.1/checkouts', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      checkout_reference: payload.checkout_reference,
      amount: payload.amount,
      currency: payload.currency || 'EUR',
      merchant_code: payload.merchant_code,
      description: payload.description,
      return_url: payload.return_url,
    }),
  });

  if (!response.ok) {
    const errorText = await response.text();
    throw new Error(`SumUp API Error: ${response.status} - ${errorText}`);
  }

  return response.json();
}

2. Python / FastAPI: Webhook Handler & Status Verification

The following FastAPI endpoint processes CHECKOUT_STATUS_CHANGED events, queries checkout details via API, and prepares clean records for banking reconciliation:

import os
import httpx
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="SumUp Webhook & Financial Reconciliation Engine")

SUMUP_API_KEY = os.getenv("SUMUP_API_KEY", "sup_sk_live_sample")

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

@app.post("/api/v1/webhooks/sumup")
async def handle_sumup_webhook(event: SumUpWebhookEvent):
    # SumUp does not cryptographically sign webhook payloads; always verify via API.
    if event.event_type != "CHECKOUT_STATUS_CHANGED":
        return {"status": "ignored", "reason": "Unmonitored event type"}

    checkout_id = event.id
    headers = {"Authorization": f"Bearer {SUMUP_API_KEY}"}

    async with httpx.AsyncClient() as client:
        res = await client.get(
            f"https://api.sumup.com/v0.1/checkouts/{checkout_id}",
            headers=headers
        )

    if res.status_code != 200:
        raise HTTPException(status_code=502, detail="Failed to fetch checkout details")

    checkout = res.json()
    status = checkout.get("status")

    if status == "PAID":
        amount = checkout.get("amount")
        currency = checkout.get("currency")
        # TODO: Calculate processing fees and execute reconciliation split for Finom / ledger
        print(f"Payment confirmed for checkout {checkout_id}: {amount} {currency}")
        return {"status": "success", "checkout_id": checkout_id}

    return {"status": "pending", "checkout_status": status}

Finom Banking & SumUp Clearing: Reconciling Batch Payouts

A recurring pain point for small businesses and merchants is the variance between daily card payments and periodic bank deposits received inside their Finom checking account.

SumUp aggregates daily customer card transactions and pays out a single net sum, having deducted processing fees. Trying to match this lump-sum deposit manually against dozens of individual customer invoices creates friction during monthly tax preparation.

Best Practice: The 3-Step Transit Clearing Architecture

1. Transit Clearing Account: When an in-person or online payment is approved in SumUp, the transaction is immediately booked against an interim transit account (e.g. SumUp Clearing).
2. Real-Time Invoice Settlement: The corresponding customer invoice in SumUp Invoices is instantly tagged as settled.
3. Automated Batch Matching: When the aggregated lump-sum deposit arrives on the Finom bank account, an automated script balances the gross receipts against the transit ledger and books the delta to the merchant processing fee expense account, leaving a zero balance on the clearing ledger.

Software Comparison 2026: SumUp Invoices vs. Competitors

Which invoicing platform aligns best with your business model and transaction volume? The table below compares SumUp Invoices with leading DACH solutions including Lexware Office, sevDesk, and Sorted:

Criteria SumUp Invoices Lexware Office sevDesk Sorted
Primary Focus Micro-businesses, retail POS, mobile trades & service pros Growing SMEs, startups & collaborative teams Contractors, craftspeople & service SMBs Solo freelancers & self-employed individuals
POS & Card Hardware Natively integrated (Solo, Air, 3G) Via third-party integrations Via partner extensions No hardware support
E-Invoicing (ZUGFeRD/XRechnung) Yes (EN 16931 compliant) Yes (Full enterprise support) Yes (Full enterprise support) Basic e-invoicing
Bookkeeping Scope Revenue capture & EÜR preparation Full double-entry, P&L, balance sheets, VAT returns Complete cash accounting & advance VAT filing Focus on German freelancer EÜR & VAT
API & Webhooks Payment API (checkouts, transactions); no invoicing API Extensive REST API REST API & Webhooks Limited API access
Entry Pricing see provider pricing page see provider pricing page see provider pricing page see provider pricing page

Conclusion & Implementation Roadmap for Scalable Businesses

The transition from Debitoor to SumUp Invoices reflects the broader convergence of billing and payment rails. Modern small businesses no longer operate with fragmented software stacks that decouple invoice generation from customer settlements. Whether servicing clients on-site, managing a storefront, or selling consulting services online, the combination of hardware card readers, compliant e-invoicing, and open REST APIs gives SMBs an agile operational command center.

By integrating SumUp into enterprise automation workflows via n8n and orchestrating data exchange with digital banking solutions like Finom and treasury forecasting tools like Commitly, you eliminate manual bookkeeping overhead and accelerate cash collection.

Quick-Check: 4-Step Implementation Roadmap for SumUp Automation

1. Merchant API Setup: Register OAuth 2.0 app credentials in the SumUp Developer Portal or configure an API key for transaction access.
2. E-Invoicing Templates: Configure corporate tax identifiers, VAT categories, and ZUGFeRD profiles.
3. Webhook Listeners: Configure return_url for checkout status notifications and automate gross-versus-fee calculations.
4. Automated Bank Clearing: Implement a transit account reconciling Finom bank deposits against SumUp settlement batches.

Looking to integrate SumUp Invoices and card terminals into your existing CRM, architect resilient webhook pipelines, or deploy custom API connectors? The engineering team at Pragma Code designs, builds, and maintains high-performance workflow automation solutions tailored to your operational architecture.

Ready to Automate Invoicing and Card Payments?

Let's discuss how custom API integrations and automated clearing pipelines can streamline your billing operations.

Schedule a Free Technical Consultation

AI automation for your business?

I deliver this for small and mid-sized businesses: at a fixed price agreed upfront, working directly with the person who builds it. Process, scope and pricing are on the service page.

See service & pricing Or request a free intro call

Extended Specialized Glossary

Debitoor

A cloud invoicing and accounting software originally built for freelancers and micro-businesses, acquired by SumUp and transitioned into SumUp Invoices.

SumUp Invoices

SumUp's integrated cloud invoicing and payment solution allowing SMBs to generate compliant e-invoices, accept card payments via payment links and POS card readers, and automate workflows via REST APIs.

ZUGFeRD

A hybrid e-invoicing format that combines a human-readable PDF document with standardized, machine-readable XML invoice data compliant with EN 16931.

REST API

An architectural style for network-based software interfaces utilizing standard HTTP verbs (GET, POST, PUT, DELETE) for seamless, platform-independent system interoperability.

Alexander Ohl

Alexander Ohl

Automated assistant • Online

Hello! I am the Pragma-Code Assistant. How can I help you today? You can ask me about our services or select a topic below.