> Kontinuierliche Prozessverbesserung > Zahlungsabwicklung > SWIFT > Daten Template

Ihr Daten-Template für die Zahlungsabwicklung

SWIFT

← Zurück zum Leitfaden zur Prozessverbesserung

Attribute der Zahlungsabwicklung (19) Aktivitäten der Zahlungsabwicklung (12) Anleitungen zur Datenextraktion (3)

Ihr Daten-Template für die Zahlungsabwicklung

Dieses Template bildet die strukturelle Grundlage, um Ihre SWIFT-Transaktions-Workflows vom Start bis zur endgültigen Abwicklung abzubilden. Es beschreibt die benötigten Datenkomponenten und operativen Meilensteine, damit Sie den gesamten Zahlungslebenszyklus nachvollziehen können. Mit diesem Leitfaden bereiten Sie Ihre Daten gezielt auf, um verborgene Ineffizienzen aufzudecken und Compliance-Risiken zu senken.

Empfohlene Attribute für eine detaillierte Transaktionsanalyse
Zentrale Aktivitäten und Meilensteine im SWIFT-Prozess
Technische Hinweise zur Extraktion von Finanzdaten

Neu bei Event Logs? Erfahren Sie, wie Sie ein Event Log für Process Mining erstellen.

Template herunterladen

Attribute der Zahlungsabwicklung

Diese Datenfelder sollten Sie in Ihr Event Log aufnehmen, um den gesamten SWIFT-Transaktionslebenszyklus umfassend zu analysieren.

5 Erforderlich 9 Empfohlen 5 Optional

	Name	Beschreibung
	Aktivitätsname ActivityName	Der Name des ausgeführten Prozessschritts oder eingetretenen Ereignisses.
Beschreibung Dieses Attribut beschreibt die konkrete Aktion oder Statusänderung, die im Systemprotokoll erfasst wurde. Beispiele sind „Zahlungsauftrag erstellt“, „Sanktionsprüfung bestanden“ oder „SWIFT-ACK empfangen“. Es ist die wichtigste Dimension für Prozessübersichten: Sie legt die Knoten der Visualisierung fest und hilft Analysten, die Abfolge der Zahlungsschritte nachzuvollziehen. Warum das wichtig ist Das Attribut beschreibt, was im Prozess geschieht, und ermöglicht die Visualisierung des Prozessablaufs und seiner Varianten. Woher beziehen Transaktionsprotokolle, Prüfpfade oder aus Nachrichtentypen abgeleitete Angaben, zum Beispiel „MT103 gesendet“. Beispiele Zahlungsauftrag erstelltZahlungsanweisung gesendetSWIFT-ACK empfangenZahlung genehmigt
	Ereignis-Timestamp EventTimestamp	Das genaue Datum und die Uhrzeit des Ereignisses.
Beschreibung Dieses Attribut erfasst den genauen Zeitpunkt eines Ereignisses. Es dient dazu, Aktivitäten chronologisch anzuordnen und alle zeitbezogenen Kennzahlen zu berechnen, etwa Durchlaufzeiten, Zykluszeiten und Durchsatz. Genaue Timestamps sind entscheidend für die Analyse der „Einhaltung von Annahmeschlusszeiten im Netzwerk“ und die Erkennung von Engpässen in der Autorisierungskette. Warum das wichtig ist Timestamps bilden die Grundlage für alle zeitbezogenen Analysen und Leistungskennzahlen im Process Mining. Woher beziehen Systemprüfprotokolle, Timestamps der Nachrichtenerstellung oder Transaktionszeiten aus der Datenbank. Beispiele 2023-10-25T08:30:15Z2023-10-25T14:45:00Z2023-10-26T09:15:22Z
	Letzte Datenaktualisierung LastDataUpdate	Der Timestamp, zu dem der Datensatz zuletzt extrahiert oder aktualisiert wurde.
Beschreibung Gibt an, wann die Daten zuletzt in das Process-Mining-Tool geladen wurden. So lässt sich die Aktualität der Daten beurteilen und sicherstellen, dass die Dashboards den neuesten Stand des Zahlungsbetriebs zeigen. Die Angabe zur Verzögerung der Berichtsdaten schafft Transparenz und stärkt das Vertrauen der Benutzer in die Daten. Warum das wichtig ist Stellt sicher, dass Benutzer die Aktualität und Zuverlässigkeit der angezeigten Daten einschätzen können. Woher beziehen Timestamp der ETL-Prozessausführung. Beispiele 2023-10-27T12:00:00Z2023-11-01T06:00:00Z
	Payment Transaction ID PaymentTransactionId	Die eindeutige Kennung für den durchgängigen Zahlungsfall.
Beschreibung Dieses Attribut dient als zentraler Case-Schlüssel für Process Mining. Es fasst alle Aktivitäten zu einer einzelnen Zahlungsanweisung zusammen, von der ersten Anforderung über die Validierung und SWIFT-Übermittlung bis zur endgültigen Abwicklung. Im SWIFT-Kontext wird dafür häufig die Transaction Reference Number (TRN) oder die Unique End-to-end Transaction Reference (UETR) verwendet, damit die Zahlung über verschiedene Bankensysteme hinweg eindeutig zugeordnet werden kann. Die Kennung dient dazu, den Ablauf einer Prozessinstanz zu rekonstruieren. Sie ist außerdem für alle Variantenanalysen und Berechnungen der Zykluszeit erforderlich. Warum das wichtig ist Eine eindeutige Kennung bildet die Grundlage für Process Mining. Sie ermöglicht es, verstreute Ereignisse zu einem zusammenhängenden Prozessbild zusammenzuführen. Woher beziehen SWIFT-Feld 20 (TRN) oder Feld 121 (UETR) in den Nachrichtenkopfzeilen. Beispiele TRN-20231025-883954392-882-101UETR-9982-1123-5521PAY-US-EU-9912
	Quellsystem SourceSystem	Der Name des Systems, aus dem die Ereignisdaten stammen.
Beschreibung Gibt an, welche Software oder Plattform das Event Log erstellt hat. In einem Zahlungsprozess kann dies das Kernbankensystem, das Payment Gateway oder direkt die SWIFT-Schnittstelle sein. Dieses Attribut hilft dabei, die Datenherkunft nachzuvollziehen und Probleme zu untersuchen, wenn Daten aus verschiedenen Bankanwendungen zusammengeführt werden. Warum das wichtig ist Gibt Auskunft über die Datenherkunft und ist für Process Mining über mehrere Systeme hinweg unverzichtbar. Woher beziehen Während des ETL-Prozesses fest hinterlegt oder aus Systemkennungen ausgelesen. Beispiele SWIFT Alliance AccessCore Banking SystemPayment EngineSanktionsfilter
	BIC der Empfängerbank BeneficiaryBic	Der Bank Identifier Code des empfangenden Instituts.
Beschreibung Gibt die Zielbank der Zahlung an. Diese Dimension ist für das Dashboard „Ursachen für Ablehnungen durch die Empfängerbank“ entscheidend. Werden Ablehnungen nach dem BIC der Empfängerbank gruppiert, kann die Bank bestimmte Gegenparteien ermitteln, die Zahlungsanweisungen häufig aufgrund von Datenqualitätsproblemen oder besonderen Formatvorgaben zurückweisen. Warum das wichtig ist Wichtig für die Analyse der Gegenparteienleistung und von Ablehnungsmustern. Woher beziehen SWIFT-Feld 57A (Konto bei Institut) oder 58A (Begünstigtes Institut). Beispiele CITIUS33BARCGB22DRESDEFFHANDSEXX
	STP IsStp	Kennzeichnet, ob die Zahlung ohne manuelle Eingriffe verarbeitet wurde.
Beschreibung Ein boolesches Kennzeichen mit dem Wert True, wenn der Case keine Aktivitäten wie „Fehler erkannt“, „Zahlung abgelehnt“ oder eine manuelle „Änderung“ enthält. Daraus wird direkt die KPI „Quote der Straight-Through-Verarbeitung“ berechnet. Sie ist die wichtigste Kennzahl für den Automatisierungserfolg in der Zahlungsabwicklung. Warum das wichtig ist Die wichtigste Kennzahl für Prozesseffizienz und den Zustand der Automatisierung. Woher beziehen Berechnet anhand des Fehlens bestimmter negativer oder manueller Aktivitäten im Case. Beispiele truefalse
	SWIFT-Nachrichtentyp SwiftMessageType	Der verwendete SWIFT-Nachrichtentyp, zum Beispiel MT103 oder pacs.008.
Beschreibung Gibt das Format der Zahlungsanweisung an. Zu den gängigen Typen zählen MT103 für Kundenzahlungen und die entsprechenden ISO-20022-Formate wie pacs.008. Wird in der „Variantenanalyse des Zahlungswegs“ verwendet, um die Verarbeitungseffizienz älterer MT-Formate mit den neuen ISO-Standards zu vergleichen. Warum das wichtig ist Unterscheidet Zahlungsabläufe und Verarbeitungsstandards (Legacy und ISO 20022). Woher beziehen SWIFT-Block 2 (Anwendungsheader), Feld „Nachrichtentyp“. Beispiele MT103MT202pacs.008MT101
	SWIFT-NAK-Code SwiftNakCode	Der Fehlercode, den das SWIFT-Netzwerk zurückgibt, wenn eine Nachricht abgelehnt wird.
Beschreibung Enthält den konkreten Fehlercode, zum Beispiel T26 oder T13, aus einer negativen Bestätigung (NAK) des SWIFT-Netzwerks. Dieses Attribut bildet die Grundlage für das Dashboard „SWIFT-Fehler- und Nacharbeitsanalyse“. Damit lassen sich technische Fehler kategorisieren und Systemkorrekturen priorisieren. Warum das wichtig ist Liefert technische Ursachen für Ablehnungen auf Netzwerkebene. Woher beziehen MT-015/019-Systemnachrichten oder Feld 451 in ACK/NAK. Beispiele T26H01T13G02
	Transaktionsbetrag TransactionAmount	Der Geldbetrag der Zahlungsanweisung.
Beschreibung Gibt den zu überweisenden Hauptbetrag an. Die Daten werden aus bestimmten SWIFT-Feldern ausgelesen, zum Beispiel aus Feld 32A in MT103. Das Attribut ist wichtig für das Dashboard „Autorisierungszyklen bei Überweisungen mit hohem Betrag“. Damit lassen sich Zahlungen nach Betrag segmentieren und Verzögerungen bei der Autorisierung risikoreicher Transaktionen mit hohem Wert analysieren. Warum das wichtig ist Ermöglicht die Analyse finanzieller Auswirkungen und die Segmentierung nach Transaktionsbetrag. Woher beziehen SWIFT-MT-Feld 32A (Betrag) oder ISO-20022-Element IntrBkSttlmAmt. Beispiele 15000.001250.501000000.0045.00
	Transaktionswährung TransactionCurrency	Der dreistellige ISO-Code der Zahlungswährung.
