rechnungsapi.de
    Startseite
    Lösungen
    Zielgruppen
    Steuerberater & KanzleienUnternehmen & MittelstandIT-Teams & SoftwareanbieterE-Invoicing-Berater & PartnerStartups & SaaSInternational & Peppol
    ERP-SystemeAptifyClaris FileMakerDocuWareIBM i (AS/400)IFSMicrosoft Dynamics 365 Business CentralMicrosoft Dynamics 365 Finance & OperationsMicrosoft Dynamics NAV (Navision)OdooOnline-Shops (Shopify, WooCommerce, Shopware)Oracle NetSuiteproALPHASage 100 (Office Line)Sage Classic LineSalesforceSAP ECC 6.0SAP S/4HANAWord & Excel
    Produkte
    E-Rechnung per OrdnerPDF in ZUGFeRD umwandelnPeppol-AnbindungRechnung auslesen: PDF zu JSONXRechnung APIZUGFeRD API
    PreiseValidatorXML-ViewerBlogKontakt
    Dokumentation
    DokumentationOrdner-Integration & SFTP, ohne ProgrammierungAPI DocsREST-API-Referenz für Entwickler
    AnmeldenLoslegen
    Zurück zum Blog
    SalesforceApex & FlowZUGFeRDXRechnungPraxisleitfaden

    Salesforce mit rechnungsapi.de verbinden: So wird aus dem CRM eine E-Rechnungs-Lösung

    Praxisleitfaden: XRechnung und ZUGFeRD direkt aus Salesforce, per Flow, Apex oder Middleware. Ohne neues ERP, ohne Umbau der Systemlandschaft, und mit einer günstigen Alternative zu Conga Composer.

    19. November 202614 min Lesezeit

    Kurz gesagt

    Salesforce bleibt das führende System. Ein Flow mit HTTP Callout oder eine Apex-Queueable übergibt die Rechnungsdaten als JSON an rechnungsapi.de und erhält eine validierte XRechnung oder ein ZUGFeRD-PDF/A-3 zurück, das als Datei am Rechnungsdatensatz landet. Die Umsetzung in Salesforce übernimmt Ihr Team oder Ihr Salesforce-Dienstleister, typischerweise in 4 bis 6 Projekttagen. Wir begleiten fachlich: Pflichtfelder, Mapping und Validierung.

    Aus der Praxis: drei Salesforce-Projekte mit rechnungsapi.de

    Dieser Leitfaden beruht auf umgesetzten Projekten. Drei Kunden erzeugen ihre E-Rechnungen aus Salesforce mit rechnungsapi.de, jeder auf einem anderen Weg:

    1

    Direkte API-Anbindung per Apex und Flow

    Salesforce übergibt die Rechnungsdaten bei Freigabe per Apex an die API. Das validierte ZUGFeRD-PDF liegt danach als Datei am Rechnungsdatensatz, Fehler stehen mit Regel-ID im Datensatz.

    2

    Datenintegration NetSuite und Salesforce

    Für ein Online-Marktplatz-Unternehmen laufen Rechnungen aus NetSuite und Salesforce über dieselbe Schnittstelle. Beide Systeme erzeugen E-Rechnungen im gleichen Format und mit derselben Prüfung.

    3

    PDF-Ordner mit OCR statt Salesforce-Projekt

    Das Angebot des Salesforce-Dienstleisters lag deutlich über dem Budget. Salesforce exportiert die Rechnungen jetzt als PDF in einen Ordner, rechnungsapi.de scannt sie per OCR und konvertiert sie in validierte ZUGFeRD-Dateien.

    Kundennamen nennen wir nur mit Freigabe.

    1. Salesforce kennt die Kunden, aber nicht alle E-Rechnungsfelder

    Salesforce ist für viele Unternehmen das zentrale System für Kunden, Angebote, Aufträge und Verträge. Oft entstehen dort auch die Rechnungen, direkt oder über angebundene Lösungen. Mit der E-Rechnungspflicht kommt die Frage: Wie werden aus diesen Daten normgerechte E-Rechnungen im Format XRechnung oder ZUGFeRD?

    Viele Angaben sind schon da: Stammdaten aus Account und Contact, Produkte, Preise und Mengen aus Quote oder Order, Vertragsreferenzen. Für eine Rechnung nach EN 16931 fehlen aber häufig diese Felder:

    InformationFeldTypische Herausforderung
    Umsatzsteuer-ID des KäufersBT-48Nicht immer im Account gepflegt
    Käuferreferenz / Leitweg-IDBT-10Häufig nicht vorhanden, bei öffentlichen Auftraggebern Pflicht (BR-DE-15)
    Elektronische Adresse des KäufersBT-49In klassischen CRM-Datenmodellen selten
    LeistungsdatumBT-72Oft nur Erstellungs- oder Auftragsdatum vorhanden
    ZahlungsartBT-81Nicht immer strukturiert hinterlegt
    IBAN des VerkäufersBT-84Wird meist außerhalb von Salesforce gepflegt
    MengeneinheitBT-130Picklisten statt UN/ECE-Codes (z. B. HUR, C62)
    SteuerkategorieBT-151Salesforce-Steuercodes müssen auf EN-16931-Kategorien gemappt werden

    Salesforce kann Rechnungsdaten also verwalten. Die Arbeit liegt darin, sie in das standardisierte E-Rechnungsmodell zu überführen und fehlende Angaben zu ergänzen. Genau das übernimmt rechnungsapi.de.

    2. Die Architektur: Salesforce bleibt das führende System

    Salesforce erzeugt und verwaltet die Rechnungsdaten, rechnungsapi.de übernimmt Format, Validierung und Dokument. UBL, CII, PDF/A-3 und die Geschäftsregeln der EN 16931 müssen Sie in Salesforce nicht selbst implementieren.

    1. 1Salesforce: Eine Rechnung wird erstellt oder zur Verarbeitung freigegeben (Statuswechsel, Button oder Batch).
    2. 2API-Aufruf: Salesforce übergibt die Rechnungsdaten als JSON an rechnungsapi.de, authentifiziert über eine Named Credential.
    3. 3Validierung: rechnungsapi.de prüft die Daten gegen EN 16931 und die deutschen Geschäftsregeln (BR-DE).
    4. 4Generierung: Es entsteht eine XRechnung (CII oder UBL) oder ein ZUGFeRD-PDF/A-3 mit eingebettetem XML.
    5. 5Rückübertragung: Dokument und Validierungsstatus gehen zurück an Salesforce und werden als Datei am Rechnungsdatensatz gespeichert.

    3. Vier Wege, Salesforce anzubinden

    Salesforce ruft externe REST-APIs nativ auf. Welcher Weg passt, hängt von Datenmodell, Volumen und Team ab. Allen gemeinsam ist die Named Credential: Sie hält die Basis-URL und den API-Token, damit kein Schlüssel im Code oder im Flow steht.

    Flow + HTTP Callout (Low-Code)

    Im Flow Builder legen Sie eine HTTP-Callout-Aktion an, die auf der Named Credential aufsetzt; das Schema leiten Sie aus einem Beispiel-JSON ab. Flow kann Dateien nicht ohne Apex als Base64 übergeben. Geeignet ist dieser Weg deshalb für Aufrufe mit reinem JSON: die XRechnung (createXinvoiceFromJson) oder das ZUGFeRD-PDF aus Ihrem Template (createInvoicePdfFromJson).

    Passt bei: XRechnung oder Template-PDF, überschaubare Positionen, Admins ohne Apex

    Apex (Queueable + Invocable)

    Eine Queueable-Klasse mit Database.AllowsCallouts baut das JSON aus Rechnung und Positionen, liest das Rechnungs-PDF vom Datensatz, ruft die API asynchron auf und speichert das Ergebnis. Über eine @InvocableMethod starten Sie sie aus einem Flow. Volle Kontrolle über Mapping, Dateien und Fehlerbehandlung.

    Passt bei: Komplexe Datenmodelle, Sammelverarbeitung, saubere Fehlerbehandlung

    Middleware (MuleSoft, n8n, Platform Events)

    Salesforce publiziert ein Platform Event oder eine Outbound Message, die Middleware holt die Daten, ruft die API auf und schreibt das Ergebnis über die Salesforce REST API zurück. Entlastet die Org von Callout- und Heap-Limits.

    Passt bei: Hohe Volumina, mehrere Quellsysteme, vorhandene Integrationsplattform

    Ordner + KI-Erkennung (ohne Salesforce-Entwicklung)

    Salesforce bzw. Conga legt die fertigen Rechnungs-PDFs in einem Ordner ab, etwa per Nextcloud, SFTP oder WebDAV. rechnungsapi.de liest jedes PDF per OCR und KI-Erkennung aus, prüft die Summen gegen das Dokument und legt eine validierte ZUGFeRD-Datei zurück. In der Org wird nichts programmiert.

    Passt bei: Einfache Rechnungen, kein Budget für Salesforce-Consultants, PDFs enthalten alle Pflichtangaben

    Aus der Praxis: PDF-Ordner statt teurem Salesforce-Projekt

    Bei einem Kunden lag das Angebot des Salesforce-Dienstleisters für die API-Anbindung deutlich über dem Budget. Wir haben deshalb den Ordner-Weg umgesetzt: Salesforce exportiert die Rechnungen wie bisher als PDF in einen überwachten Ordner, rechnungsapi.de scannt sie per OCR, erkennt die Rechnungsfelder per KI und konvertiert sie in validierte ZUGFeRD-Dateien. Ohne Eingriff in die Salesforce-Org und ohne Dienstleisterstunden. Voraussetzung: Die Pflichtangaben wie USt-IdNr., Leistungsdatum und Zahlungsdaten stehen im PDF.

    Wo der Weg an Grenzen kommt: Bei einfachen Rechnungen mit wenigen Positionen und einem Steuersatz funktioniert die Erkennung sehr gut. Komplexe Rechnungen mit vielen Positionen, Rabatten, Abschlägen oder mehreren Steuersätzen brauchen auf unserer Seite mehr Abstimmung und Prüfregeln. Günstiger als eine Anbindung durch Salesforce-Consultants war es in unseren Projekten in jedem Fall. Mehr dazu unter E-Rechnung per Ordner und PDF in ZUGFeRD umwandeln.

    Named Credential einrichten

    Die API erwartet den Header Authorization: Bearer <Token>. Den Token hinterlegen Sie als Parameter der External Credential, nicht im Flow:

    Salesforce Setup
    Setup → Named Credentials
    
    External Credential   RechnungsAPI_Auth
      Authentication       Custom
      Principal            Named Principal
      Principal-Parameter  Token = <Ihr rechnungsapi.de API-Token>
      Custom Header        Authorization = {!'Bearer ' & $Credential.RechnungsAPI_Auth.Token}
    
    Named Credential      RechnungsAPI
      URL                  https://api.rechnungsapi.de
      External Credential  RechnungsAPI_Auth
    
    Permission Set        External Credential Principal Access: RechnungsAPI_Auth
                          allen Nutzern zuweisen, die Rechnungen freigeben
                          (die Queueable läuft im Kontext dieses Nutzers)

    4. Der API-Aufruf: strukturiertes JSON, kein XML

    Salesforce übergibt kein XRechnung- oder ZUGFeRD-XML, sondern JSON mit den Feldern der EN 16931. Die Feldnamen entsprechen der API-Dokumentation, jedes Feld hat seine BT-Nummer. Die Basis-URL ist https://api.rechnungsapi.de, authentifiziert wird mit Authorization: Bearer <Token>. Ein gekürztes Beispiel für das Objekt invoice:

    Request-Body (gekürzt)
    {
      "invoice": {
        "invoiceNumber": "RE-2026-001",
        "invoiceIssueDate": "2026-11-19",
        "invoiceTypeCode": "380",
        "invoiceCurrencyCode": "EUR",
        "buyerReference": "04011000-12345-67",
        "paymentTerms": "Zahlbar innerhalb von 14 Tagen ohne Abzug.",
        "seller": {
          "sellerName": "Muster GmbH",
          "sellerVatIdentifier": "DE123456789",
          "sellerElectronicAddress": "rechnung@muster.de",
          "sellerPostalAddress": {
            "sellerAddressLine1": "Hauptstraße 5",
            "sellerCity": "Mainz",
            "sellerPostCode": "55116",
            "sellerCountryCode": "DE"
          }
        },
        "buyer": {
          "buyerName": "Kunde GmbH",
          "buyerVatIdentifier": "DE987654321",
          "buyerElectronicAddress": "eingang@kunde.de",
          "buyerPostalAddress": {
            "buyerAddressLine1": "Musterstraße 1",
            "buyerCity": "Wiesbaden",
            "buyerPostCode": "65183",
            "buyerCountryCode": "DE"
          }
        },
        "deliveryInformation": { "actualDeliveryDate": "2026-11-18" },
        "paymentInstructions": {
          "paymentMeansTypeCode": "58",
          "creditTransfer": [{ "paymentAccountIdentifier": "DE89370400440532013000" }]
        },
        "invoiceLine": [
          {
            "invoiceLineIdentifier": "1",
            "invoicedQuantity": 10,
            "invoicedQuantityUnitOfMeasureCode": "HUR",
            "invoiceLineNetAmount": 1000.00,
            "priceDetails": { "itemNetPrice": 100.00 },
            "lineVatInformation": [{ "invoicedItemVatCategoryCode": "S", "invoicedItemVatRate": 19 }],
            "itemInformation": { "itemName": "Consulting" }
          }
        ],
        "vatBreakdown": [
          { "vatCategoryTaxableAmount": 1000.00, "vatCategoryTaxAmount": 190.00, "vatCategoryCode": "S", "vatCategoryRate": 19 }
        ],
        "documentTotals": {
          "sumOfInvoiceLineNetAmount": 1000.00,
          "invoiceTotalAmountWithoutVat": 1000.00,
          "invoiceTotalVatAmount": 190.00,
          "invoiceTotalAmountWithVat": 1190.00,
          "amountDueForPayment": 1190.00
        }
      }
    }

    Welcher Endpunkt passt, hängt davon ab, woher das PDF kommt:

    ZielEndpunktPflichtfelderAntwort
    XRechnung (XML)/api/v1/zugferd/createXinvoiceFromJsoninvoiceXML in xInvoice, downloadURL, Prüfergebnis
    ZUGFeRD aus Ihrem PDF (z. B. Conga)/api/v1/zugferd/createZugferdFromJsoninvoice, invoicePdf64PDF als Base64 in zugferd, zugferdValid, xInvoiceValid, Fehlerlisten
    ZUGFeRD aus unserem Template/api/v1/zugferd/createInvoicePdfFromJsoninvoice, templateIddownloadURL, zugferdIsValid, zugferdErrors

    HTTP 200 heißt nur, dass ein Dokument erzeugt wurde. Prüfen Sie immer die Gültigkeitsfelder, bevor Sie die Rechnung versenden.

    5. Apex-Beispiel: Queueable mit Callout und Ablage am Datensatz

    Das folgende Beispiel erzeugt ein ZUGFeRD-PDF aus einem PDF, das bereits am Datensatz liegt, etwa von Conga Composer. Es geht von einem eigenen Rechnungsobjekt Invoice__c mit Positionen aus. Es läuft asynchron, damit Callout-Zeit und Heap nicht den Speichervorgang des Nutzers blockieren. Das fertige PDF wird als ContentVersion direkt an den Rechnungsdatensatz gehängt, Fehler landen mit Regel-ID in einem Feld.

    EInvoiceJob.cls
    public with sharing class EInvoiceJob implements Queueable, Database.AllowsCallouts {
        private final Id invoiceId;
        public EInvoiceJob(Id invoiceId) { this.invoiceId = invoiceId; }
    
        public void execute(QueueableContext ctx) {
            Invoice__c inv = EInvoiceMapper.load(invoiceId);
    
            // Rechnungs-PDF am Datensatz suchen, z. B. von Conga Composer abgelegt
            Set<Id> docIds = new Set<Id>();
            for (ContentDocumentLink l : [
                    SELECT ContentDocumentId FROM ContentDocumentLink WHERE LinkedEntityId = :invoiceId]) {
                docIds.add(l.ContentDocumentId);
            }
            List<ContentVersion> pdfs = [
                SELECT VersionData FROM ContentVersion
                WHERE ContentDocumentId IN :docIds AND IsLatest = true
                  AND FileExtension = 'pdf' AND (NOT Title LIKE '%ZUGFeRD%')
                ORDER BY CreatedDate DESC LIMIT 1
            ];
            if (pdfs.isEmpty()) {
                update new Invoice__c(Id = inv.Id, EInvoice_Status__c = 'Fehler',
                    EInvoice_Errors__c = 'Kein Rechnungs-PDF am Datensatz gefunden.');
                return;
            }
    
            // invoice und invoicePdf64 sind bei createZugferdFromJson Pflicht
            HttpRequest req = new HttpRequest();
            req.setEndpoint('callout:RechnungsAPI/api/v1/zugferd/createZugferdFromJson');
            req.setMethod('POST');
            req.setHeader('Content-Type', 'application/json');
            req.setTimeout(120000);   // Maximum, gilt für alle Callouts der Transaktion zusammen
            req.setBody(JSON.serialize(new Map<String, Object>{
                'invoice' => EInvoiceMapper.toInvoice(inv),
                'invoicePdf64' => EncodingUtil.base64Encode(pdfs[0].VersionData)
            }));
            HttpResponse res = new Http().send(req);
    
            Map<String, Object> out;
            try {
                out = (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
            } catch (Exception e) {   // z. B. 401 ohne JSON-Body
                out = new Map<String, Object>{ 'message' => res.getStatus() + ' ' + res.getBody() };
            }
    
            // HTTP 200 heißt nur "Dokument erzeugt": beide Gültigkeitsfelder prüfen
            Boolean valid = res.getStatusCode() == 200
                && (Boolean) out.get('zugferdValid') == true
                && (Boolean) out.get('xInvoiceValid') == true;
    
            // Callout ist erledigt, ab hier ist DML erlaubt
            if (valid) {
                insert new ContentVersion(
                    Title = inv.Name + ' ZUGFeRD',
                    PathOnClient = inv.Name + '-zugferd.pdf',
                    VersionData = EncodingUtil.base64Decode((String) out.get('zugferd')),
                    FirstPublishLocationId = inv.Id
                );
            }
            update new Invoice__c(
                Id = inv.Id,
                EInvoice_Status__c = valid ? 'Erzeugt' : 'Fehler',
                EInvoice_Errors__c = valid ? null : JSON.serializePretty(new Map<String, Object>{
                    'status' => res.getStatusCode(),
                    'message' => out.get('message'),
                    'xInvoiceErrorList' => out.get('xInvoiceErrorList'),
                    'zugferdErrorList' => out.get('zugferdErrorList')
                }).left(131072)
            );
        }
    }

    Der Mapper baut das JSON aus Rechnung, Positionen und den Verkäuferdaten aus Custom Metadata (EInvoice_Setting__mdt mit dem Datensatz Default). Die Steueraufschlüsselung rechnet er je Kategorie und Satz selbst, damit Positionen und Summen auf den Cent zusammenpassen:

    EInvoiceMapper.cls
    public with sharing class EInvoiceMapper {
    
        public static Invoice__c load(Id invoiceId) {
            return [
                SELECT Id, Name, Invoice_Date__c, Service_Date__c, Buyer_Reference__c,
                       Account__r.Name, Account__r.VAT_Number__c, Account__r.EInvoice_Email__c,
                       Account__r.BillingStreet, Account__r.BillingCity,
                       Account__r.BillingPostalCode, Account__r.BillingCountryCode,
                       (SELECT Line_No__c, Quantity__c, Unit_Code__c, Unit_Price__c,
                               Tax_Category__c, Tax_Rate__c, Product_Name__c
                        FROM Invoice_Lines__r ORDER BY Line_No__c)
                FROM Invoice__c WHERE Id = :invoiceId
            ];
        }
    
        public static Map<String, Object> toInvoice(Invoice__c inv) {
            // Verkäuferdaten aus Custom Metadata: ändern ohne Deployment
            EInvoice_Setting__mdt cfg = EInvoice_Setting__mdt.getInstance('Default');
    
            List<Object> lines = new List<Object>();
            Map<String, Decimal> netByVat = new Map<String, Decimal>();
            Decimal netTotal = 0;
            for (Invoice_Line__c l : inv.Invoice_Lines__r) {
                Decimal net = (l.Quantity__c * l.Unit_Price__c).setScale(2, RoundingMode.HALF_UP);
                netTotal += net;
                String key = l.Tax_Category__c + '|' + l.Tax_Rate__c;
                netByVat.put(key, (netByVat.containsKey(key) ? netByVat.get(key) : 0) + net);
                lines.add(new Map<String, Object>{
                    'invoiceLineIdentifier' => String.valueOf(l.Line_No__c),
                    'invoicedQuantity' => l.Quantity__c,
                    'invoicedQuantityUnitOfMeasureCode' => l.Unit_Code__c,
                    'invoiceLineNetAmount' => net,
                    'priceDetails' => new Map<String, Object>{ 'itemNetPrice' => l.Unit_Price__c },
                    'lineVatInformation' => new List<Object>{ new Map<String, Object>{
                        'invoicedItemVatCategoryCode' => l.Tax_Category__c,
                        'invoicedItemVatRate' => l.Tax_Rate__c
                    } },
                    'itemInformation' => new Map<String, Object>{ 'itemName' => l.Product_Name__c }
                });
            }
    
            // Steueraufschlüsselung je Kategorie und Satz (BG-23)
            List<Object> vatBreakdown = new List<Object>();
            Decimal vatTotal = 0;
            for (String key : netByVat.keySet()) {
                Decimal base = netByVat.get(key);
                Decimal rate = Decimal.valueOf(key.substringAfter('|'));
                Decimal tax = (base * rate / 100).setScale(2, RoundingMode.HALF_UP);
                vatTotal += tax;
                vatBreakdown.add(new Map<String, Object>{
                    'vatCategoryCode' => key.substringBefore('|'),
                    'vatCategoryRate' => rate,
                    'vatCategoryTaxableAmount' => base,
                    'vatCategoryTaxAmount' => tax
                });
            }
            Decimal gross = netTotal + vatTotal;
    
            return new Map<String, Object>{
                'invoiceNumber' => inv.Name,
                'invoiceIssueDate' => inv.Invoice_Date__c,          // Date wird als JJJJ-MM-TT serialisiert
                'invoiceTypeCode' => '380',
                'invoiceCurrencyCode' => 'EUR',
                'buyerReference' => inv.Buyer_Reference__c,
                'paymentTerms' => cfg.Payment_Terms__c,
                'seller' => new Map<String, Object>{
                    'sellerName' => cfg.Seller_Name__c,
                    'sellerVatIdentifier' => cfg.Seller_VAT_Id__c,
                    'sellerElectronicAddress' => cfg.Seller_Email__c,
                    'sellerPostalAddress' => new Map<String, Object>{
                        'sellerAddressLine1' => cfg.Seller_Street__c,
                        'sellerCity' => cfg.Seller_City__c,
                        'sellerPostCode' => cfg.Seller_Postcode__c,
                        'sellerCountryCode' => 'DE'
                    }
                },
                'buyer' => new Map<String, Object>{
                    'buyerName' => inv.Account__r.Name,
                    'buyerVatIdentifier' => inv.Account__r.VAT_Number__c,
                    'buyerElectronicAddress' => inv.Account__r.EInvoice_Email__c,
                    'buyerPostalAddress' => new Map<String, Object>{
                        'buyerAddressLine1' => inv.Account__r.BillingStreet,
                        'buyerCity' => inv.Account__r.BillingCity,
                        'buyerPostCode' => inv.Account__r.BillingPostalCode,
                        'buyerCountryCode' => inv.Account__r.BillingCountryCode
                    }
                },
                'deliveryInformation' => new Map<String, Object>{ 'actualDeliveryDate' => inv.Service_Date__c },
                'paymentInstructions' => new Map<String, Object>{
                    'paymentMeansTypeCode' => '58',                  // SEPA-Überweisung
                    'creditTransfer' => new List<Object>{
                        new Map<String, Object>{ 'paymentAccountIdentifier' => cfg.IBAN__c }
                    }
                },
                'invoiceLine' => lines,
                'vatBreakdown' => vatBreakdown,
                'documentTotals' => new Map<String, Object>{
                    'sumOfInvoiceLineNetAmount' => netTotal,
                    'invoiceTotalAmountWithoutVat' => netTotal,
                    'invoiceTotalVatAmount' => vatTotal,
                    'invoiceTotalAmountWithVat' => gross,
                    'amountDueForPayment' => gross
                }
            };
        }
    }

    Damit Admins die Erzeugung im Flow auslösen können, etwa beim Statuswechsel auf „Freigegeben“:

    EInvoiceAction.cls
    public with sharing class EInvoiceAction {
        @InvocableMethod(label='E-Rechnung erzeugen' category='rechnungsapi.de')
        public static void run(List<Id> invoiceIds) {
            // Höchstens 50 Queueables pro Transaktion; für Monatsläufe Batch Apex nutzen
            for (Id invoiceId : invoiceIds) {
                System.enqueueJob(new EInvoiceJob(invoiceId));
            }
        }
    }

    Für das Deployment in die Produktion verlangt Salesforce eine Testabdeckung von 75 %. Ein Test mit HttpCalloutMock, der den API-Aufruf simuliert:

    EInvoiceJobTest.cls
    @IsTest
    private class EInvoiceJobTest {
        private class ApiMock implements HttpCalloutMock {
            public HttpResponse respond(HttpRequest req) {
                HttpResponse res = new HttpResponse();
                res.setStatusCode(200);
                res.setHeader('Content-Type', 'application/json');
                res.setBody(JSON.serialize(new Map<String, Object>{
                    'zugferdValid' => true,
                    'xInvoiceValid' => true,
                    'zugferd' => EncodingUtil.base64Encode(Blob.valueOf('%PDF-1.7 test'))
                }));
                return res;
            }
        }
    
        @IsTest
        static void storesZugferdAtInvoice() {
            Account acc = new Account(Name = 'Kunde GmbH');
            insert acc;
            Invoice__c inv = new Invoice__c(Account__c = acc.Id,
                Invoice_Date__c = Date.today(), Service_Date__c = Date.today());
            insert inv;
            insert new Invoice_Line__c(Invoice__c = inv.Id, Line_No__c = 1, Quantity__c = 10,
                Unit_Price__c = 100, Unit_Code__c = 'HUR', Tax_Category__c = 'S',
                Tax_Rate__c = 19, Product_Name__c = 'Consulting');
            insert new ContentVersion(Title = 'Rechnung', PathOnClient = 'Rechnung.pdf',
                VersionData = Blob.valueOf('%PDF-1.7 conga'), FirstPublishLocationId = inv.Id);
    
            Test.setMock(HttpCalloutMock.class, new ApiMock());
            Test.startTest();
            EInvoiceAction.run(new List<Id>{ inv.Id });
            Test.stopTest();
    
            Assert.areEqual('Erzeugt',
                [SELECT EInvoice_Status__c FROM Invoice__c WHERE Id = :inv.Id].EInvoice_Status__c);
        }
    }
    Voraussetzungen in Ihrer Org: Objekte Invoice__c und Invoice_Line__c (Master-Detail, Beziehungsname Invoice_Lines__r) mit den abgefragten Feldern, die Felder EInvoice_Status__c und EInvoice_Errors__c (Long Text) sowie Custom Metadata EInvoice_Setting__mdt. BillingCountryCode gibt es nur mit aktivierten State and Country Picklists, sonst BillingCountry auf den ISO-Code mappen. Objekt- und Feldnamen sind Beispiele: Passen Sie sie an Ihr Datenmodell an.
    Limits beachten: Alle Callouts einer Transaktion zusammen dürfen höchstens 120 Sekunden dauern, nach einem DML-Befehl ist in derselben Transaktion kein Callout mehr erlaubt, und Base64-PDFs belasten den Heap (6 MB synchron, 12 MB asynchron). Für Monatsläufe mit vielen Rechnungen nutzen Sie Batch Apex mit kleiner Batch-Größe oder verlagern den Aufruf in eine Middleware. Den Mapper EInvoiceMapper halten Sie getrennt, damit Feldänderungen nicht den Callout-Code berühren.

    6. Das Feldmapping: konfigurierbar statt fest verdrahtet

    Der größte Teil der Arbeit steckt im Mapping. Die Custom Fields in der Tabelle sind Beispiele, jede Org ist anders. Legen Sie das Mapping deshalb in Custom Metadata ab: Firmen-IBAN, Verkäuferdaten, Steuercode-Zuordnung und Einheiten-Codes ändern Sie dann ohne Deployment.

    Salesforcerechnungsapi.deFeld
    Account.Namebuyer.buyerNameBT-44
    Account.VAT_Number__cbuyer.buyerVatIdentifierBT-48
    Account.EInvoice_Email__cbuyer.buyerElectronicAddressBT-49
    Account.BillingStreetbuyer.buyerPostalAddress.buyerAddressLine1BT-50
    Account.BillingPostalCodebuyer.buyerPostalAddress.buyerPostCodeBT-53
    Account.BillingCountryCodebuyer.buyerPostalAddress.buyerCountryCodeBT-55
    Invoice__c.NameinvoiceNumberBT-1
    Invoice__c.Invoice_Date__cinvoiceIssueDateBT-2
    Invoice__c.Buyer_Reference__cbuyerReferenceBT-10
    Invoice__c.Service_Date__cdeliveryInformation.actualDeliveryDateBT-72
    Custom Metadata: Firmen-IBANpaymentInstructions.creditTransfer[].paymentAccountIdentifierBT-84
    Invoice_Line__c.Quantity__cinvoiceLine[].invoicedQuantityBT-129
    Invoice_Line__c.Unit_Code__cinvoiceLine[].invoicedQuantityUnitOfMeasureCodeBT-130
    Invoice_Line__c.Unit_Price__cinvoiceLine[].priceDetails.itemNetPriceBT-146
    Invoice_Line__c.Tax_Category__cinvoiceLine[].lineVatInformation[].invoicedItemVatCategoryCodeBT-151

    7. Conga Composer: weiter nutzen oder günstiger ersetzen

    Viele Salesforce-Kunden erzeugen ihre Rechnungs-PDFs mit Conga Composer. Ein PDF allein ist aber keine E-Rechnung. Es gibt zwei Wege, und beide enden in einer ZUGFeRD-Datei mit eingebettetem XML:

    A: Conga bleibt, wir ergänzen das XML

    1. Conga Composer erzeugt das PDF wie bisher.
    2. Apex übergibt PDF (invoicePdf64) und JSON an createZugferdFromJson.
    3. rechnungsapi.de bettet das XML ein und liefert ein PDF/A-3 zurück.

    Passt, wenn Conga ohnehin für viele Dokumentarten im Einsatz ist.

    B: Unser Template statt Conga

    1. Ihr Rechnungslayout wird einmalig zum Word-Template.
    2. Apex sendet nur das JSON an createInvoicePdfFromJson.
    3. PDF und XML entstehen in einem Aufruf als fertige ZUGFeRD-Datei.

    Die kostengünstige Alternative, wenn die Conga-Lizenz vor allem für Rechnungen bezahlt wird.

    Bei Variante B gibt es keine zweite Datenquelle für das Layout: Was im PDF steht, kommt aus demselben JSON wie das XML. Abweichungen zwischen sichtbarer Rechnung und strukturierten Daten sind damit ausgeschlossen. Den Umzug Ihres bestehenden Layouts übernehmen wir mit dem Template-Support für 179,00 € je Rechnungslayout.

    Variante B in Apex
    // Variante B: Ihr Word-Template erzeugt PDF und XML, ein Conga-PDF ist nicht nötig.
    // Pflichtfelder: invoice und templateId
    HttpRequest req = new HttpRequest();
    req.setEndpoint('callout:RechnungsAPI/api/v1/zugferd/createInvoicePdfFromJson');
    req.setMethod('POST');
    req.setHeader('Content-Type', 'application/json');
    req.setHeader('Idempotency-Key', String.valueOf(inv.Id));   // Wiederholung erzeugt keine zweite Rechnung
    req.setTimeout(60000);
    req.setBody(JSON.serialize(new Map<String, Object>{
        'invoice' => EInvoiceMapper.toInvoice(inv),
        'templateId' => 'ihre-template-id',
        'invoiceFilename' => inv.Name + '.pdf'
    }));
    HttpResponse res = new Http().send(req);
    Map<String, Object> out = (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
    
    // Die Antwort enthält einen Download-Link statt der Datei: zweiter Aufruf über dieselbe Named Credential
    if (res.getStatusCode() == 200 && (Boolean) out.get('zugferdIsValid') == true) {
        HttpRequest dl = new HttpRequest();
        dl.setEndpoint('callout:RechnungsAPI'
            + ((String) out.get('downloadURL')).substringAfter('api.rechnungsapi.de'));
        dl.setMethod('GET');
        dl.setTimeout(60000);   // beide Callouts zusammen höchstens 120 Sekunden
        insert new ContentVersion(
            Title = inv.Name + ' ZUGFeRD',
            PathOnClient = inv.Name + '-zugferd.pdf',
            VersionData = new Http().send(dl).getBodyAsBlob(),
            FirstPublishLocationId = inv.Id
        );
    }

    Conga Sign bleibt für Verträge und andere unterschriftsbedürftige Dokumente sinnvoll. Rechnungen brauchen keine elektronische Unterschrift.

    8. E-Rechnungs-Readiness direkt in Salesforce prüfen

    Prüfen Sie die Pflichtangaben, bevor der Callout startet. Ein Flow mit Entscheidungselementen oder Validierungsregeln am Rechnungsobjekt fängt die häufigsten Lücken ab:

    • Ist die Rechnungsnummer vorhanden und eindeutig?
    • Ist das Leistungsdatum oder der Leistungszeitraum angegeben?
    • Ist bei öffentlichen Auftraggebern die Leitweg-ID als Käuferreferenz gepflegt?
    • Ist die elektronische Adresse des Käufers gesetzt?
    • Sind alle Positionen einer Steuerkategorie zugeordnet?
    • Sind die Mengeneinheiten als UN/ECE-Code hinterlegt?
    • Sind die Zahlungsinformationen vollständig?

    Was trotzdem durchrutscht, meldet die API mit Regel-ID, etwa BR-DE-15 für eine fehlende Käuferreferenz. Schreiben Sie diese Meldung an den Datensatz, dann korrigiert der Vertrieb die Daten in Salesforce, statt dass der Fehler erst beim Empfänger auffällt.

    9. Wie lange dauert die Integration?

    Die Arbeiten in Salesforce übernimmt Ihr eigenes Team oder Ihr Salesforce-Dienstleister. rechnungsapi.de entwickelt nicht in Ihrer Org. Für einen ersten produktiven Anwendungsfall mit vorhandenem Rechnungsobjekt rechnet ein Salesforce-Dienstleister etwa mit:

    ArbeitsschrittAufwand
    Named Credential und Authentifizierung0,5–1 Tag
    Callout per Flow oder Apex0,5–1 Tag
    Feldmapping inkl. Custom Fields1–2 Tage
    Rückübertragung der Dokumente0,5–1 Tag
    Tests und Fehlerbehandlung1 Tag
    Gesamtca. 4–6 Tage

    Das ist eine Projektschätzung für einen Dienstleister, keine Zusage. Komplexe Datenmodelle, eigene Billing-Prozesse oder zusätzliche Freigaben erhöhen den Aufwand.

    Unsere Rolle: fachliche Begleitung. Mit der Integrationsbegleitung klären wir, welche Pflichtfelder Ihre Rechnungen brauchen, prüfen das Mapping, stimmen Sonderfälle wie Gutschriften und Abschläge ab und begleiten die Abnahme mit validierten Testrechnungen. Das abgenommene Mapping sichern wir auch über spätere Updates. Ihr Salesforce-Team oder Dienstleister setzt die Anbindung technisch um.

    10. Fazit: Salesforce muss nicht zum E-Rechnungssystem werden

    • Salesforce bleibt das führende CRM- und Abrechnungssystem.
    • Bestehende Prozesse und, wenn gewünscht, Conga-Templates bleiben erhalten.
    • rechnungsapi.de übernimmt Formate, Transformation und Validierung nach EN 16931.
    • Die fertigen Dokumente liegen wieder am Datensatz in Salesforce.

    Mehr zu Salesforce als Quellsystem finden Sie auf der Seite E-Rechnung mit Salesforce.

    Häufige Fragen: Salesforce und E-Rechnung

    Kann Salesforce selbst XRechnung oder ZUGFeRD erzeugen?

    +

    Salesforce bringt keine Erzeugung nach EN 16931 mit. Über eine REST-Anbindung an rechnungsapi.de entstehen aus den vorhandenen Rechnungsdaten validierte XRechnungen und ZUGFeRD-PDFs, die am Datensatz gespeichert werden.

    Brauche ich MuleSoft oder eine andere Middleware?

    +

    Für den Einstieg nicht. Ein Flow mit HTTP Callout oder eine Apex-Klasse reicht. Middleware lohnt sich bei hohen Volumina oder wenn mehrere Systeme Rechnungen erzeugen.

    Wir nutzen Conga Composer. Müssen wir wechseln?

    +

    Nein. Sie übergeben das Conga-PDF zusammen mit den Rechnungsdaten, und rechnungsapi.de bettet das XML ein. Wer die Conga-Lizenz nur für Rechnungen nutzt, kann stattdessen unser Word-Template verwenden: Dort entstehen PDF und XML in einem Aufruf.

    Geht es auch ganz ohne Salesforce-Entwicklung?

    +

    Ja. Salesforce legt die Rechnungs-PDFs in einem Ordner ab, rechnungsapi.de liest sie per OCR und KI-Erkennung aus und erzeugt daraus validierte ZUGFeRD-Dateien. Diesen Weg haben wir für einen Kunden umgesetzt, dem die Anbindung durch einen Salesforce-Dienstleister zu teuer war. Bei einfachen Rechnungen funktioniert das sehr gut, komplexe Rechnungen verursachen auf unserer Seite mehr Aufwand. Günstiger als Salesforce-Consultants ist es in jedem Fall. Die Pflichtangaben müssen dafür im PDF stehen.

    Funktioniert das mit jeder Salesforce-Edition?

    +

    Apex und API-Zugriff gibt es ab der Enterprise Edition. In der Professional Edition ist der API-Zugriff ein kostenpflichtiges Add-on, eigenes Apex ist dort nicht vorgesehen. Für kleinere Editionen ist der Ordner-Weg mit KI-Erkennung meist die schnellere Lösung. Prüfen Sie außerdem, wo Ihre Rechnungen liegen: Salesforce Billing und Revenue Cloud bringen eigene Rechnungsobjekte mit, sonst ist es meist Order oder ein Custom Object.

    Welche Salesforce-Limits sind relevant?

    +

    Callouts dürfen höchstens 120 Sekunden dauern, Base64-PDFs belasten den Heap (6 MB synchron, 12 MB asynchron), und nach einem Datenbankschreibvorgang ist in derselben Transaktion kein Callout erlaubt. Deshalb läuft der Aufruf in einer Queueable-Klasse. Für große Mengen eignet sich Batch Apex oder eine Middleware.

    Was passiert, wenn eine Rechnung nicht valide ist?

    +

    Die API liefert die Fehlerliste mit Regel-ID zurück, etwa BR-DE-15 bei fehlender Käuferreferenz. Diese Liste schreiben Sie in ein Feld am Rechnungsdatensatz, damit der Vertrieb oder die Buchhaltung die Daten direkt in Salesforce korrigiert.

    Salesforce E-Rechnungs-ready machen

    Testen Sie die API mit Ihren Salesforce-Daten oder sprechen Sie mit uns über Mapping, Template und die fachliche Integrationsbegleitung.

    API-DokumentationKostenloses Gespräch buchen

    Technische Fragen: support@rechnungsapi.de

    Stefan Grimm

    Stefan Grimm

    Stefan Grimm ist Gründer der Finbc GmbH und arbeitet seit 1999 an Zahlungs- und Rechnungsprozessen, seit 2021 an der E-Rechnung — unter anderem in einem EU-weiten E-Rechnungsprogramm eines Bankkonzerns. Mehr über den Autor

    Verwandte Artikel

    Integration

    E-Rechnung per Ordner: PDF hineinlegen, ZUGFeRD kommt heraus – Nextcloud & WebDAV Integration

    Artikel lesen
    Integration

    Stripe + E-Rechnung: ZUGFeRD und XRechnung automatisch nach Zahlung erzeugen

    Artikel lesen
    Integration

    E-Rechnung für Shopify und WooCommerce: ZUGFeRD & XRechnung automatisch per Webhook

    Artikel lesen
    rechnungsapi.de

    Professionelle E-Rechnungs-APIs für KMUs. Transformieren Sie Ihr ERP-System mit ZUGFeRD-konformen Lösungen und DSGVO-konformer KI-Technologie.

    DSGVO-konform & sicher

    Produkt

    • Preise
    • XRechnung API
    • ZUGFeRD API
    • PDF zu ZUGFeRD
    • PDF zu JSON
    • Ordner-Workflow
    • Peppol
    • XRechnung 4.0
    • Validator
    • XML-Viewer
    • Kontakt

    Lösungen

    • Steuerberater & Kanzleien
    • Unternehmen & Mittelstand
    • IT-Teams & Softwareanbieter
    • E-Invoicing-Berater & Partner
    • Startups & SaaS
    • International & Peppol

    Rechtliches

    • Über uns / Stefan Grimm
    • Impressum
    • AGB / Datenschutzerklärung
    • AVV / TOM
    • Unterauftragsverarbeiter
    • Nutzungsbedingungen
    • DSGVO-Konformität

    Server in Deutschland · DSGVO-konform · Auftragsverarbeiter ISO/IEC 27001-zertifiziert (Open Telekom Cloud)

    rechnungsapi.de ist ein Produkt der Finbc GmbH, Essenheim (gegründet 2018).

    © 2026 rechnungsapi.de

    support@rechnungsapi.de