> Amélioration continue des processus > Traitement des paiements > SWIFT > Modèle de données

Votre modèle de données pour le traitement des paiements

SWIFT

Attributs du traitement des paiements(19) Activités de traitement des paiements(12) Guides d’extraction(3)

Votre modèle de données pour le traitement des paiements

Ce modèle fournit la structure nécessaire pour représenter les flux de travail de vos transactions SWIFT, de leur lancement jusqu’au règlement final. Il présente les données et les jalons opérationnels à recueillir pour suivre l’ensemble du cycle de vie des paiements. Suivez ces indications pour préparer vos données, repérer les inefficacités cachées et réduire les risques liés à la conformité.

Attributs recommandés pour analyser les transactions en détail
Activités et jalons clés du processus SWIFT
Conseils techniques pour extraire les données financières

Vous découvrez les journaux d’événements ? Découvrez comment créer un journal d’événements pour le Process Mining.

Télécharger le modèle

Attributs du traitement des paiements

Voici les champs de données à inclure dans votre journal d’événements pour analyser en détail le cycle de vie de vos transactions SWIFT.

5 Obligatoire 9 Recommandé 5 Facultatif

	Nom	Description
	Dernière mise à jour des données LastDataUpdate	Horodatage de la dernière extraction ou actualisation de l’enregistrement.
Description Indique la date du dernier chargement des données dans l’outil de Process Mining. Cet attribut est essentiel pour évaluer leur fraîcheur et vérifier que les Dashboards reflètent l’état le plus récent des opérations de paiement. Il aide les utilisateurs à se fier aux données en indiquant clairement le délai de mise à jour des rapports. Pourquoi est-ce important ? Permet aux utilisateurs de connaître l’actualité et la fiabilité des données présentées. Où trouver ces données Horodatage de l’exécution du processus ETL. Exemples 2023-10-27T12:00:00Z2023-11-01T06:00:00Z
	Horodatage de l’événement EventTimestamp	Date et heure exactes auxquelles l’activité s’est produite.
Description Cet attribut consigne le moment précis où un événement s’est produit. Il sert à ordonner les activités chronologiquement et à calculer toutes les métriques fondées sur la durée, comme les délais, les temps de cycle et le débit. Des horodatages précis sont essentiels pour analyser le « respect des heures limites du réseau » et repérer les goulots d’étranglement dans le circuit d’approbation. Pourquoi est-ce important ? Les horodatages sont à la base de toutes les analyses temporelles et des métriques de performance du Process Mining. Où trouver ces données Journaux d’audit système, horodatages de création des messages ou heures des transactions en base de données. Exemples 2023-10-25T08:30:15Z2023-10-25T14:45:00Z2023-10-26T09:15:22Z
	Identifiant de transaction de paiement PaymentTransactionId	Identifiant unique représentant le dossier de paiement de bout en bout.
Description Cet attribut sert de clé centrale du dossier pour le Process Mining. Il regroupe toutes les activités liées à une même instruction de paiement, de la demande initiale à la validation, à la transmission SWIFT et au règlement final. Dans le contexte SWIFT, il correspond souvent au numéro de référence de transaction (TRN) ou à la référence unique de transaction de bout en bout (UETR), afin d’assurer la continuité entre les systèmes bancaires. Il permet de reconstituer le parcours d’une instance de processus et est indispensable à l’analyse des variantes et au calcul des temps de cycle. Pourquoi est-ce important ? L’identification unique est le fondement du Process Mining : elle permet de relier des événements dispersés pour obtenir une vue cohérente du processus. Où trouver ces données Champ 20 SWIFT (TRN) ou champ 121 (UETR) dans les en-têtes de message. Exemples TRN-20231025-883954392-882-101UETR-9982-1123-5521PAY-US-EU-9912
	Nom de l’activité ActivityName	Nom de l’étape ou de l’événement du processus qui s’est produit.
Description Cet attribut décrit l’action précise ou le changement de statut consigné dans le journal système. Exemples : « Demande de paiement créée », « Filtrage des sanctions réussi » ou « Accusé de réception SWIFT reçu ». Il constitue la dimension principale des cartes de processus : il définit les nœuds de la visualisation et permet aux analystes de comprendre la séquence des opérations effectuées pour un paiement. Pourquoi est-ce important ? Il définit le « quoi » du processus, ce qui permet de visualiser le flux du processus et ses variantes. Où trouver ces données Journaux de transactions, pistes d’audit ou données déduites des types de messages (par exemple, MT103 envoyé). Exemples Demande de paiement crééeInstruction de paiement envoyéeAccusé de réception SWIFT reçuPaiement approuvé
	Système source SourceSystem	Nom du système d’où proviennent les données de l’événement.