Beschreibung Gibt an, in welcher Währung die Zahlung erfolgt, zum Beispiel USD, EUR oder GBP. Diese Angabe ist für das Dashboard „Leistung nach Netzwerk-Cut-off-Zeit“ entscheidend, da die Cut-off-Zeiten je nach Währung variieren. Außerdem unterstützt sie die Analyse „Effizienz der Währungsumrechnung“, indem sie Währungspaare mit unterschiedlichen Währungen kennzeichnet. Warum das wichtig ist Bestimmt Routing-Regeln, Cut-off-Zeiten und Abwicklungskorridore. Woher beziehen SWIFT-MT-Feld 32A (Währung) oder ISO-20022-Element Ccy. Beispiele USDEURGBPJPY
	UETR UniqueEndToEndReference	Die eindeutige End-to-End-Transaktionsreferenz zur Nachverfolgung in SWIFT gpi.
Beschreibung Die UETR ist eine 36 Zeichen lange Zeichenfolge, die eine eindeutige, unveränderliche Referenz für eine Zahlung im gesamten SWIFT-Netzwerk bereitstellt. Anders als interne IDs bleibt die UETR über Bankgrenzen hinweg bestehen. Dieses Attribut ist entscheidend für die durchgängige Transparenz und dafür, interne Protokolle mit externen Statusmeldungen von SWIFT gpi abzugleichen. Warum das wichtig ist Der Goldstandard für die Nachverfolgung grenzüberschreitender Zahlungen zwischen verschiedenen Instituten. Woher beziehen SWIFT-Block 3, Feld 121. Beispiele b8c3f4a0-5d2a-4e1b-9c3d-1a2b3c4d5e6f123e4567-e89b-12d3-a456-426614174000
	Valutadatum ValueDate	Das Datum, an dem die Gelder dem Begünstigten zur Verfügung stehen sollen.
Beschreibung Gibt das in der Zahlungsnachricht angegebene Abwicklungsdatum an. Ein Vergleich mit dem tatsächlichen Timestamp von „Zahlung abgewickelt“ unterstützt das Dashboard „Alter von Abwicklung und Abstimmung“. Das Datum zeigt die Dringlichkeit der Zahlung an und dient dazu, die Einhaltung von Service-Level-Vereinbarungen zur Verfügbarkeit der Gelder zu messen. Warum das wichtig ist Entscheidend für das Liquiditätsmanagement und die Messung der fristgerechten Abwicklung. Woher beziehen SWIFT-MT-Feld 32A (Datumsunterfeld) oder ISO 20022 IntrBkSttlmDt. Beispiele 2023-10-262023-11-01
	Verarbeitender Benutzer ProcessingUser	Der Benutzer oder Systemagent, der die Aktivität ausgeführt hat.
Beschreibung Gibt an, welche Person oder welcher automatisierte Bot für die Aktivität verantwortlich war, etwa ein Compliance-Beauftragter, der einen Sanktionshinweis freigibt, oder ein Sachbearbeiter, der einen Formatierungsfehler behebt. Dieses Attribut bildet die Grundlage für die „Heatmap zu Validierungsfehlern“. So können Führungskräfte Schulungsbedarf erkennen und feststellen, welche Benutzer mit hohen Nacharbeitsquoten verbunden sind. Warum das wichtig ist Ermöglicht die Ressourcenanalyse und die Ermittlung manueller Engpässe. Woher beziehen System-Auditprotokolle, Spalte „User ID“ in Transaktionstabellen. Beispiele SYSTEMJ.DoeCompliance_Bot_01M.Smith
	Ablehnungsgrund RejectionReason	Textbeschreibung des Grundes für die Ablehnung einer Zahlung.
Beschreibung Enthält eine Beschreibung oder einen Code, der den Fehler einer Zahlung erläutert. Diese Angaben finden sich üblicherweise in SWIFT-Feld 72 (Informationen vom Absender an den Empfänger) oder in Rücknachrichten. Sie unterstützen die Analyse „Ursachen für Ablehnungen durch die Empfängerbank“. Analysten können den Text auswerten, um häufige Ablehnungsgründe zu ermitteln, zum Beispiel „Ungültiges Konto“ oder „Name des Begünstigten stimmt nicht überein“. Warum das wichtig ist Liefert qualitative Informationen zu Prozessfehlern. Woher beziehen SWIFT-Feld 72 oder 79 in Rücknachrichten (MT103 Return). Beispiele Konto des Begünstigten geschlossenUngültige IBANCompliance-Vorgaben nicht erfülltBankkennung unbekannt
	Cut-off-Zeit eingehalten MetCutOffTime	Kennzeichnet, ob die Zahlungsanweisung vor dem Netzwerk-Cut-off gesendet wurde.
Beschreibung Ein boolesches Kennzeichen, das durch den Vergleich des Sendezeitpunkts von „Zahlungsanweisung gesendet“ mit der währungsspezifischen Cut-off-Zeit des SWIFT-Netzwerks berechnet wird. Es unterstützt die KPI „Einhaltungsquote der SWIFT-Cut-off-Zeit“. Wird die Cut-off-Zeit verpasst, verzögert sich die Abwicklung und die Liquiditätsposition kann beeinträchtigt werden. Warum das wichtig ist Eine wichtige operative KPI für Treasury und Liquiditätsmanagement. Woher beziehen Berechnet durch den Vergleich des Timestamps mit einer statischen Referenztabelle der Cut-off-Zeiten. Beispiele truefalse
	Grenzüberschreitend IsCrossBorder	Kennzeichnet, ob die Zahlung Ländergrenzen überschreitet.
Beschreibung Ein boolesches Attribut, das den Wert True hat, wenn sich das Land des Absenders vom Land des Begünstigten unterscheidet. Damit unterstützt es die KPI „Latenz bei der Abwicklung mehrerer Währungen“, indem es inländische und internationale Zahlungsabläufe voneinander trennt. Grenzüberschreitende Zahlungen sind in der Regel komplexer, teurer und zeitaufwendiger. Warum das wichtig ist Grundlegende Segmentierung für die Analyse der Zahlungskomplexität. Woher beziehen Vergleich des Ländercodes im Sender-BIC mit dem Ländercode im BIC der Empfängerbank. Beispiele truefalse
	Herkunftsland OriginatingCountry	Der Ländercode der Stelle, die die Zahlung veranlasst.
Beschreibung Gibt das Land an, aus dem der Zahlungsauftrag stammt. Diese Angabe ist für das Dashboard „Durchlaufzeit der Sanktionsprüfung“ wichtig, da Zahlungen aus Ländern mit hohem Risiko häufig gründlicher und länger geprüft werden. Sie ermöglicht die geografische Analyse von Zahlungsvolumen und Verarbeitungsverzögerungen. Warum das wichtig ist Wichtige Dimension für die Analyse von Compliance-Risiken und regionaler Leistung. Woher beziehen Abgeleitet aus dem Sender-BIC (Zeichen 5–6 des Ländercodes). Beispiele USGBDEFR
	Priorität der Zahlungsanweisung InstructionPriority	Kennzeichnet die Dringlichkeit der Zahlung.
Beschreibung Wird aus den Nachrichtenheadern abgeleitet, zum Beispiel „Normal“ oder „Dringend“. Im Dashboard „Freigabezyklen für Überweisungen mit hohem Wert“ lassen sich Zahlungen danach segmentieren, da dringende Zahlungen häufig schneller freigegeben werden müssen. Die Verteilung der Prioritäten hilft bei der Ressourcenplanung für Spitzenzeiten. Warum das wichtig ist Hilft, SLA-Anforderungen für Standardzahlungen und beschleunigte Zahlungen zu unterscheiden. Woher beziehen SWIFT-Block 2, Feld „Nachrichtenpriorität“ (z. B. N für Normal, U für Dringend). Beispiele NormalDringendSystem

Erforderlich Empfohlen Optional

Aktivitäten der Zahlungsabwicklung

Diese zentralen Prozessschritte und Meilensteine sollten Sie in Ihrem Event Log erfassen, um den Prozess präzise zu entdecken und Engpässe zu identifizieren.

6 Empfohlen 6 Optional

	Aktivität	Beschreibung
	Sanktionsprüfung bestanden	Timestamp, zu dem der Zahlungsauftrag die OFAC- beziehungsweise Sanktionslistenprüfung erfolgreich durchläuft. Wird direkt aus den Protokollen des Compliance-Systems erfasst oder daran erkannt, dass der Status „Prüfung ausstehend“ aufgehoben wird.
Warum das wichtig ist Entscheidend für das Dashboard „Durchlaufzeit der Sanktionsprüfung“. Verzögerungen an dieser Stelle weisen auf Engpässe bei Compliance-Prüfungen hin, nicht auf operative Ineffizienz. Woher beziehen Protokolle des Compliance-Filtersystems oder Compliance-Statuskennzeichen im Payment Hub. Erfassung Erfasst, wenn der Prüfungsstatus aktualisiert wird Ereignistyp explicit
	Zahlung abgeglichen	Die Zahlungstransaktion wird mit dem Kontoauszug des Nostro- oder Vostro-Kontos abgeglichen. Dies lässt sich daran erkennen, dass das Abstimmungssystem die Transaktions-ID mit einer Kontoauszugsposition verknüpft.
Warum das wichtig ist Schließt den finanziellen Vorgang ab. Verzögerungen beeinträchtigen die Liquiditätstransparenz und die Auditfähigkeit. Woher beziehen Protokolle des Abstimmungssystems oder Status „Abgeglichen“ im Core Banking System. Erfassung Abstimmungsstatus vergleichen Ereignistyp inferred
	Zahlung abgewickelt	Bestätigung, dass der Betrag dem Konto des Begünstigten gutgeschrieben wurde, häufig mit dem gpi-Status ACSC. Wird direkt über Tracker-Aktualisierungen oder Bestätigungsnachrichten erfasst.
Warum das wichtig ist Kennzeichnet den erfolgreichen Abschluss der Zahlungskette. Wichtig für die Berechnung des „Abstands zwischen Abwicklung und Abstimmung“. Woher beziehen SWIFT-gpi-Tracker (Status ACSC) oder MT900-/910-Bestätigungen. Erfassung Erfasst, wenn die Abwicklung bestätigt wird Ereignistyp explicit
	Zahlung genehmigt	Die abschließende Autorisierung durch eine zuständige Person oder eine automatisierte Regel für Überweisungen mit hohem Betrag. Wird direkt erfasst, wenn das Kennzeichen des Freigabe-Workflows auf „true“ gesetzt wird.
Warum das wichtig ist Wichtig für das Dashboard „Autorisierungszyklen bei Überweisungen mit hohem Betrag“. Zeigt Verzögerungen bei manuellen Freigaben großer Liquiditätstransfers. Woher beziehen Prüfpfad des Freigabe-Workflow-Systems. Erfassung Erfasst, wenn die Freigabe ausgeführt wird Ereignistyp explicit
	Zahlungsanweisung gesendet	Die formatierte Nachricht (MT103 oder ISO 20022 pacs.008) wird an das SWIFT-Gateway übermittelt. Dieser Schritt wird direkt erfasst, wenn die Nachricht erstellt und an die Netzwerkschnittstelle übergeben wird.
Warum das wichtig ist Dient zur Berechnung der „Einhaltungsquote der SWIFT-Annahmeschlusszeiten“. Kennzeichnet den Übergang von der internen Verarbeitung zur Verarbeitung im Netzwerk. Woher beziehen Protokolle von SWIFT Alliance Access (SAA) oder Übertragungsprotokolle des Gateways. Erfassung Erfasst, wenn die Nachricht ausgegeben wird Ereignistyp explicit
	Zahlungsauftrag erstellt	Der Zahlungsauftrag wird erstmals im internen Bankensystem oder ERP-System angelegt. Dieser Schritt wird ausdrücklich erfasst, sobald dem Auftrag eine eindeutige Transaktionsreferenz (TRN oder UETR) zugewiesen wird.
Warum das wichtig ist Legt den Startzeitpunkt des gesamten Zahlungslebenszyklus fest. Unverzichtbar für die Berechnung der durchgängigen Verarbeitungszeit und die Erkennung vorgelagerter Verzögerungen, bevor das SWIFT-Netzwerk einbezogen wird. Woher beziehen Timestamp der Tabellenerstellung im Core Banking System (CBS) oder Payment Hub. Erfassung Erfasst, wenn der Transaktionsdatensatz erstellt wird Ereignistyp explicit
	SWIFT-ACK empfangen	Eine technische Empfangsbestätigung (ACK) des SWIFT-Netzwerks bestätigt, dass die Nachricht zur Verarbeitung angenommen wurde. Wird direkt aus den Protokollen der Netzwerkschnittstelle erfasst.
Warum das wichtig ist Bestätigt, dass die Nachricht erfolgreich in das globale Netzwerk gelangt ist. Unterscheidet interne Fehler von Problemen bei der Übermittlung über das Netzwerk. Woher beziehen Protokolle des SWIFT-Gateways, insbesondere ACK- und NACK-Signale. Erfassung Erfasst, wenn das Netzwerk-ACK eingeht Ereignistyp explicit
	Zahlung weitergeleitet	Eine Zwischenstatusmeldung, häufig der gpi-Status ACSP, zeigt an, dass eine zwischengeschaltete Bank die Zahlung verarbeitet. Der Status wird über Aktualisierungen des SWIFT-gpi-Trackers oder Statusmeldungen erfasst.
Warum das wichtig ist Macht den Ablauf bei Korrespondenzbanken transparent. Unverzichtbar für die Analyse des gesamten Zahlungswegs von Anfang bis Ende. Woher beziehen Datenfeeds des SWIFT-gpi-Trackers oder MT199-/trck-Nachrichten. Erfassung Erfasst, wenn eine Aktualisierung des Trackers eingeht Ereignistyp explicit
	Zahlung zurückgewiesen	Eine Empfänger- oder zwischengeschaltete Bank sendet eine Rückweisungsnachricht (MT103 Return oder gpi-Status RJCT). Wird direkt aus eingehenden SWIFT-Nachrichten erfasst.
Warum das wichtig ist Entscheidend für das Dashboard „Ursachen für Rückweisungen durch Begünstigte“. Zeigt externe Hindernisse wie geschlossene Konten oder fehlerhafte Weiterleitungsdaten. Woher beziehen Eingehende SWIFT-Nachrichten (MT103 RET, pacs.004) oder gpi-Status RJCT. Erfassung Erfasst, wenn eine Rückweisungsnachricht eingeht Ereignistyp explicit
	Zahlungsdetails validiert	Die Syntax- und Formatprüfungen des Zahlungsauftrags wurden erfolgreich abgeschlossen, zum Beispiel die Prüfung des IBAN-Formats und der BIC-Gültigkeit. Dieser Schritt lässt sich häufig daran erkennen, dass sich der Transaktionsstatus von „Entwurf“ zu „Validiert“ oder „Zur Autorisierung bereit“ ändert.
Warum das wichtig ist Eine hohe Fehlerquote weist hier auf eine schlechte Datenqualität an der Quelle hin. Dient zur Messung der Kennzahl „Erfolgsquote der Validierung beim ersten Durchlauf“. Woher beziehen Statusprotokolle des Payment Engine oder Tabellen mit dem Validierungsverlauf. Erfassung Statusfeld vorher und nachher vergleichen Ereignistyp inferred
	Zahlungsfehler behoben	Eine zuvor fehlerhafte Transaktion wurde erfolgreich geändert und erneut übermittelt. Dies lässt sich daran erkennen, dass die Transaktion aus der Warteschlange für „Reparatur“ wieder in den Status „In Bearbeitung“ oder „Bereit“ wechselt.
Warum das wichtig ist Misst die Effizienz des Teams für manuelle Nachbearbeitung. Lange Bearbeitungszeiten weisen auf Schulungsbedarf oder komplexe Fehlercodes hin. Woher beziehen Statusprotokolle des Payment Hub, die den Austritt aus Warteschlangen für Ausnahmefälle zeigen. Erfassung Prüfen, ob das Statusfeld den Austritt aus der Reparaturwarteschlange anzeigt Ereignistyp inferred
	Zahlungsfehler erkannt	Eine Transaktion wird aufgrund fehlgeschlagener Validierungen, NACKs oder Rückweisungsnachrichten zur Korrektur markiert. Dies lässt sich daran erkennen, dass die Transaktion in eine Warteschlange für „Reparatur“, „Korrektur“ oder „Ausnahmefälle“ gelangt.
Warum das wichtig ist Erfasst die „Nacharbeitsquote bei der Fehlerbehebung“. Häufige Fehler an dieser Stelle senken die STP-Quote deutlich. Woher beziehen Statusspalten im Payment Hub oder Protokolle der Warteschlange für Ausnahmefälle. Erfassung Prüfen, ob das Statusfeld „Fehler“ oder „Reparatur“ anzeigt Ereignistyp inferred

Anleitungen zur Datenextraktion

So exportieren Sie Ihre Daten aus SWIFT

Schritte

Melden Sie sich mit einem Administratorkonto, das Zugriff auf die Archivierungskonfiguration hat, bei der SWIFT Alliance WebPlatform oder der Alliance Access GUI an.
Öffnen Sie das Menü System Management, wählen Sie Archiving und anschließend Automated Archiving Configuration.
Richten Sie ein neues Profil für den täglichen Export ein. Legen Sie als Target Directory einen sicheren Netzwerkpfad fest, auf den Ihre Extraktionsskripte zugreifen können.
Legen Sie den Content Scope fest: Wählen Sie „Messages“ und aktivieren Sie „Include History“ sowie „Include Interventions“. So werden Audit-Trail-Ereignisse wie Freigaben und Validierungen erfasst.
Wählen Sie das Ausgabeformat. Verwenden Sie XML, vorzugsweise „SAA XML v2“ oder das neueste verfügbare Schema. XML bildet die hierarchische Beziehung zwischen Nachrichtenkopf und Verlaufsereignissen besser ab als CSV.
Legen Sie mit den Filtern für den Datumsbereich den benötigten historischen Zeitraum für das Process-Mining-Vorhaben fest oder richten Sie einen täglichen Export der Daten von T-1 ein.
Starten Sie den Archivexport für den ersten Datenimport manuell oder warten Sie, bis der geplante Batch-Job abgeschlossen ist. Prüfen Sie, ob die .xml-Dateien im Zielverzeichnis erstellt wurden.
Da der SAA-Export eine hierarchische XML-Datei ist und ProcessMind ein flaches CSV-Event-Log benötigt, müssen Sie die Daten mit einem Skript transformieren. Verwenden Sie das im Abschnitt Query bereitgestellte Python-Skript, um die XML-Datei auszulesen.
Das Skript durchläuft alle Nachrichtenelemente. Es verwendet die eindeutige End-to-End-Transaktionsreferenz (UETR) oder die Transaktionsreferenznummer (TRN) als Case-ID.
Anschließend durchläuft das Skript die untergeordneten Knoten „History“ und „Intervention“ jeder Nachricht und erstellt daraus Aktivitätszeilen. Interne SAA-Statuscodes wie „NetworkAck“ und „Authorisation“ werden standardisierten Aktivitätsnamen zugeordnet.
Führen Sie das Python-Skript für Ihre exportierten XML-Dateien aus, um die flache Datei „events.csv“ zu erstellen.
Prüfen Sie die CSV-Ausgabe. Achten Sie darauf, dass Spalten wie EventTimestamp dem ISO-8601-Format entsprechen. Laden Sie die Datei anschließend in ProcessMind hoch.

Konfiguration

Archivformat: XML (empfohlen) oder CSV (flache Datei). XML wird dringend empfohlen, damit verschachtelte Verlaufsdaten erfasst werden.
Nachrichtentext einschließen: Ja (erforderlich, um Betrag, Währung und Angaben zum Zahlungsempfänger auszulesen).
Verlauf und Interventionen einschließen: Ja (erforderlich, um Freigaben, Validierungen und Fehler zu erfassen).
Datumsbereich: Legen Sie für inkrementelle Datenimporte einen rollierenden Zeitraum fest, zum Beispiel die letzten 30 Tage. Für den ersten Import können Sie einen festen Zeitraum wählen.
Nachrichtentypen: Filtern Sie nach MT103, MT202, pacs.008, pacs.009 und pacs.004/002 (für Rückgaben und Statusmeldungen).
Richtung: Berücksichtigen Sie sowohl eingehende Nachrichten (Emission) als auch ausgehende Nachrichten (Reception), um eingehende Ablehnungen und Bestätigungen zu erfassen.
Sicherheit: Beschränken Sie Lese- und Schreibberechtigungen für den Exportordner, da die Dateien aktuelle Zahlungsdaten enthalten.

a Beispielabfrage python

import xml.etree.ElementTree as ET
import pandas as pd
import glob
import os

class=class="hl-string">"hl-comment"># CONFIGURATION
class=class="hl-string">"hl-comment"># Update this path to your SAA XML Export directory
input_folder = class="hl-string">"./saa_exports/"
output_file = class="hl-string">"./swift_process_mining_log.csv"