Description Identifie le logiciel ou la plateforme qui a généré le journal d’événements. Dans un processus de paiement, il peut s’agir du système bancaire central, de la passerelle de paiement ou directement de l’interface SWIFT. Cet attribut aide à vérifier la traçabilité des données et à diagnostiquer les problèmes lors de la fusion de données provenant de plusieurs applications bancaires distinctes. Pourquoi est-ce important ? Précise l’origine des données, une information essentielle pour le Process Mining dans plusieurs systèmes. Où trouver ces données Valeur définie en dur pendant l’ETL ou extraite des identifiants système. Exemples SWIFT Alliance AccessSystème bancaire centralMoteur de paiementFiltre des sanctions
	BIC de la banque bénéficiaire BeneficiaryBic	Code d’identification bancaire de l’établissement destinataire.
Description Identifie la banque destinataire du paiement. Cette dimension est essentielle pour le Dashboard « Causes des rejets par la banque bénéficiaire ». En regroupant les échecs par BIC de la banque bénéficiaire, la banque peut repérer les contreparties qui rejettent fréquemment les instructions en raison de problèmes de qualité des données ou d’exigences de format particulières. Pourquoi est-ce important ? Indispensable pour analyser les performances des contreparties et les motifs de rejet. Où trouver ces données Champ 57A SWIFT (établissement teneur du compte) ou 58A (établissement bénéficiaire). Exemples CITIUS33BARCGB22DRESDEFFHANDSEXX
	Code NAK SWIFT SwiftNakCode	Code d’erreur renvoyé par le réseau SWIFT lorsqu’un message est rejeté.
Description Contient le code d’erreur précis (par exemple, T26, T13) indiqué dans un accusé de réception négatif (NAK) du réseau SWIFT. Cet attribut alimente le Dashboard « Analyse des erreurs et des reprises SWIFT » et permet de classer les défaillances techniques afin de prioriser les corrections système. Pourquoi est-ce important ? Fournit les causes techniques des rejets au niveau du réseau. Où trouver ces données Messages système MT 015/019 ou champ 451 dans les ACK/NAK. Exemples T26H01T13G02
	Date de valeur ValueDate	Date à laquelle les fonds doivent être mis à la disposition du bénéficiaire.
Description Correspond à la date de règlement indiquée dans le message de paiement. La comparaison avec l’horodatage réel de l’activité « Paiement réglé » permet d’alimenter le Dashboard « Ancienneté du règlement et du rapprochement ». Elle indique le degré d’urgence du paiement et sert à mesurer le respect des accords de niveau de service concernant la mise à disposition des fonds. Pourquoi est-ce important ? Essentielle à la gestion de la liquidité et au suivi des délais de règlement. Où trouver ces données Champ 32A SWIFT MT (sous-champ de date) ou IntrBkSttlmDt d’ISO 20022. Exemples 2023-10-262023-11-01
	Devise de la transaction TransactionCurrency	Code ISO à 3 lettres indiquant la devise du paiement.
Description Identifie la devise dans laquelle le paiement est libellé (par exemple, USD, EUR, GBP). Cette information est essentielle pour le Dashboard « Performance des heures limites du réseau », car les heures limites varient selon la devise. Elle permet également d’analyser l’efficacité des conversions de devises en identifiant les paires de devises différentes. Pourquoi est-ce important ? Détermine les règles de routage, les heures limites et les circuits de règlement. Où trouver ces données Champ 32A SWIFT MT (devise) ou élément Ccy d’ISO 20022. Exemples USDEURGBPJPY
	Montant de la transaction TransactionAmount	Valeur monétaire de l’instruction de paiement.
Description Représente le montant principal transféré. Cette donnée est extraite de champs SWIFT spécifiques, par exemple le champ 32A d’un message MT103. Elle est essentielle au Dashboard « Cycles d’approbation des virements de montant élevé » : elle permet de segmenter les paiements par montant et d’analyser les retards d’approbation des transactions à risque élevé et de montant important. Pourquoi est-ce important ? Permet d’analyser l’impact financier et de segmenter les transactions selon leur montant. Où trouver ces données Champ 32A des messages SWIFT MT (montant) ou élément IntrBkSttlmAmt d’ISO 20022. Exemples 15000.001250.501000000.0045.00
	Traitement STP IsStp	Indicateur précisant si le paiement a nécessité une intervention manuelle.
Description Indicateur booléen égal à True lorsque le cas ne comporte aucune activité « Erreur détectée », « Paiement rejeté » ou « Modification » manuelle. Il permet de calculer directement l’indicateur de performance clé « Taux de traitement automatisé de bout en bout ». C’est la principale mesure de la réussite de l’automatisation du traitement des paiements. Pourquoi est-ce important ? Principale mesure de l’efficacité du processus et du bon fonctionnement de l’automatisation. Où trouver ces données Calculé à partir de l’absence d’activités manuelles ou négatives précises dans le cas. Exemples truefalse
	Type de message SWIFT SwiftMessageType	Type de message SWIFT utilisé (par exemple, MT103, pacs.008).