columns = [
    class="hl-string">"PaymentTransactionId", class="hl-string">"ActivityName", class="hl-string">"EventTimestamp", class="hl-string">"SourceSystem", 
    class="hl-string">"LastDataUpdate", class="hl-string">"TransactionAmount", class="hl-string">"TransactionCurrency", class="hl-string">"UniqueEndToEndReference",
    class="hl-string">"SwiftMessageType", class="hl-string">"ProcessingUser", class="hl-string">"BeneficiaryBic", class="hl-string">"SwiftNakCode", class="hl-string">"ValueDate", class="hl-string">"IsStp"
]

data_rows = []

class=class="hl-string">"hl-comment"># Helper to determine Activity Name based on SAA History Events
def map_activity(history_item_name, status, nature, text_content):
    class=class="hl-string">"hl-comment"># 1. Payment Request Created
    if history_item_name == class="hl-string">"Creation" or history_item_name == class="hl-string">"Reception":
        return class="hl-string">"Payment Request Created"
    
    class=class="hl-string">"hl-comment"># 2. Payment Details Validated
    if class="hl-string">"Validation" in history_item_name and status == class="hl-string">"Success":
        return class="hl-string">"Payment Details Validated"
    
    class=class="hl-string">"hl-comment"># 3. Sanctions Screening Passed
    if class="hl-string">"Filter" in history_item_name and status == class="hl-string">"Passed":
        return class="hl-string">"Sanctions Screening Passed"
    
    class=class="hl-string">"hl-comment"># 4. Payment Approved
    if history_item_name == class="hl-string">"Intervention" and nature == class="hl-string">"Authorization":
        return class="hl-string">"Payment Approved"
    
    class=class="hl-string">"hl-comment"># 5. Payment Instruction Sent
    if history_item_name == class="hl-string">"Transmission" or status == class="hl-string">"Transmitted":
        return class="hl-string">"Payment Instruction Sent"
    
    class=class="hl-string">"hl-comment"># 6. SWIFT ACK Received
    if history_item_name == class="hl-string">"NetworkReport" and class="hl-string">"ACK" in text_content:
        return class="hl-string">"SWIFT ACK Received"

    class=class="hl-string">"hl-comment"># 7. Payment Transferred (gpi status)
    if class="hl-string">"TrackerUpdate" in history_item_name and class="hl-string">"ACSP" in text_content:
        return class="hl-string">"Payment Transferred"

    class=class="hl-string">"hl-comment"># 8. Payment Error Identified
    if nature == class="hl-string">"NAK" or status == class="hl-string">"Failed" or nature == class="hl-string">"RoutingFailure":
        return class="hl-string">"Payment Error Identified"

    class=class="hl-string">"hl-comment"># 9. Payment Error Resolved
    if history_item_name == class="hl-string">"Modification" and nature == class="hl-string">"Repair":
        return class="hl-string">"Payment Error Resolved"
    
    class=class="hl-string">"hl-comment"># 10. Payment Rejected
    if class="hl-string">"TrackerUpdate" in history_item_name and class="hl-string">"RJCT" in text_content:
        return class="hl-string">"Payment Rejected"

    class=class="hl-string">"hl-comment"># 11. Payment Settled
    if class="hl-string">"TrackerUpdate" in history_item_name and class="hl-string">"ACSC" in text_content:
        return class="hl-string">"Payment Settled"

    class=class="hl-string">"hl-comment"># 12. Payment Reconciled
    class=class="hl-string">"hl-comment"># Often external, but if SAA receives a Reconciliation update:
    if history_item_name == class="hl-string">"ReconciliationMatch":
        return class="hl-string">"Payment Reconciled"
        
    return None

class=class="hl-string">"hl-comment"># PROCESS XML FILES
for xml_file in glob.glob(os.path.join(input_folder, class="hl-string">"*.xml")):
    tree = ET.parse(xml_file)
    root = tree.getroot()

    class=class="hl-string">"hl-comment"># Iterate through Messages
    for message in root.findall(class="hl-string">".//Message"):
        class=class="hl-string">"hl-comment"># Header Extraction
        trn = message.findtext(class="hl-string">"TRN")
        uetr = message.findtext(class="hl-string">"UETR")
        case_id = uetr if uetr else trn
        
        class=class="hl-string">"hl-comment"># Skip if no identifier found
        if not case_id: 
            continue

        msg_type = message.findtext(class="hl-string">"Type")
        amount = message.findtext(class="hl-string">"Amount")
        currency = message.findtext(class="hl-string">"Currency")
        val_date = message.findtext(class="hl-string">"ValueDate")
        ben_bic = message.findtext(class="hl-string">"BeneficiaryBIC")
        
        class=class="hl-string">"hl-comment"># Loop through History/Audit Trail for Activities
        for history in message.findall(class="hl-string">".//History/Item"):
            evt_name = history.findtext(class="hl-string">"Name")
            evt_status = history.findtext(class="hl-string">"Status")
            evt_nature = history.findtext(class="hl-string">"Nature")
            evt_text = history.findtext(class="hl-string">"Text") or class="hl-string">""
            evt_user = history.findtext(class="hl-string">"Operator")
            evt_time = history.findtext(class="hl-string">"Time") class=class="hl-string">"hl-comment"># format: YYYYMMDDHHMMSS
            
            activity = map_activity(evt_name, evt_status, evt_nature, evt_text)
            
            if activity:
                class=class="hl-string">"hl-comment"># Determine NAK Code if applicable
                nak_code = None
                if activity == class="hl-string">"Payment Error Identified" and class="hl-string">"NAK" in evt_text:
                    nak_code = evt_text.split(class="hl-string">"Code:")[-1].strip()
                
                class=class="hl-string">"hl-comment"># Determine STP
                is_stp = class="hl-string">"True" if evt_user == class="hl-string">"System" or evt_user == class="hl-string">"Auto" else class="hl-string">"False"

                data_rows.append({
                    class="hl-string">"PaymentTransactionId": case_id,
                    class="hl-string">"ActivityName": activity,
                    class="hl-string">"EventTimestamp": pd.to_datetime(evt_time, format=class="hl-string">'%Y%m%d%H%M%S'),
                    class="hl-string">"SourceSystem": class="hl-string">"SWIFT Alliance Access",
                    class="hl-string">"LastDataUpdate": pd.Timestamp.now(),
                    class="hl-string">"TransactionAmount": amount,
                    class="hl-string">"TransactionCurrency": currency,
                    class="hl-string">"UniqueEndToEndReference": uetr,
                    class="hl-string">"SwiftMessageType": msg_type,
                    class="hl-string">"ProcessingUser": evt_user,
                    class="hl-string">"BeneficiaryBic": ben_bic,
                    class="hl-string">"SwiftNakCode": nak_code,
                    class="hl-string">"ValueDate": val_date,
                    class="hl-string">"IsStp": is_stp
                })

class=class="hl-string">"hl-comment"># OUTPUT GENERATION
df = pd.DataFrame(data_rows, columns=columns)

class=class="hl-string">"hl-comment"># Remove duplicate timestamp/activity pairs for cleaner log
df.drop_duplicates(subset=[class="hl-string">"PaymentTransactionId", class="hl-string">"ActivityName", class="hl-string">"EventTimestamp"], inplace=True)

df.to_csv(output_file, index=False, quoting=1)
print(fclass="hl-string">"Extraction Complete. Processed {len(df)} events into {output_file}")

Schritte

Umgebung vorbereiten: Stellen Sie sicher, dass Python 3.8 oder höher auf dem Extraktionsserver installiert ist. Installieren Sie die erforderlichen Bibliotheken mit pip (pandas, numpy). Erstellen Sie ein eigenes Arbeitsverzeichnis mit einem Unterordner namens raw_swift_files und legen Sie dort alle täglichen .out-, .txt- oder .fin-Dateien ab.
Dateistruktur prüfen: SWIFT-FIN-Rohdaten sind in Blöcken strukturiert ({1: Header} {2: Application} {4: Body}). Ermitteln Sie die Trennzeichen. Standarddateien verwenden geschweifte Klammern. Stellen Sie sicher, dass Ihre Dateien nicht in proprietäre Umschläge wie RJE-Header eingebettet sind, oder entfernen Sie diese vor der Verarbeitung.
Skriptpfade konfigurieren: Öffnen Sie das bereitgestellte Python-Skript. Ändern Sie die Variable INPUT_DIRECTORY so, dass sie auf Ihren Ordner raw_swift_files verweist. Legen Sie außerdem den Pfad für die resultierende CSV-Datei in OUTPUT_FILE fest.
Regex-Muster festlegen: Das Skript verwendet Regex, um die Blöcke zu isolieren. Block 1 enthält den Sender-BIC und die Sequenznummer. Block 2 enthält den Nachrichtentyp, zum Beispiel I103 oder O103, und den Empfänger-BIC. Block 4 enthält die Geschäftsdaten-Tags, zum Beispiel :20: TRN und :32A: Wert/Betrag.
Nachrichtentypen Aktivitäten zuordnen: Das Skript enthält ein Zuordnungswörterbuch. MT103 steht für „Zahlungsanweisung gesendet“. MT012 (System-ACK) steht für „SWIFT-ACK empfangen“. MT900/910 steht für „Zahlung abgewickelt“. MT199/299 mit bestimmten Statuscodes (ACSP, RJCT) wird „Zahlung übertragen“ oder „Zahlung abgelehnt“ zugeordnet.
Attribute extrahieren: Der Parser durchläuft bestimmte Tags. :20: wird der Payment Transaction ID zugeordnet, :121: der UETR. :32A: wird in Datum, Währung und Betrag aufgeteilt.
Interne Status berücksichtigen: Aktivitäten wie „Zahlungsanfrage erstellt“ oder „Zahlung freigegeben“ stammen häufig aus internen ERP-Ereignissen und sind in SWIFT-Dateien nicht enthalten. Wenn keine expliziten Protokolle vorliegen, leitet das Skript diese Aktivitäten aus dem Timestamp der Nachrichtenerstellung in Block 1 ab. Alternativ sucht es in Feld :72: (Informationen vom Sender an den Empfänger) nach bestimmten Textcodes, sofern Ihre Organisation dort Freigaben protokolliert.
Extraktion ausführen: Führen Sie das Skript über die Befehlszeile aus: python swift_parser.py. Es durchläuft alle Dateien, liest gültige SWIFT-Blöcke aus und überspringt fehlerhafte Zeilen.
Ausgabe prüfen: Öffnen Sie die erstellte CSV-Datei. Prüfen Sie das Format von EventTimestamp (ISO 8601 wird empfohlen). Stellen Sie sicher, dass PaymentTransactionId in jeder Zeile ausgefüllt ist, damit die Fälle gruppiert werden können.
Daten transformieren: Wenn „ValueDate“ im Format YYMMDD ausgegeben wird, wandelt das Skript den Wert in YYYY-MM-DD um. Stellen Sie sicher, dass die Dezimaltrennzeichen in „TransactionAmount“ einheitlich sind, also Punkte oder Kommas verwendet werden.
Abschließende Prüfung: Filtern Sie nach einer bestimmten UETR, um den durchgängigen Ablauf von „Zahlungsanweisung gesendet“ über ACK bis zur Abwicklung nachzuvollziehen. Prüfen Sie, ob NAKs (MT019) als „Zahlungsfehler erkannt“ erscheinen.
In ProcessMind hochladen: Importieren Sie die CSV-Datei. Ordnen Sie PaymentTransactionId der Case-ID, ActivityName der Aktivität und EventTimestamp dem Timestamp zu.

Konfiguration

Eingabeverzeichnis: Pfad zum Ordner mit den FIN/MT-Rohdateien. Stellen Sie sicher, dass Leseberechtigungen vorhanden sind.
Datumsformat: SWIFT-Rohdaten verwenden das Format YYMMDD. Das Skript geht dabei von einem Jahrhundert im Format 20xx aus.
Filter für Nachrichtentypen: Das Skript berücksichtigt die Kategorien 1 (Zahlungen) und 9 (Kontoauszüge) sowie gängige Systemnachrichten (012, 019). Ergänzen Sie die Liste RELEVANT_MT_TYPES, wenn Sie Kategorie 2 (Überweisungen zwischen Finanzinstituten) benötigen.
Zeichenkodierung: Standardmäßig wird „utf-8“ verwendet. Ändern Sie die Kodierung in „latin-1“ oder „ascii“, wenn die Dateien Zeichen aus älteren Kodierungen enthalten.
Batch-Verarbeitung: Bei Datensätzen über 1 GB verwendet das Skript einen Generator, um einen Speicherüberlauf zu vermeiden. Die Dateien werden einzeln verarbeitet.
Regex anpassen: Der strenge Regex setzt das Standard-FIN-Format {1:...}{2:...}{4:...} voraus. Wenn Ihre Dateien $ oder andere Trennzeichen verwenden, passen Sie die Variable BLOCK_PATTERN an.

a Beispielabfrage python

import os
import re
import glob
import pandas as pd
from datetime import datetime

class=class="hl-string">"hl-comment"># === CONFIGURATION ===
INPUT_DIRECTORY = class="hl-string">"./raw_swift_files/"
OUTPUT_FILE = class="hl-string">"./extracted_swift_event_log.csv"

class=class="hl-string">"hl-comment"># === REGEX PATTERNS ===
class=class="hl-string">"hl-comment"># Matches standard SWIFT block structure: {1:...}{2:...}{3:...}{4:...}
BLOCK_PATTERN = re.compile(rclass="hl-string">'(\{1:.*?\})(\{2:.*?\})(?:\{3:.*?\})?(\{4:.*?\})', re.DOTALL)

class=class="hl-string">"hl-comment"># Field extractors
TAG_20_TRN = re.compile(rclass="hl-string">':20:([^\r\n]+)')
TAG_121_UETR = re.compile(rclass="hl-string">':121:([a-fA-F0-9\-]+)')
TAG_32A_VAL = re.compile(rclass="hl-string">':32A:(\d{6})([A-Z]{3})([\d,]+)')
TAG_72_INFO = re.compile(rclass="hl-string">':72:([^\r\n]+)')
TAG_57A_BIC = re.compile(rclass="hl-string">':57[A-Z]?:(?:[/]{0,2}[A-Z0-9]+)?\r?\n?([A-Z0-9]{8,11})')

class=class="hl-string">"hl-comment"># Header parsers
BLOCK_1_DATE = re.compile(rclass="hl-string">'\{1:[F|A|L]01[A-Z0-9]{12}(\d{4})(\d{6})')
BLOCK_2_TYPE = re.compile(rclass="hl-string">'\{2:([IO])(\d{3})')

class=class="hl-string">"hl-comment"># === ACTIVITY MAPPING LOGIC ===
def map_message_to_activity(io_direction, mt_type, block4_text):
    class=class="hl-string">"hl-comment"># Outgoing Payments (MT103, MT202)
    if io_direction == class="hl-string">'I' and mt_type in [class="hl-string">'103', class="hl-string">'202']:
        return class="hl-string">"Payment Instruction Sent"
    
    class=class="hl-string">"hl-comment"># Incoming Payments (MT103 received from another bank)
    if io_direction == class="hl-string">'O' and mt_type in [class="hl-string">'103', class="hl-string">'202']:
        return class="hl-string">"Payment Transferred"

    class=class="hl-string">"hl-comment"># System Acknowledgment (MT012)
    if mt_type == class="hl-string">'012':
        return class="hl-string">"SWIFT ACK Received"

    class=class="hl-string">"hl-comment"># System NAK / Abort (MT019)
    if mt_type == class="hl-string">'019':
        return class="hl-string">"Payment Error Identified"

    class=class="hl-string">"hl-comment"># Statements / Confirmation (MT900 Debit, MT910 Credit, MT950)
    if mt_type in [class="hl-string">'900', class="hl-string">'910', class="hl-string">'910', class="hl-string">'950']:
        return class="hl-string">"Payment Settled"
    
    class=class="hl-string">"hl-comment"># Returns (MT103 RETN)
    if mt_type == class="hl-string">'103' and class="hl-string">':23E:RETN' in block4_text:
        return class="hl-string">"Payment Rejected"

    class=class="hl-string">"hl-comment"># GPI Status Updates (MT199)
    if mt_type == class="hl-string">'199':
        if class="hl-string">'/RJCT/' in block4_text:
            return class="hl-string">"Payment Rejected"
        if class="hl-string">'/ACSP/' in block4_text:
            return class="hl-string">"Payment Transferred"
        if class="hl-string">'/ACSC/' in block4_text:
            return class="hl-string">"Payment Settled"
            
    return class="hl-string">"Message Processed"  class=class="hl-string">"hl-comment"># Fallback

def parse_swift_date(yymmdd):
    class=class="hl-string">"hl-comment"># Assumes 20xx for years
    try:
        return datetime.strptime(yymmdd, class="hl-string">'%y%m%d').strftime(class="hl-string">'%Y-%m-%d')
    except ValueError:
        return None

class=class="hl-string">"hl-comment"># === MAIN EXTRACTION ===
def process_files():
    records = []
    files = glob.glob(os.path.join(INPUT_DIRECTORY, class="hl-string">"*"))
    
    print(fclass="hl-string">"Found {len(files)} files to process.")

    for filepath in files:
        try:
            with open(filepath, class="hl-string">'r', encoding=class="hl-string">'utf-8', errors=class="hl-string">'ignore') as f:
                content = f.read()
                
            class=class="hl-string">"hl-comment"># Find all full messages in file
            messages = BLOCK_PATTERN.findall(content)
            
            for b1, b2, b4 in messages:
                class=class="hl-string">"hl-comment"># -- Extract Core IDs --
                trn_match = TAG_20_TRN.search(b4)
                uetr_match = TAG_121_UETR.search(b4)
                
                class=class="hl-string">"hl-comment"># Primary Key preference: UETR > TRN > Generated ID
                uetr = uetr_match.group(1) if uetr_match else None
                trn = trn_match.group(1) if trn_match else class="hl-string">"UNKNOWN"
                case_id = uetr if uetr else trn
                
                if case_id == class="hl-string">"UNKNOWN":
                    continue class=class="hl-string">"hl-comment"># Skip structural noise

                class=class="hl-string">"hl-comment"># -- Extract Metadata --
                type_match = BLOCK_2_TYPE.search(b2)
                io_dir = type_match.group(1) if type_match else class="hl-string">"I"
                mt_type = type_match.group(2) if type_match else class="hl-string">"999"
                
                class=class="hl-string">"hl-comment"># -- Determine Timestamp --
                class=class="hl-string">"hl-comment"># Attempt to find timestamp in Block 1 (Session header)
                class=class="hl-string">"hl-comment"># Format often: {1:F01BANKBEBBXXXX1234123456}
                class=class="hl-string">"hl-comment"># Using current time as fallback if header parsing fails
                timestamp = datetime.now().isoformat()
                date_match = BLOCK_1_DATE.search(b1)
                if date_match:
                    class=class="hl-string">"hl-comment"># YYMMDD + HHMM
                    class=class="hl-string">"hl-comment"># Note: Sequence number often occupies this space, this regex is generic
                    class=class="hl-string">"hl-comment"># For simplicity, we assume file creation time or construct from header
                    pass 
                    
                class=class="hl-string">"hl-comment"># -- Extract Financials --
                amount = None
                currency = None
                val_date = None
                amt_match = TAG_32A_VAL.search(b4)
                if amt_match:
                    val_date_raw, currency, amt_str = amt_match.groups()
                    val_date = parse_swift_date(val_date_raw)
                    amount = float(amt_str.replace(class="hl-string">',', class="hl-string">'.'))

                class=class="hl-string">"hl-comment"># -- Extract Beneficiary --
                ben_bic = None
                ben_match = TAG_57A_BIC.search(b4)
                if ben_match:
                    ben_bic = ben_match.group(1)

                class=class="hl-string">"hl-comment"># -- Map Activity --
                activity = map_message_to_activity(io_dir, mt_type, b4)

                class=class="hl-string">"hl-comment"># -- Create Record --
                record = {
                    class="hl-string">"PaymentTransactionId": case_id,
                    class="hl-string">"ActivityName": activity,
                    class="hl-string">"EventTimestamp": datetime.now().strftime(class="hl-string">"%Y-%m-%d %H:%M:%S"), class=class="hl-string">"hl-comment"># Replace with actual extracted time
                    class="hl-string">"SourceSystem": class="hl-string">"SWIFT_Alliance_Access",
                    class="hl-string">"TransactionAmount": amount,
                    class="hl-string">"TransactionCurrency": currency,
                    class="hl-string">"UniqueEndToEndReference": uetr,
                    class="hl-string">"SwiftMessageType": fclass="hl-string">"MT{mt_type}",
                    class="hl-string">"BeneficiaryBic": ben_bic,
                    class="hl-string">"ValueDate": val_date,
                    class="hl-string">"LastDataUpdate": datetime.now().isoformat()
                }
                
                records.append(record)

                class=class="hl-string">"hl-comment"># -- Derived Logic for class="hl-string">'Created' --
                class=class="hl-string">"hl-comment"># If this is the very first outgoing MT103, we can imply creation
                class=class="hl-string">"hl-comment"># In a real scenario, this logic happens after sorting all events
                if activity == class="hl-string">"Payment Instruction Sent":
                    creation_record = record.copy()
                    creation_record[class="hl-string">"ActivityName"] = class="hl-string">"Payment Request Created"
                    class=class="hl-string">"hl-comment"># Offset time slightly backwards to simulate flow
                    creation_record[class="hl-string">"EventTimestamp"] = class="hl-string">"[Derive from Log Creation Time]"
                    records.append(creation_record)

        except Exception as e:
            print(fclass="hl-string">"Error processing file {filepath}: {e}")

    class=class="hl-string">"hl-comment"># -- Convert to DataFrame --
    df = pd.DataFrame(records)
    
    class=class="hl-string">"hl-comment"># -- Final Cleanup --
    class=class="hl-string">"hl-comment"># Sort by ID and Time to ensure logical order if needed
    if not df.empty:
        df.sort_values(by=[class="hl-string">'PaymentTransactionId', class="hl-string">'EventTimestamp'], inplace=True)
        df.to_csv(OUTPUT_FILE, index=False)
        print(fclass="hl-string">"Extraction complete. Data saved to {OUTPUT_FILE}")
    else:
        print(class="hl-string">"No valid SWIFT messages found.")