Description Indique le format précis de l’instruction de paiement. Parmi les types courants figurent le MT103 pour les virements de clientèle et ses équivalents ISO 20022, comme pacs.008. Utilisé dans l’analyse des variantes du parcours de paiement pour comparer l’efficacité de traitement des anciens formats MT avec celle des nouvelles normes ISO. Pourquoi est-ce important ? Permet de distinguer les flux de paiement et les normes de traitement (anciens formats ou ISO 20022). Où trouver ces données Bloc 2 SWIFT (en-tête d’application), champ du type de message. Exemples MT103MT202pacs.008MT101
	UETR UniqueEndToEndReference	Référence unique de bout en bout de la transaction, utilisée pour le suivi dans SWIFT gpi.
Description L’UETR est une chaîne de 36 caractères qui fournit une référence unique et immuable pour un paiement dans l’ensemble du réseau SWIFT. Contrairement aux identifiants internes, l’UETR reste le même d’une banque à l’autre. Cet attribut est essentiel pour assurer une visibilité de bout en bout et rapprocher les journaux internes des mises à jour de statut externes de SWIFT gpi. Pourquoi est-ce important ? La référence de référence pour suivre les paiements transfrontaliers entre différents établissements. Où trouver ces données Bloc 3 SWIFT, champ 121. Exemples b8c3f4a0-5d2a-4e1b-9c3d-1a2b3c4d5e6f123e4567-e89b-12d3-a456-426614174000
	Utilisateur chargé du traitement ProcessingUser	Utilisateur ou agent système ayant effectué l’activité.
Description Identifie la personne ou le robot automatisé responsable de l’activité, par exemple un responsable de la conformité qui approuve une alerte de sanction ou un opérateur qui corrige une erreur de format. Cet attribut alimente la carte thermique des erreurs de validation. Les responsables peuvent ainsi repérer les besoins de formation ou les utilisateurs associés à un taux élevé de reprises. Pourquoi est-ce important ? Permet d’analyser les ressources et de repérer les goulots d’étranglement liés aux interventions manuelles. Où trouver ces données Journaux d’audit système, colonne « User ID » des tables de transactions. Exemples SYSTÈMEJ.DoeCompliance_Bot_01M.Smith
	Heure limite respectée MetCutOffTime	Indicateur précisant si l’instruction a été envoyée avant l’heure limite du réseau.
Description Indicateur booléen calculé en comparant l’heure d’envoi de l’instruction de paiement à l’heure limite du réseau SWIFT pour la devise concernée. Il permet de calculer l’indicateur de performance clé « Taux de respect des heures limites SWIFT ». Le non-respect de ces heures limites retarde le règlement et affecte les positions de liquidité. Pourquoi est-ce important ? Indicateur opérationnel essentiel pour la trésorerie et la gestion de la liquidité. Où trouver ces données Calculé en comparant l’horodatage à une table de référence statique des heures limites. Exemples truefalse
	Motif du rejet RejectionReason	Description textuelle expliquant le rejet d’un paiement.
Description Contient le texte explicatif ou la description du code associé à l’échec d’un paiement. Ces informations figurent généralement dans le champ 72 SWIFT (informations de l’expéditeur au destinataire) ou dans les messages de retour. Elles alimentent l’analyse des causes des rejets par la banque bénéficiaire. Les analystes peuvent effectuer une analyse de texte pour repérer les motifs récurrents de rejet (par exemple, « Compte invalide » ou « Nom du bénéficiaire non concordant »). Pourquoi est-ce important ? Apporte un contexte qualitatif aux échecs du processus. Où trouver ces données Champ 72 ou 79 SWIFT dans les messages de retour (retour MT103). Exemples Compte du bénéficiaire clôturéIBAN invalideÉchec du contrôle de conformité réglementaireCode bancaire inconnu
	Paiement transfrontalier IsCrossBorder	Indicateur précisant si le paiement concerne plusieurs pays.
Description Attribut booléen égal à True lorsque le pays de l’expéditeur diffère de celui du bénéficiaire. Il permet de calculer l’indicateur de performance clé « Latence du traitement multidevise » en distinguant les flux nationaux des flux internationaux. Les paiements transfrontaliers sont généralement plus complexes, plus coûteux et plus longs à traiter. Pourquoi est-ce important ? Segmentation fondamentale pour analyser la complexité des paiements. Où trouver ces données Comparaison du code pays du BIC de l’expéditeur avec celui du BIC du bénéficiaire. Exemples truefalse
	Pays d’origine OriginatingCountry	Code pays de l’entité à l’origine du paiement.
Description Indique la juridiction d’où provient la demande de paiement. Cette information est essentielle pour le Dashboard « Délai de traitement du filtrage des sanctions », car les paiements provenant de juridictions à haut risque font souvent l’objet de contrôles de conformité plus rigoureux et plus longs. Elle permet d’analyser la répartition géographique des volumes de paiement et des retards de traitement. Pourquoi est-ce important ? Dimension clé pour l’analyse des risques de conformité et des performances régionales. Où trouver ces données Déduit du BIC de l’expéditeur (caractères 5 et 6 du code pays). Exemples USGBDEFR
	Priorité de l’instruction InstructionPriority	Indicateur de priorité précisant le degré d’urgence du paiement.
Description Déduite des en-têtes du message (par exemple, « Normal » ou « Urgent »). Elle permet de segmenter les données dans le Dashboard « Cycles d’approbation des virements de montant élevé », car les paiements urgents nécessitent souvent un circuit d’approbation accéléré. La répartition des priorités aide à planifier les ressources pendant les périodes de pointe. Pourquoi est-ce important ? Permet de distinguer les exigences de niveau de service des paiements standard et accélérés. Où trouver ces données Bloc 2 SWIFT, champ de priorité du message (par exemple, N pour Normal, U pour Urgent). Exemples NormalUrgentSystème

Obligatoire Recommandé Facultatif

Activités de traitement des paiements

Voici les étapes et les jalons clés à consigner dans votre journal d’événements pour découvrir le processus avec précision et repérer les goulots d’étranglement.

6 Recommandé 6 Facultatif

	Activité	Description
	Demande de paiement créée	Création initiale de l’instruction de paiement dans le système bancaire interne ou le système ERP. Cet événement est enregistré explicitement lorsqu’une référence de transaction unique (TRN ou UETR) est attribuée pour la première fois à l’ordre de paiement.
Pourquoi est-ce important ? Définit l’heure de début de l’ensemble du cycle de vie du paiement. Cette étape est essentielle pour calculer les délais de traitement de bout en bout et repérer les retards en amont, avant l’intervention du réseau SWIFT. Où trouver ces données Horodatage de création de la ligne de transaction dans le système bancaire central (CBS) ou le Payment Hub. Données à recueillir Enregistré lors de la création de la transaction Type d’événement explicit
	Filtrage des sanctions réussi	Horodatage auquel l’instruction de paiement passe avec succès le filtrage des listes OFAC et des sanctions. Cet événement est enregistré explicitement dans les journaux du système de conformité ou déduit de la levée du statut « En attente de filtrage ».
Pourquoi est-ce important ? Indispensable au Dashboard « Délai de filtrage des sanctions ». Les retards à cette étape relèvent de la conformité, et non d’un manque d’efficacité opérationnelle. Où trouver ces données Journaux du système de filtrage de conformité ou indicateurs de statut de conformité du Payment Hub. Données à recueillir Enregistré lors de la mise à jour du statut de filtrage Type d’événement explicit
	Instruction de paiement envoyée	Transmission du message formaté (MT103 ou ISO 20022 pacs.008) à la passerelle SWIFT. Cet événement est enregistré explicitement lorsque le contenu du message est généré et transmis à l’interface réseau.
Pourquoi est-ce important ? Permet de calculer le « taux de respect des heures limites SWIFT ». Marque le passage du traitement interne au traitement par le réseau. Où trouver ces données Journaux de SWIFT Alliance Access (SAA) ou journaux de transmission de la passerelle. Données à recueillir Enregistré lors de l’émission du message Type d’événement explicit
	Paiement approuvé	Action d’autorisation finale effectuée par un responsable désigné ou par une règle automatisée pour les virements de montant élevé. Cet événement est enregistré explicitement lorsque l’indicateur du flux de travail d’approbation est défini sur « vrai ».
Pourquoi est-ce important ? Indispensable au Dashboard « Cycles d’approbation des virements de montant élevé ». Permet de repérer les retards liés aux validations manuelles des mouvements de liquidité importants. Où trouver ces données Piste d’audit du moteur de flux de travail d’approbation. Données à recueillir Enregistré lors de l’exécution de l’action d’approbation Type d’événement explicit
	Paiement rapproché	Rapprochement de la transaction de paiement avec le relevé du compte Nostro/Vostro. Cet événement est déduit lorsque le système de rapprochement associe l’identifiant de transaction à une ligne du relevé.
Pourquoi est-ce important ? Clôture le cycle financier. Les retards à cette étape nuisent à la visibilité sur la trésorerie et à la traçabilité des opérations. Où trouver ces données Journaux du système de rapprochement ou statut « Rapproché » dans le système bancaire central. Données à recueillir Comparez le statut de rapprochement Type d’événement inferred
	Paiement réglé	Confirmation du crédit des fonds sur le compte du bénéficiaire, souvent indiquée par le statut gpi ACSC. Cet événement est enregistré explicitement à partir des mises à jour du Tracker ou des messages de confirmation.
Pourquoi est-ce important ? Marque la fin effective de la chaîne de paiement. Indispensable pour calculer l’« écart entre règlement et rapprochement ». Où trouver ces données SWIFT gpi Tracker (statut ACSC) ou confirmations MT900/910. Données à recueillir Enregistré à la confirmation du règlement Type d’événement explicit
	Accusé de réception SWIFT reçu	Réception d’un accusé de réception technique (ACK) du réseau SWIFT, confirmant que le message a été accepté pour traitement. Cet événement est enregistré explicitement dans les journaux de l’interface réseau.