if __name__ == class="hl-string">"__main__":
    process_files()

Schritte

Prüfen Sie, ob Ihr Abonnement für die SWIFT gpi Tracker API, die API-Zugangsdaten, die UETR-Suchfunktion und der Zugriff auf die Ereignisquelle des internen Zahlungssystems verfügbar sind. Entnehmen Sie der SWIFT-Service-Dokumentation die genaue API-Basis-URL, Authentifizierungsmethode, das Antwortschema, die Ratenbegrenzungen und die Regeln für die Seitennavigation. Gehen Sie nicht von einem bestimmten Endpunktpfad aus, da dieser vom lizenzierten SWIFT-Service und der Bereitstellung abhängt.
Konfigurieren Sie das Skript mit der erforderlichen Verbindungszeichenfolge, den Zugangsdaten, dem Datumsbereich und den unternehmensspezifischen Filtern. Verwenden Sie für die erste Extraktion einen Zeitraum von drei bis sechs Monaten. Beschränken Sie die Daten aus der internen Quelle auf Zahlungstransaktionen mit TRN oder UETR und speichern Sie für jedes Ereignis den Namen des Quellsystems.
Extrahieren Sie die internen Ereignisse des Lebenszyklus: Zahlungsanfrage erstellt, Zahlungsdetails validiert, Sanktionsprüfung bestanden, Zahlung freigegeben, Zahlungsanweisung gesendet, SWIFT-ACK empfangen, Zahlungsfehler erkannt, Zahlungsfehler behoben, Zahlung abgelehnt, Zahlung abgewickelt und Zahlung abgestimmt. Wandeln Sie jedes Quellereignis in eine eigene Zeile im Event Log um. Verlassen Sie sich nicht darauf, dass ProcessMind Aktivitäten ableitet.
Extrahieren Sie die UETRs aus den internen Zahlungsdatensätzen und fragen Sie die lizenzierte SWIFT gpi Tracker API für jede UETR ab. Konfigurieren Sie Anfrage-URL, Authentifizierungsheader, Anfrageparameter, Seitennavigation und Antwortfelder anhand der API-Dokumentation für Ihre Umgebung. Speichern Sie die Rohantwort für die Auditierbarkeit.
Wandeln Sie die zutreffenden gpi-Tracker-Status in explizite Ereigniszeilen um. Das Skript ordnet ACSP „Zahlung übertragen“, RJCT „Zahlung abgelehnt“ und ACSC „Zahlung abgewickelt“ zu. Wenn Ihre lizenzierte Antwort andere Statusnamen oder Timestamps verwendet, passen Sie die Zuordnung anhand des dokumentierten Antwortschemas an. Erstellen Sie kein Ereignis, wenn die API keinen entsprechenden Statusvorgang liefert.
Vereinheitlichen Sie alle Timestamps auf eine einheitliche Zeitzone, vorzugsweise UTC. Bewahren Sie den ursprünglichen Timestamp auf, wenn dies für Audit-Zwecke erforderlich ist. Wandeln Sie Geldbeträge in numerische Werte um, behalten Sie die Transaktionswährung bei, vereinheitlichen Sie boolesche STP-Werte und lassen Sie Werte NULL, wenn die Quelle kein Attribut bereitstellt.
Entfernen Sie doppelte Ereignisse anhand von PaymentTransactionId, ActivityName, EventTimestamp und der genauesten verfügbaren Quellereignis-ID. Bewahren Sie mehrere legitime Vorkommen, etwa wiederholte Korrektur- und erneute Übermittlungszyklen, sofern die Geschäftsregel nicht ausdrücklich ein Vorkommen pro Aktivität verlangt.
Stellen Sie sicher, dass jede Ausgabezeile PaymentTransactionId, ActivityName, EventTimestamp, SourceSystem und LastDataUpdate enthält. Prüfen Sie, ob ActivityName ausschließlich die dokumentierten Aktivitätswerte enthält und alle 12 Aktivitäten abgebildet sind, sofern sie in den Quelldaten vorkommen.
Exportieren Sie den resultierenden Datensatz als UTF-8-CSV oder in einem anderen von ProcessMind unterstützten Event-Log-Format. Verwenden Sie eine Zeile pro Ereignis, nehmen Sie die erforderlichen und empfohlenen Spalten auf und ordnen Sie PaymentTransactionId der Fall-ID, ActivityName der Aktivität und EventTimestamp dem Ereignis-Timestamp zu. Laden Sie die Datei in ProcessMind hoch, ohne davon auszugehen, dass weitere Ereignisse abgeleitet werden.

Konfiguration

API-Endpunkt und Schema: Konfigurieren Sie die genaue SWIFT gpi Tracker API-Basis-URL, den Ressourcenpfad, die Anfrageparameter, Authentifizierungsheader, Seitennavigation und Antwortfeldnamen anhand der lizenzierten SWIFT-Dokumentation für Ihre Umgebung. Das Skript erfindet absichtlich keinen Endpunkt.
Zugangsdaten und Berechtigungen: Verwenden Sie den genehmigten Mechanismus für SWIFT-API-Zugangsdaten, erforderliche Zertifikate oder Tokens, die vorgesehene Speicherung von Geheimnissen und die Berechtigungen für interne Quellsysteme. Hinterlegen Sie keine Produktionsgeheimnisse direkt im Quellcode.
Datumsbereich: Beginnen Sie mit drei bis sechs Monaten. Verwenden Sie den Ereignis-Timestamp oder das Erstellungsdatum der Zahlung, je nach Berichtsziel. Teilen Sie große Datenmengen in kleinere Zeiträume auf und speichern Sie abgeschlossene UETRs als Checkpoints.
Filter für interne Quellen: Konfigurieren Sie Filter für Unternehmen, Rechtseinheit, Niederlassung, Zahlungsprodukt, Belegart, Nachrichtentyp, Währung und Status entsprechend Ihrem System. Verwenden Sie Platzhalter wie [Configure based on your system], bis das Quellschema bestätigt ist.
Aktivitätszuordnung: Pflegen Sie explizite Zuordnungen für interne Status und Warteschlangen. Beispiele: Draft wird für „Zahlungsdetails validiert“ zu „Validated“ oder „Ready for Auth“; die Freigabe einer Sperre bei der Prüfung wird „Sanktionsprüfung bestanden“ zugeordnet; der Eintritt in eine Reparatur- oder Ausnahme-Warteschlange steht für „Zahlungsfehler erkannt“; die Rückkehr zur Verarbeitung oder zu „Ready for Payment“ für „Zahlungsfehler behoben“.
Zuordnung der gpi-Status: Ordnen Sie dokumentierte Tracker-Status expliziten Aktivitäten zu. Diese Implementierung ordnet ACSP „Zahlung übertragen“, RJCT „Zahlung abgelehnt“ und ACSC „Zahlung abgewickelt“ zu. Erweitern Sie die Zuordnung nur, wenn die lizenzierte API-Dokumentation die Bedeutung des Status bestätigt.
Timestamp-Regeln: Vereinheitlichen Sie Timestamps nach Möglichkeit auf UTC. Legen Sie fest, welcher Wert Vorrang hat: Quellereigniszeit, Tracker-Ereigniszeit, Nachrichtenempfangszeit oder Extraktionszeit. LastDataUpdate muss den Extraktions- oder Aktualisierungszeitpunkt angeben, nicht den Zeitpunkt des Geschäftsereignisses.
Ratenbegrenzungen und Wiederholungen: Konfigurieren Sie Anfrage-Timeout, Anzahl der Wiederholungen, exponentielles Backoff, Behandlung von HTTP-Statuscodes und Seitennavigation. Halten Sie die SWIFT-Service-Limits ein und vermeiden Sie unkontrollierte parallele Anfragen.
Leistung: Zwischenspeichern Sie Antworten nach UETR, verarbeiten Sie UETRs in Stapeln, speichern Sie Checkpoints und verwenden Sie, sofern unterstützt, eine inkrementelle Extraktion. Fragen Sie den Tracker für dieselbe UETR und denselben Datumsbereich nicht wiederholt ab.
Datenqualität: Erforderlich sind PaymentTransactionId, ActivityName, EventTimestamp, SourceSystem und LastDataUpdate. Empfohlene Attribute dürfen NULL sein, wenn die Quelle keine Werte bereitstellt. Erfassen Sie jedoch, wie häufig sie befüllt sind.
Auditierbarkeit: Speichern Sie die rohe API-Antwort, den Anfrage-Timestamp, den Antwortstatus, die UETR und die Kennung des Extraktionslaufs an einem zugelassenen Audit-Speicherort. Halten Sie die für Zahlungsdaten geltenden Aufbewahrungs- und Sicherheitsregeln ein.
Voraussetzungen: Stellen Sie sicher, dass Sie Zugriff auf interne Protokolle zum Zahlungslebenszyklus, zur Compliance, zum SWIFT-Gateway, zum Abgleich und zu Nachrichtenschnittstellen haben. Erforderlich sind außerdem eine Lizenz für die SWIFT gpi Tracker API sowie gegebenenfalls Zertifikate oder eine Freigabe der Netzwerkadressen.

a Beispielabfrage python

import csv
import json
import os
import time
import uuid
from datetime import datetime, timezone
from decimal import Decimal, InvalidOperation
from typing import Any, Dict, Iterable, List, Optional

import requests