Pourquoi est-ce important ? Confirme que le message a bien été transmis au réseau mondial. Permet de distinguer les échecs internes des problèmes de transmission sur le réseau. Où trouver ces données Journaux de la passerelle SWIFT (recherche des signaux ACK et NACK). Données à recueillir Enregistré à la réception de l’ACK du réseau Type d’événement explicit
	Détails du paiement validés	Validation réussie de la syntaxe et du format de l’instruction de paiement, par exemple du format IBAN ou de la validité du BIC. Cet événement est souvent déduit du passage du statut de transaction de « Brouillon » à « Validé » ou « Prêt pour autorisation ».
Pourquoi est-ce important ? Un taux d’échec élevé à cette étape indique une mauvaise qualité des données à la source. Permet de mesurer le KPI « taux de validation réussie au premier passage ». Où trouver ces données Journaux d’état du moteur de paiement ou tables d’historique des validations. Données à recueillir Comparez le champ de statut avant et après Type d’événement inferred
	Erreur de paiement détectée	Événement indiquant qu’une transaction doit être corrigée en raison d’échecs de validation, de NACK ou de messages de rejet. Il est déduit du passage de la transaction dans une file d’attente « Réparation », « Correction » ou « Exception ».
Pourquoi est-ce important ? Permet de suivre le « taux de reprises pour résolution des erreurs ». Une fréquence élevée à cette étape fait baisser le taux de traitement de bout en bout (STP). Où trouver ces données Colonnes de statut du Payment Hub ou journaux des files d’attente d’exceptions. Données à recueillir Comparez le champ de statut à « Erreur » ou « Réparation » Type d’événement inferred
	Erreur de paiement résolue	Modification réussie et nouvelle soumission d’une transaction précédemment en erreur. Cet événement est déduit du passage de la transaction d’une file d’attente « Réparation » à un état « En cours de traitement » ou « Prêt ».
Pourquoi est-ce important ? Mesure l’efficacité de l’équipe chargée des reprises manuelles. Des durées longues à cette étape peuvent révéler des besoins de formation ou des codes d’erreur complexes. Où trouver ces données Journaux de statut du Payment Hub indiquant la sortie des files d’attente d’exceptions. Données à recueillir Comparez le champ de statut à la sortie de l’étape de réparation Type d’événement inferred
	Paiement rejeté	Réception d’un message de rejet (retour MT103 ou statut gpi RJCT) d’une banque bénéficiaire ou intermédiaire. Cet événement est enregistré explicitement à partir des messages SWIFT entrants.
Pourquoi est-ce important ? Indispensable au Dashboard « Causes profondes des rejets par les bénéficiaires ». Permet de repérer les obstacles externes, comme les comptes clôturés ou les données de routage incorrectes. Où trouver ces données Messages SWIFT entrants (MT103 RET, pacs.004) ou statut gpi RJCT. Données à recueillir Enregistré à la réception du message de rejet Type d’événement explicit
	Paiement transféré	Mise à jour intermédiaire du statut, souvent le statut gpi ACSP, indiquant que le paiement est traité par une banque intermédiaire. Cet événement est enregistré à partir des mises à jour du SWIFT gpi Tracker ou des messages de statut.
Pourquoi est-ce important ? Donne de la visibilité sur les étapes du traitement par les banques correspondantes, souvent difficiles à suivre. Indispensable pour analyser l’ensemble du parcours de bout en bout. Où trouver ces données Flux de données du SWIFT gpi Tracker ou messages MT199/trck. Données à recueillir Enregistré à la réception d’une mise à jour du Tracker Type d’événement explicit

Recommandé Facultatif

Guides d’extraction

Comment extraire vos données de SWIFT

Étapes

Connectez-vous à SWIFT Alliance WebPlatform ou à l’interface graphique d’Alliance Access avec un compte administrateur disposant d’un accès à la configuration de l’archivage.
Dans le menu System Management, sélectionnez Archiving, puis Automated Archiving Configuration.
Configurez un nouveau profil d’export quotidien. Définissez Target Directory sur un chemin réseau sécurisé auquel vos scripts d’extraction peuvent accéder.
Définissez le périmètre du contenu : sélectionnez « Messages » et vérifiez que « Include History » et « Include Interventions » sont cochés. Cette étape est essentielle pour recueillir les événements de la piste d’audit, comme les approbations et les validations.
Sélectionnez le format de sortie. Choisissez XML, et plus précisément « SAA XML v2 » ou le schéma le plus récent disponible, car ce format préserve mieux que CSV les liens hiérarchiques entre l’en-tête du message et les événements de l’historique.
Définissez les filtres de période pour extraire les données historiques nécessaires à votre projet de Process Mining, ou configurez une exécution quotidienne pour obtenir les données de la veille (T-1).
Lancez manuellement l’export des archives pour le chargement initial, ou attendez la fin du traitement planifié. Vérifiez que les fichiers .xml sont générés dans le répertoire cible.
L’export SAA étant un fichier XML hiérarchique, alors que ProcessMind nécessite un journal d’événements CSV à plat, vous devez exécuter un script de transformation. Utilisez le script Python fourni dans la section Query pour analyser le XML.
Le script parcourt chaque élément de message. Il extrait la référence de transaction unique de bout en bout (UETR) ou le numéro de référence de transaction (TRN) pour l’utiliser comme Case ID.
Le script parcourt ensuite les nœuds enfants « History » et « Intervention » de chaque message afin de créer les lignes d’activité. Il associe les codes d’état internes de SAA, par exemple « NetworkAck » et « Authorisation », aux noms d’activité normalisés.
Exécutez le script Python sur les fichiers XML exportés pour générer le fichier « events.csv » à plat.
Vérifiez que les colonnes du fichier CSV, notamment EventTimestamp, sont au format ISO 8601, puis importez le fichier dans ProcessMind.

Configuration

Format d’archive : XML (recommandé) ou CSV (fichier à plat). Le format XML est vivement conseillé pour recueillir les nœuds d’historique imbriqués.
Inclure le texte des messages : oui (nécessaire pour extraire les montants, les devises et les informations sur les bénéficiaires).
Inclure l’historique et les interventions : oui (indispensable pour voir les approbations, les validations et les erreurs).
Période : configurez une fenêtre glissante, par exemple les 30 derniers jours, pour les chargements incrémentiels, ou des dates fixes pour l’historique initial.
Types de messages : filtrez les messages MT103, MT202, pacs.008, pacs.009 et pacs.004/002 (retours et statuts).
Sens des messages : incluez les messages entrants (émission) et sortants (réception) pour recueillir les rejets et confirmations reçus.
Sécurité : limitez strictement les droits de lecture et d’écriture sur le dossier d’export, car ces fichiers contiennent des données de paiement en temps réel.

Exemple de requête 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}")

Étapes

Préparez l’environnement : vérifiez que Python 3.8 ou une version ultérieure est installé sur le serveur d’extraction. Installez les bibliothèques nécessaires avec pip (pandas, numpy). Créez un répertoire de travail dédié contenant un sous-dossier nommé raw_swift_files, puis placez-y tous les fichiers quotidiens .out, .txt ou .fin.
Examinez la structure des fichiers : les messages SWIFT FIN bruts sont organisés en blocs ({1 : Header} {2 : Application} {4 : Body}). Repérez les délimiteurs. Les fichiers standard utilisent des accolades. Vérifiez que vos fichiers ne sont pas enveloppés dans des formats propriétaires, comme des en-têtes RJE, ou retirez ces en-têtes avant le traitement.
Configurez les chemins du script : ouvrez le script Python fourni. Modifiez la variable INPUT_DIRECTORY pour qu’elle pointe vers votre dossier raw_swift_files. Définissez le chemin de OUTPUT_FILE pour le fichier CSV généré.
Définissez les expressions régulières : le script utilise des expressions régulières pour isoler les blocs. Le bloc 1 contient le BIC de l’expéditeur et le numéro de séquence. Le bloc 2 contient le type de message, par exemple I103 ou O103, et le BIC du destinataire. Le bloc 4 contient les balises de données métier, par exemple :20 : TRN et :32A : valeur/montant.
Associez les types de message aux activités : le script contient un dictionnaire d’associations. MT103 correspond à « Instruction de paiement envoyée ». MT012 (accusé de réception système) correspond à « Accusé de réception SWIFT reçu ». MT900/910 correspond à « Paiement réglé ». MT199/299 avec certains codes d’état (ACSP, RJCT) correspond à « Paiement transféré » ou « Paiement rejeté ».
Extrayez les attributs : l’analyseur parcourt des balises précises. :20 : est associé à Payment Transaction ID. :121 : est associé à UETR. :32A : est analysé pour en extraire la date, la devise et le montant.
Gérez les états internes : pour les activités comme « Demande de paiement créée » ou « Paiement approuvé », qui correspondent souvent à des événements internes de l’ERP absents des fichiers SWIFT, le script déduit ces événements de l’horodatage de création du message dans le bloc 1 si aucun journal explicite n’est disponible. Il peut aussi rechercher des codes de texte précis dans le champ :72 : (informations de l’expéditeur au destinataire), si votre organisation y consigne les approbations.
Lancez l’extraction : exécutez le script en ligne de commande avec python swift_parser.py. Il parcourt tous les fichiers, analyse les blocs SWIFT valides et ignore les lignes mal formées.
Vérifiez les données après traitement : ouvrez le fichier CSV généré. Vérifiez le format de EventTimestamp (ISO 8601 est recommandé). Assurez-vous que PaymentTransactionId est renseigné pour chaque ligne afin de regrouper les cas.
Transformez les données : si « ValueDate » est au format YYMMDD, le script le convertit au format YYYY-MM-DD. Vérifiez que les séparateurs décimaux de « TransactionAmount » sont uniformes (points ou virgules).
Effectuez une dernière vérification : filtrez les données sur un UETR précis pour suivre le flux de bout en bout, de l’instruction envoyée à l’accusé de réception, puis au règlement. Vérifiez que les NAK (MT019) apparaissent sous l’activité « Erreur de paiement détectée ».
Importez les données dans ProcessMind : importez le fichier CSV. Associez PaymentTransactionId à Case ID, ActivityName à Activity et EventTimestamp à Timestamp.