class=class="hl-string">"hl-comment"># Replace only the following placeholders with environment-specific values.
SWIFT_API_BASE_URL = class="hl-string">"[SWIFT gpi Tracker API base URL]"
SWIFT_API_PATH = class="hl-string">"[SWIFT gpi Tracker API resource path]"
SWIFT_API_TOKEN = class="hl-string">"[SWIFT API token or credential reference]"
START_DATE = class="hl-string">"[YYYY-MM-DD]"
END_DATE = class="hl-string">"[YYYY-MM-DD]"
COMPANY_FILTER = class="hl-string">"[Configure based on your system]"
INTERNAL_EVENTS_FILE = class="hl-string">"[path to internal payment lifecycle events CSV or JSON]"
OUTPUT_FILE = class="hl-string">"swift_gpi_event_log.csv"
RAW_RESPONSE_FILE = class="hl-string">"swift_gpi_raw_responses.jsonl"
REQUEST_TIMEOUT_SECONDS = 60
MAX_RETRIES = 4
PAGE_SIZE = 100

REQUIRED_COLUMNS = [
    class="hl-string">"PaymentTransactionId",
    class="hl-string">"ActivityName",
    class="hl-string">"EventTimestamp",
    class="hl-string">"SourceSystem",
    class="hl-string">"LastDataUpdate",
]

RECOMMENDED_COLUMNS = [
    class="hl-string">"TransactionAmount",
    class="hl-string">"TransactionCurrency",
    class="hl-string">"UniqueEndToEndReference",
    class="hl-string">"SwiftMessageType",
    class="hl-string">"ProcessingUser",
    class="hl-string">"BeneficiaryBic",
    class="hl-string">"SwiftNakCode",
    class="hl-string">"ValueDate",
    class="hl-string">"IsStp",
]

ALL_ACTIVITIES = {
    class="hl-string">"Payment Request Created",
    class="hl-string">"Payment Details Validated",
    class="hl-string">"Sanctions Screening Passed",
    class="hl-string">"Payment Approved",
    class="hl-string">"Payment Instruction Sent",
    class="hl-string">"SWIFT ACK Received",
    class="hl-string">"Payment Transferred",
    class="hl-string">"Payment Error Identified",
    class="hl-string">"Payment Error Resolved",
    class="hl-string">"Payment Rejected",
    class="hl-string">"Payment Settled",
    class="hl-string">"Payment Reconciled",
}


def utc_now() -> str:
    return datetime.now(timezone.utc).isoformat()


def first_value(record: Dict[str, Any], names: Iterable[str], default: Any = None) -> Any:
    for name in names:
        if name in record and record[name] not in (None, class="hl-string">""):
            return record[name]
    return default


def normalize_timestamp(value: Any) -> Optional[str]:
    if value in (None, class="hl-string">""):
        return None
    text = str(value).strip()
    if text.endswith(class="hl-string">"Z"):
        text = text[:-1] + class="hl-string">"+00:00"
    try:
        parsed = datetime.fromisoformat(text)
        if parsed.tzinfo is None:
            parsed = parsed.replace(tzinfo=timezone.utc)
        return parsed.astimezone(timezone.utc).isoformat()
    except ValueError:
        return str(value)


def normalize_amount(value: Any) -> Optional[str]:
    if value in (None, class="hl-string">""):
        return None
    try:
        return str(Decimal(str(value)))
    except (InvalidOperation, ValueError):
        return str(value)


def normalize_bool(value: Any) -> Optional[bool]:
    if value in (None, class="hl-string">""):
        return None
    if isinstance(value, bool):
        return value
    return str(value).strip().lower() in {class="hl-string">"true", class="hl-string">"1", class="hl-string">"yes", class="hl-string">"y"}


def load_records(path: str) -> List[Dict[str, Any]]:
    if path.lower().endswith(class="hl-string">".json"):
        with open(path, class="hl-string">"r", encoding=class="hl-string">"utf-8") as handle:
            data = json.load(handle)
        if isinstance(data, list):
            return data
        if isinstance(data, dict):
            for key in (class="hl-string">"records", class="hl-string">"events", class="hl-string">"payments", class="hl-string">"data"):
                if isinstance(data.get(key), list):
                    return data[key]
        raise ValueError(class="hl-string">"The JSON input must contain a list of records.")
    with open(path, class="hl-string">"r", encoding=class="hl-string">"utf-8-sig", newline=class="hl-string">"") as handle:
        return list(csv.DictReader(handle))


def base_event(payment: Dict[str, Any], activity: str, timestamp: Any, source_system: str, run_time: str) -> Optional[Dict[str, Any]]:
    payment_id = first_value(payment, [class="hl-string">"PaymentTransactionId", class="hl-string">"payment_transaction_id", class="hl-string">"transaction_id", class="hl-string">"TRN", class="hl-string">"trn", class="hl-string">"UETR", class="hl-string">"uetr"])
    event_time = normalize_timestamp(timestamp)
    if not payment_id or not event_time:
        return None
    return {
        class="hl-string">"PaymentTransactionId": str(payment_id),
        class="hl-string">"ActivityName": activity,
        class="hl-string">"EventTimestamp": event_time,
        class="hl-string">"SourceSystem": source_system,
        class="hl-string">"LastDataUpdate": run_time,
        class="hl-string">"TransactionAmount": normalize_amount(first_value(payment, [class="hl-string">"TransactionAmount", class="hl-string">"transaction_amount", class="hl-string">"amount"])),
        class="hl-string">"TransactionCurrency": first_value(payment, [class="hl-string">"TransactionCurrency", class="hl-string">"transaction_currency", class="hl-string">"currency"]),
        class="hl-string">"UniqueEndToEndReference": first_value(payment, [class="hl-string">"UniqueEndToEndReference", class="hl-string">"UETR", class="hl-string">"uetr", class="hl-string">"uetr_value"]),
        class="hl-string">"SwiftMessageType": first_value(payment, [class="hl-string">"SwiftMessageType", class="hl-string">"swift_message_type", class="hl-string">"message_type"]),
        class="hl-string">"ProcessingUser": first_value(payment, [class="hl-string">"ProcessingUser", class="hl-string">"processing_user", class="hl-string">"user", class="hl-string">"performed_by"]),
        class="hl-string">"BeneficiaryBic": first_value(payment, [class="hl-string">"BeneficiaryBic", class="hl-string">"beneficiary_bic", class="hl-string">"beneficiaryBIC"]),
        class="hl-string">"SwiftNakCode": first_value(payment, [class="hl-string">"SwiftNakCode", class="hl-string">"swift_nak_code", class="hl-string">"nak_code"]),
        class="hl-string">"ValueDate": first_value(payment, [class="hl-string">"ValueDate", class="hl-string">"value_date"]),
        class="hl-string">"IsStp": normalize_bool(first_value(payment, [class="hl-string">"IsStp", class="hl-string">"is_stp", class="hl-string">"stp"])),
    }


def add_internal_event(events: List[Dict[str, Any]], payment: Dict[str, Any], activity: str, timestamp_names: List[str], source_system: str, run_time: str) -> None:
    timestamp = first_value(payment, timestamp_names)
    event = base_event(payment, activity, timestamp, source_system, run_time)
    if event:
        events.append(event)