Configuration

Répertoire d’entrée : chemin du dossier contenant les fichiers plats FIN/MT bruts. Vérifiez que les droits de lecture sont accordés.
Interprétation du format de date : les dates SWIFT brutes sont au format YYMMDD. Le script déduit le siècle en utilisant 20xx.
Filtres sur les types de message : le script traite principalement la catégorie 1 (paiements), la catégorie 9 (relevés) et les messages système courants (012, 019). Modifiez la liste RELEVANT_MT_TYPES si la catégorie 2 (transferts entre établissements financiers) est nécessaire.
Encodage : l’encodage par défaut est « utf-8 ». Utilisez « latin-1 » ou « ascii » si les fichiers contiennent des caractères issus d’un ancien encodage.
Traitement par lots : pour les jeux de données de plus de 1 Go, le script utilise un générateur afin d’éviter la saturation de la mémoire et traite les fichiers un par un.
Réglage des expressions régulières : l’expression régulière stricte suppose un format FIN standard {1:...}{2:...}{4:...}. Si les fichiers utilisent $ ou d’autres délimiteurs, modifiez la variable BLOCK_PATTERN.

Exemple de requête 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()

Étapes

Vérifiez que vous disposez d’un abonnement à l’API SWIFT gpi Tracker, des identifiants API, de la fonction de recherche par UETR et d’un accès à la source des événements du système de paiement interne. Consultez la documentation de votre service SWIFT pour obtenir l’URL de base exacte de l’API, la méthode d’authentification, le schéma des réponses, les limites de requêtes et les règles de pagination. Ne présumez pas du chemin d’un point de terminaison, car il dépend du service SWIFT sous licence et de son déploiement.
Configurez le script avec la chaîne de connexion, les identifiants, la période et les filtres propres à votre entreprise. Pour l’extraction initiale, choisissez une période de trois à six mois. Limitez les données internes aux transactions de paiement associées à un TRN ou à un UETR, et conservez le nom du système source pour chaque événement.
Extrayez les événements internes du cycle de vie suivants : Demande de paiement créée, Détails du paiement validés, Contrôle des sanctions réussi, Paiement approuvé, Instruction de paiement envoyée, Accusé de réception SWIFT reçu, Erreur de paiement détectée, Erreur de paiement résolue, Paiement rejeté, Paiement réglé et Paiement rapproché. Chaque événement source doit correspondre à une ligne distincte du journal d’événements. Ne comptez pas sur ProcessMind pour déduire les activités.
Extrayez les UETR des dossiers de paiement internes et interrogez l’API sous licence SWIFT gpi Tracker pour chacun d’eux. Utilisez la documentation de l’API fournie pour votre environnement afin de configurer l’URL de requête, les en-têtes d’authentification, les paramètres, la pagination et les champs de réponse. Conservez la réponse brute à des fins d’audit.
Convertissez les statuts applicables de gpi Tracker en lignes d’événement explicites. Le script associe ACSP à Paiement transféré, RJCT à Paiement rejeté et ACSC à Paiement réglé. Si la réponse de votre service sous licence utilise d’autres noms de statut ou horodatages, adaptez les associations en vous appuyant sur le schéma de réponse documenté. Ne créez pas d’événement si l’API ne fournit pas de statut correspondant.
Normalisez tous les horodatages dans un même fuseau horaire, de préférence UTC, tout en conservant l’horodatage d’origine si l’audit l’exige. Convertissez les montants en valeurs numériques, conservez la devise de la transaction, normalisez les valeurs booléennes STP et gardez les valeurs NULL lorsque la source ne fournit pas d’attribut.
Dédupliquez les événements à l’aide de PaymentTransactionId, ActivityName, EventTimestamp et de l’identifiant d’événement source le plus précis disponible. Conservez les occurrences légitimes multiples, comme les cycles répétés de correction et de nouvelle soumission, sauf si une règle métier impose explicitement une seule occurrence par activité.
Vérifiez que chaque ligne du résultat contient PaymentTransactionId, ActivityName, EventTimestamp, SourceSystem et LastDataUpdate. Assurez-vous que ActivityName ne contient que les valeurs d’activité documentées et que les 12 activités sont présentes lorsqu’elles figurent dans les données sources.
Exportez le jeu de données obtenu au format CSV UTF-8 ou dans un autre format de journal d’événements pris en charge par ProcessMind. Utilisez une ligne par événement, incluez les colonnes obligatoires et recommandées, puis associez PaymentTransactionId à l’identifiant du cas, ActivityName à l’activité et EventTimestamp à l’horodatage de l’événement. Importez le fichier dans ProcessMind sans attendre de déduction supplémentaire des événements.

Configuration

Point de terminaison et schéma de l’API : configurez l’URL de base exacte de l’API SWIFT gpi Tracker, le chemin de la ressource, les paramètres de requête, les en-têtes d’authentification, la pagination et les noms des champs de réponse à partir de la documentation SWIFT sous licence correspondant à votre environnement. Le script n’invente volontairement aucun point de terminaison.
Identifiants et autorisations : utilisez le mécanisme d’identification approuvé pour l’API SWIFT, les certificats ou jetons requis, la méthode de stockage des secrets et les autorisations sur les systèmes sources internes. Ne placez pas de secrets de production directement dans le code source.
Période : commencez par trois à six mois. Utilisez l’horodatage de l’événement ou la date de création du paiement correspondant à votre objectif de reporting. Pour les volumes importants, traitez des périodes plus courtes et enregistrez les UETR déjà traités.
Filtres sur les sources internes : configurez les filtres d’entreprise, d’entité juridique, de succursale, de produit de paiement, de type de document, de type de message, de devise et de statut en fonction de votre système. Utilisez des paramètres fictifs comme [Configure based on your system] jusqu’à confirmation du schéma source.
Association des activités : définissez des associations explicites pour les statuts et les files d’attente internes. Par exemple, associez Draft à Validated ou Ready for Auth pour l’activité Détails du paiement validés, la levée d’une mise en attente de contrôle à Contrôle des sanctions réussi, l’entrée dans une file de correction ou d’exception à Erreur de paiement détectée, et le retour au traitement ou à la file de paiement à Erreur de paiement résolue.
Association des statuts gpi : associez les statuts documentés de Tracker à des activités explicites. Cette implémentation associe ACSP à Paiement transféré, RJCT à Paiement rejeté et ACSC à Paiement réglé. N’ajoutez des associations que si la documentation de l’API sous licence confirme la signification des statuts.
Règles relatives aux horodatages : normalisez les horodatages en UTC dans la mesure du possible. Définissez l’ordre de priorité entre l’heure de l’événement source, celle de l’événement Tracker, l’heure de réception du message et l’heure d’extraction. LastDataUpdate doit correspondre à l’heure d’extraction ou d’actualisation, et non à celle de l’événement métier.
Limites de requêtes et nouvelles tentatives : configurez le délai d’expiration des requêtes, le nombre de tentatives, le délai exponentiel, la gestion des statuts HTTP et la pagination. Respectez les limites du service SWIFT et évitez les requêtes parallèles non contrôlées.
Performances : mettez les réponses en cache par UETR, traitez les UETR par lots, enregistrez des points de reprise et utilisez l’extraction incrémentielle si elle est prise en charge. Évitez d’interroger plusieurs fois Tracker pour le même UETR et la même période.
Qualité des données : exigez les champs PaymentTransactionId, ActivityName, EventTimestamp, SourceSystem et LastDataUpdate. Autorisez les valeurs NULL pour les attributs recommandés lorsque la source ne les fournit pas, mais mesurez leur taux de renseignement.
Traçabilité des audits : conservez la réponse brute de l’API, l’horodatage de la requête, le statut de la réponse, l’UETR et l’identifiant de l’exécution d’extraction dans un emplacement d’audit approuvé. Appliquez les règles de conservation et de sécurité requises pour les données de paiement.
Prérequis : vérifiez que vous avez accès aux journaux du cycle de vie des paiements internes, de conformité, de la passerelle SWIFT, de rapprochement et des interfaces de messagerie, ainsi qu’à la licence de l’API SWIFT gpi Tracker et aux certificats ou autorisations réseau nécessaires.

Exemple de requête 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()

Prêt à commencer ?

Appuyez-vous sur ces modèles pour transformer vos journaux SWIFT bruts en un outil d’amélioration des opérations et d’accélération des règlements.

Retour au guide d’amélioration

Télécharger le modèle

Optimisez dès maintenant le traitement de vos paiements SWIFT

Atteignez 98 % de traitement sans intervention manuelle et éliminez les erreurs de saisie

Démarrez votre essai gratuit

Aucune carte bancaire requise. Configuration en 5 minutes.

Votre modèle de données pour le traitement des paiements

Votre modèle de données pour le traitement des paiements

Attributs du traitement des paiements

Activités de traitement des paiements

Guides d’extraction

Export des archives SWIFT Alliance Access

Étapes

Configuration

Exemple de requête python

Analyseur Python pour les fichiers SWIFT MT bruts

Étapes

Configuration

Exemple de requête python

Connecteur API SWIFT gpi

Étapes

Configuration

Exemple de requête python

Prêt à commencer ?

Optimisez dès maintenant le traitement de vos paiements SWIFT

Votre modèle de données pour le traitement des paiements

Votre modèle de données pour le traitement des paiements

Attributs du traitement des paiements

Activités de traitement des paiements

Guides d’extraction

Export des archives SWIFT Alliance Access

Étapes

Configuration

Exemple de requête python

Analyseur Python pour les fichiers SWIFT MT bruts

Étapes

Configuration

Exemple de requête python

Connecteur API SWIFT gpi

Étapes

Configuration

Exemple de requête python

Prêt à commencer ?

Optimisez dès maintenant le traitement de vos paiements SWIFT

Prêt à commencer ?