def extract_internal_events(payments: List[Dict[str, Any]], run_time: str) -> List[Dict[str, Any]]:
    events: List[Dict[str, Any]] = []
    for payment in payments:
        source_system = str(first_value(payment, [class="hl-string">"SourceSystem", class="hl-string">"source_system"], class="hl-string">"Internal Payment System"))
        add_internal_event(events, payment, class="hl-string">"Payment Request Created", [class="hl-string">"PaymentRequestCreatedTimestamp", class="hl-string">"payment_request_created_timestamp", class="hl-string">"created_at", class="hl-string">"creation_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Details Validated", [class="hl-string">"PaymentDetailsValidatedTimestamp", class="hl-string">"payment_details_validated_timestamp", class="hl-string">"validated_at", class="hl-string">"validation_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Sanctions Screening Passed", [class="hl-string">"SanctionsScreeningPassedTimestamp", class="hl-string">"sanctions_screening_passed_timestamp", class="hl-string">"screening_passed_at", class="hl-string">"screening_release_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Approved", [class="hl-string">"PaymentApprovedTimestamp", class="hl-string">"payment_approved_timestamp", class="hl-string">"approved_at", class="hl-string">"approval_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Instruction Sent", [class="hl-string">"PaymentInstructionSentTimestamp", class="hl-string">"payment_instruction_sent_timestamp", class="hl-string">"instruction_sent_at", class="hl-string">"swift_sent_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"SWIFT ACK Received", [class="hl-string">"SwiftAckReceivedTimestamp", class="hl-string">"swift_ack_received_timestamp", class="hl-string">"ack_received_at", class="hl-string">"swift_ack_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Error Identified", [class="hl-string">"PaymentErrorIdentifiedTimestamp", class="hl-string">"payment_error_identified_timestamp", class="hl-string">"error_identified_at", class="hl-string">"repair_queue_timestamp", class="hl-string">"exception_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Error Resolved", [class="hl-string">"PaymentErrorResolvedTimestamp", class="hl-string">"payment_error_resolved_timestamp", class="hl-string">"error_resolved_at", class="hl-string">"repair_resolved_timestamp", class="hl-string">"resubmission_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Rejected", [class="hl-string">"PaymentRejectedTimestamp", class="hl-string">"payment_rejected_timestamp", class="hl-string">"rejected_at", class="hl-string">"return_received_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Settled", [class="hl-string">"PaymentSettledTimestamp", class="hl-string">"payment_settled_timestamp", class="hl-string">"settled_at", class="hl-string">"beneficiary_credit_timestamp"], source_system, run_time)
        add_internal_event(events, payment, class="hl-string">"Payment Reconciled", [class="hl-string">"PaymentReconciledTimestamp", class="hl-string">"payment_reconciled_timestamp", class="hl-string">"reconciled_at", class="hl-string">"reconciliation_timestamp"], source_system, run_time)
    return events


def request_json(session: requests.Session, url: str, headers: Dict[str, str], params: Dict[str, Any]) -> Dict[str, Any]:
    last_error: Optional[Exception] = None
    for attempt in range(MAX_RETRIES):
        try:
            response = session.get(url, headers=headers, params=params, timeout=REQUEST_TIMEOUT_SECONDS)
            if response.status_code == 429 or response.status_code >= 500:
                response.raise_for_status()
            response.raise_for_status()
            return response.json()
        except (requests.RequestException, ValueError) as error:
            last_error = error
            if attempt == MAX_RETRIES - 1:
                break
            time.sleep(2 ** attempt)
    raise RuntimeError(fclass="hl-string">"SWIFT API request failed: {last_error}")


def get_items(payload: Dict[str, Any]) -> List[Dict[str, Any]]:
    for key in (class="hl-string">"events", class="hl-string">"statuses", class="hl-string">"statusEvents", class="hl-string">"data", class="hl-string">"items", class="hl-string">"results"):
        value = payload.get(key)
        if isinstance(value, list):
            return [item for item in value if isinstance(item, dict)]
    if isinstance(payload, list):
        return [item for item in payload if isinstance(item, dict)]
    return []


def fetch_gpi_events(uetr: str, session: requests.Session, raw_handle: Any, run_time: str) -> List[Dict[str, Any]]:
    url = SWIFT_API_BASE_URL.rstrip(class="hl-string">"/") + class="hl-string">"/" + SWIFT_API_PATH.lstrip(class="hl-string">"/")
    headers = {class="hl-string">"Accept": class="hl-string">"application/json", class="hl-string">"Authorization": fclass="hl-string">"Bearer {SWIFT_API_TOKEN}"}
    page = 1
    output: List[Dict[str, Any]] = []
    while True:
        params = {class="hl-string">"uetr": uetr, class="hl-string">"startDate": START_DATE, class="hl-string">"endDate": END_DATE, class="hl-string">"page": page, class="hl-string">"pageSize": PAGE_SIZE}
        payload = request_json(session, url, headers, params)
        raw_handle.write(json.dumps({class="hl-string">"run_time": run_time, class="hl-string">"uetr": uetr, class="hl-string">"request_params": params, class="hl-string">"response": payload}, default=str) + class="hl-string">"\n")
        items = get_items(payload)
        output.extend(items)
        has_next = first_value(payload, [class="hl-string">"hasNext", class="hl-string">"has_next", class="hl-string">"nextPage", class="hl-string">"next_page"])
        if not items or has_next in (False, None, class="hl-string">"false", class="hl-string">"False"):
            break
        if isinstance(has_next, (int, str)) and str(has_next).isdigit():
            page = int(has_next)
        else:
            page += 1
    return output


def tracker_event(payment: Dict[str, Any], tracker: Dict[str, Any], activity: str, run_time: str) -> Optional[Dict[str, Any]]:
    merged = dict(payment)
    merged.update({
        class="hl-string">"UniqueEndToEndReference": first_value(tracker, [class="hl-string">"uetr", class="hl-string">"UETR"], first_value(payment, [class="hl-string">"UniqueEndToEndReference", class="hl-string">"UETR", class="hl-string">"uetr"])),
        class="hl-string">"SwiftMessageType": first_value(tracker, [class="hl-string">"messageType", class="hl-string">"message_type", class="hl-string">"swiftMessageType"], first_value(payment, [class="hl-string">"SwiftMessageType", class="hl-string">"swift_message_type", class="hl-string">"message_type"])),
        class="hl-string">"BeneficiaryBic": first_value(tracker, [class="hl-string">"beneficiaryBic", class="hl-string">"beneficiary_bic", class="hl-string">"beneficiaryBIC"], first_value(payment, [class="hl-string">"BeneficiaryBic", class="hl-string">"beneficiary_bic", class="hl-string">"beneficiaryBIC"])),
        class="hl-string">"TransactionAmount": first_value(tracker, [class="hl-string">"amount", class="hl-string">"transactionAmount", class="hl-string">"transaction_amount"], first_value(payment, [class="hl-string">"TransactionAmount", class="hl-string">"transaction_amount", class="hl-string">"amount"])),
        class="hl-string">"TransactionCurrency": first_value(tracker, [class="hl-string">"currency", class="hl-string">"transactionCurrency", class="hl-string">"transaction_currency"], first_value(payment, [class="hl-string">"TransactionCurrency", class="hl-string">"transaction_currency", class="hl-string">"currency"])),
        class="hl-string">"ValueDate": first_value(tracker, [class="hl-string">"valueDate", class="hl-string">"value_date"], first_value(payment, [class="hl-string">"ValueDate", class="hl-string">"value_date"])),
        class="hl-string">"IsStp": first_value(tracker, [class="hl-string">"isStp", class="hl-string">"is_stp", class="hl-string">"stp"], first_value(payment, [class="hl-string">"IsStp", class="hl-string">"is_stp", class="hl-string">"stp"])),
        class="hl-string">"SwiftNakCode": first_value(tracker, [class="hl-string">"nakCode", class="hl-string">"nak_code", class="hl-string">"swiftNakCode"], first_value(payment, [class="hl-string">"SwiftNakCode", class="hl-string">"swift_nak_code", class="hl-string">"nak_code"])),
    })
    timestamp = first_value(tracker, [class="hl-string">"eventTimestamp", class="hl-string">"event_timestamp", class="hl-string">"timestamp", class="hl-string">"statusTimestamp", class="hl-string">"status_timestamp", class="hl-string">"occurredAt", class="hl-string">"occurred_at"])
    return base_event(merged, activity, timestamp, class="hl-string">"SWIFT gpi Tracker API", run_time)


def extract_tracker_events(payments: List[Dict[str, Any]], run_time: str, raw_handle: Any) -> List[Dict[str, Any]]:
    events: List[Dict[str, Any]] = []
    seen_uetrs = set()
    with requests.Session() as session:
        for payment in payments:
            uetr = first_value(payment, [class="hl-string">"UniqueEndToEndReference", class="hl-string">"UETR", class="hl-string">"uetr", class="hl-string">"uetr_value"])
            if not uetr or str(uetr) in seen_uetrs:
                continue
            seen_uetrs.add(str(uetr))
            for tracker in fetch_gpi_events(str(uetr), session, raw_handle, run_time):
                status = str(first_value(tracker, [class="hl-string">"status", class="hl-string">"statusCode", class="hl-string">"status_code", class="hl-string">"gpiStatus", class="hl-string">"gpi_status"], class="hl-string">"")).upper()
                activity = {class="hl-string">"ACSP": class="hl-string">"Payment Transferred", class="hl-string">"RJCT": class="hl-string">"Payment Rejected", class="hl-string">"ACSC": class="hl-string">"Payment Settled"}.get(status)
                if activity:
                    event = tracker_event(payment, tracker, activity, run_time)
                    if event:
                        events.append(event)
    return events


def deduplicate(events: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
    result: List[Dict[str, Any]] = []
    seen = set()
    for event in sorted(events, key=lambda row: (row[class="hl-string">"PaymentTransactionId"], row[class="hl-string">"EventTimestamp"], row[class="hl-string">"ActivityName"])):
        key = (event[class="hl-string">"PaymentTransactionId"], event[class="hl-string">"ActivityName"], event[class="hl-string">"EventTimestamp"], event.get(class="hl-string">"UniqueEndToEndReference"))
        if key not in seen:
            seen.add(key)
            result.append(event)
    return result


def write_csv(events: List[Dict[str, Any]], path: str) -> None:
    columns = REQUIRED_COLUMNS + RECOMMENDED_COLUMNS
    with open(path, class="hl-string">"w", encoding=class="hl-string">"utf-8", newline=class="hl-string">"") as handle:
        writer = csv.DictWriter(handle, fieldnames=columns, extrasaction=class="hl-string">"ignore")
        writer.writeheader()
        for event in events:
            writer.writerow({column: event.get(column) for column in columns})


def main() -> None:
    run_time = utc_now()
    payments = load_records(INTERNAL_EVENTS_FILE)
    if COMPANY_FILTER != class="hl-string">"[Configure based on your system]":
        payments = [payment for payment in payments if str(first_value(payment, [class="hl-string">"CompanyCode", class="hl-string">"company_code", class="hl-string">"Company", class="hl-string">"company"], class="hl-string">"")) == COMPANY_FILTER]
    internal_events = extract_internal_events(payments, run_time)
    with open(RAW_RESPONSE_FILE, class="hl-string">"w", encoding=class="hl-string">"utf-8") as raw_handle:
        tracker_events = extract_tracker_events(payments, run_time, raw_handle)
    events = deduplicate(internal_events + tracker_events)
    invalid = [event for event in events if any(event.get(column) in (None, class="hl-string">"") for column in REQUIRED_COLUMNS) or event[class="hl-string">"ActivityName"] not in ALL_ACTIVITIES]
    if invalid:
        raise ValueError(fclass="hl-string">"The extraction produced {len(invalid)} invalid event rows.")
    write_csv(events, OUTPUT_FILE)
    print(json.dumps({class="hl-string">"run_id": str(uuid.uuid4()), class="hl-string">"rows_written": len(events), class="hl-string">"output_file": OUTPUT_FILE, class="hl-string">"activities": sorted({event[class="hl-string">"ActivityName"] for event in events})}, indent=2))


if __name__ == class="hl-string">"__main__":
    main()

Möchten Sie loslegen?

Mit diesen Templates machen Sie aus Ihren SWIFT-Rohdaten eine Grundlage für operative Verbesserungen und eine schnellere Zahlungsabwicklung.

Zurück zum Leitfaden zur Prozessverbesserung Template herunterladen

Verbessern Sie jetzt Ihre SWIFT-Zahlungsabwicklung

Erreichen Sie eine Straight-Through-Processing-Quote von 98 % und vermeiden Sie manuelle Fehler

Starten Sie Ihre kostenlose Testphase

Keine Kreditkarte erforderlich. In 5 Minuten eingerichtet

Ihr Daten-Template für die Zahlungsabwicklung

Ihr Daten-Template für die Zahlungsabwicklung

Attribute der Zahlungsabwicklung

Aktivitäten der Zahlungsabwicklung

Anleitungen zur Datenextraktion

Export des SWIFT Alliance Access-Archivs

Schritte

Konfiguration

a Beispielabfrage python

Python-Parser für SWIFT-MT-Rohdateien

Schritte

Konfiguration

a Beispielabfrage python

SWIFT gpi API-Konnektor

Schritte

Konfiguration

a Beispielabfrage python

Möchten Sie loslegen?

Verbessern Sie jetzt Ihre SWIFT-Zahlungsabwicklung

Ihr Daten-Template für die Zahlungsabwicklung

Ihr Daten-Template für die Zahlungsabwicklung

Attribute der Zahlungsabwicklung

Aktivitäten der Zahlungsabwicklung

Anleitungen zur Datenextraktion

Export des SWIFT Alliance Access-Archivs

Schritte

Konfiguration

a Beispielabfrage python

Python-Parser für SWIFT-MT-Rohdateien

Schritte

Konfiguration

a Beispielabfrage python

SWIFT gpi API-Konnektor

Schritte

Konfiguration

a Beispielabfrage python

Möchten Sie loslegen?

Verbessern Sie jetzt Ihre SWIFT-Zahlungsabwicklung

Der Schutz Ihrer Daten ist uns wichtig