Aller au contenu

SumUp · checkout et remboursements

Intégrateur SumUp API : réconcilier checkout, transaction et remboursement

Dawap relie les checkouts et liens de paiement SumUp à vos commandes, avoirs et écritures ERP.

Vos équipes retrouvent la transaction confirmée, le remboursement et le montant net qui justifie la clôture.

  • Odoo
  • Symfony
  • RabbitMQ
  • OpenAPI

L’intégration

Un intégrateur SumUp API relie le paiement au dossier métier et garde chaque compensation vérifiable.

Dawap construit la couche entre les checkouts SumUp et vos commandes, factures, CRM ou ERP. L’intégration conserve checkout_reference, checkout ID et transaction ID, traite la notification comme un signal à relire, rapproche les remboursements et ne ferme un dossier que lorsque l’effet métier correspond au résultat SumUp.

  • Créer le checkout avec une référence métier stable, un montant, une devise et le bon marchand.
  • Recevoir la notification, répondre vite, dédupliquer puis vérifier l’état courant par l’API SumUp.
  • Utiliser la transaction comme résultat de paiement et conserver ses événements financiers associés.
  • Rapprocher refund, avoir, commande et solde net avant clôture ou replay.

Parcours SumUp à fiabiliser

Suivre la commande du checkout au montant net

Un checkout e-commerce, un lien hébergé, une intervention terrain et un remboursement support ne se terminent pas au même moment dans le SI.

  • Portail client

    Créer le paiement depuis le bon dossier

    La commande ou la facture émet checkout_reference et conserve l’URL ou le composant utilisé, sans perdre l’identité lors du retour utilisateur.

    Le support retrouve immédiatement l’intention initiale.

  • E-commerce

    Confirmer le résultat sans croire le seul retour navigateur

    Le parcours attend la transaction relue et traite le webhook comme un déclencheur de vérification avant de libérer commande ou service.

    Moins de faux payés et de doubles effets.

  • Remboursement

    Relier le refund à l’avoir et au motif

    Le geste support est contrôlé par le montant restant, puis rapproché de la transaction et de l’écriture attendue.

    Un net défendable par support et finance.

  • Reporting

    Comparer transactions et état métier

    Les historiques SumUp alimentent une balance par période, statut et référence, avec une liste d’écarts actionnable.

    Une clôture qui ne dépend plus d’un export manuel.

Registre checkout → transaction · scénario illustratif

Un paiement accepté n’est utile que si la commande, le remboursement et le solde racontent la même histoire.

La société, les montants et les identifiants ci-dessous sont fictifs. Ce dossier montre la preuve attendue lorsqu’un checkout SumUp réussit, qu’un remboursement partiel intervient, mais que l’ERP n’a pas encore reçu l’avoir.

Décision de rapprochement NE PAS CLÔTURER
1 écart ouvert
  1. 01
    IntentionCommande et checkout corrélésAccepté
  2. 02
    NotificationWebhook reçu puis relu par l’APIVérifié
  3. 03
    RésultatTransaction autoritative retrouvéeAccepté
  4. 04
    CompensationRefund de 29,90 € rapprochéAccepté
  5. 05
    ComptabilitéAvoir et écriture encore absentsBloqué
Prochaine action Créer l’avoir une seule fois, puis comparer le net de 100,00 €. order ≠ closed
Relecture 01

Le webhook arrive deux fois

Répondre rapidement, dédupliquer localement et relire le checkout par l’API avant tout nouvel effet métier.

Quarantaine 02

Le support ne possède que le code transaction

Retrouver la chaîne transaction–checkout_reference–commande ; ne jamais rattacher sur le seul montant.

Compensation 03

Le refund existe sans avoir ERP

Bloquer la clôture, conserver le motif et produire une compensation idempotente plutôt qu’un resync général.

Ce que SumUp documente — et ce que votre SI doit décider

Checkout, transaction et remboursement sont trois objets à relier, pas un seul statut à recopier.

SumUp documente le checkout comme intention de paiement, la transaction comme résultat autoritatif et le remboursement comme opération financière liée. Le webhook signale un changement, mais la documentation demande de vérifier l’événement par l’API : la notification ne devient donc jamais seule la vérité métier.

Premier lot recommandé

Une commande, un checkout, un refund partiel et une clôture témoin.

La recette exerce le succès, le doublon de notification, le statut relu, le remboursement partiel et l’écriture manquante avant d’ouvrir un autre canal ou un autre parcours.

Tester mon dossier SumUp

Premier lot SumUp

Prouver une transaction SumUp et son remboursement partiel

On choisit le parcours où le support ou la finance ouvre aujourd’hui plusieurs outils pour comprendre le solde. Le lot est accepté quand le dossier local et SumUp convergent, y compris après une notification doublée ou une compensation incomplète.

Sorties attendues

  • Carte portail–middleware–SumUp–ERP–support avec owner de chaque état et de chaque compensation.
  • Modèle pivot reliant commande, checkout_reference, checkout, transaction, refund, facture, avoir et écriture.
  • Contrat de notification : accusé rapide, déduplication, relecture API, ordre local et reprise bornée.
  • Cinq contre-tests : webhook doublé, checkout absent, transaction retardée, refund partiel et avoir manquant.
  • Journal expurgé avec requête, réponse, ressource relue, effet métier, décision et prochaine action.
  • Recette commerce–support–finance, alerte sur écart, export de balance et runbook de compensation.
Une chaîne de paiement que commerce, support et finance peuvent relire ensemble.
  • Audit des parcours, comptes marchands, checkouts, transactions, refunds, retours, webhooks et écarts de clôture.
  • Modèle canonique paiement–commande avec références stables, statuts métier et séparation intention–résultat–compensation.
  • Middleware côté serveur avec secrets protégés, validation, déduplication, relecture API, files et retries bornés.
  • Synchronisation vers CRM, ERP, portail, facture et avoir avec journal des effets et compensation idempotente.
  • Balance de rapprochement, alertes, dossier support expurgé, métriques de délai et tableau des écarts ouverts.
  • Tests de rupture, documentation, passation, hébergement Dawap ou déploiement dans votre infrastructure.

Trois scénarios de preuve

La recette porte sur les écarts qui changent réellement le solde ou le service rendu.

Les commandes, marchands, montants et identifiants ci-dessous sont illustratifs. La recette finale utilise vos comptes, droits, parcours et règles comptables validés.

SuccèsLe retour client ne libère rien avant la transaction relue
Scénario terrain
Le navigateur revient sur le portail alors que la notification est encore en transit.
Contrôles
checkout_reference, checkout courant, transaction associée, commande et horodatages.
Décision
Afficher un état de confirmation borné puis libérer uniquement après résultat vérifié.
Résultat vérifiable
Le portail ne fabrique pas un succès sur le seul retour utilisateur.
DoublonDeux notifications ne produisent qu’un effet métier
Scénario terrain
Le premier accusé tarde et SumUp rejoue le changement de statut.
Contrôles
Empreinte reçue, checkout relu, transition locale déjà appliquée et journal d’effet.
Décision
Acquitter, classer en doublon et ne pas recréer facture, email ou commande.
Résultat vérifiable
Le retry reste visible sans doubler l’action aval.
RefundLe remboursement partiel bloque la clôture tant que l’avoir manque
Scénario terrain
SumUp expose 29,90 € remboursés sur 129,90 €, mais l’ERP conserve le brut.
Contrôles
Transaction, événement refund, net de 100 €, facture, avoir attendu et écriture présente.
Décision
Créer une compensation unique puis comparer de nouveau les deux soldes.
Résultat vérifiable
Support et finance ferment le même dossier avec la même preuve.

Méthode Dawap

Vérifier la transaction et son effet dans le dossier

Nous partons du dossier qui coûte déjà du temps au support ou à la clôture. La chaîne d’identifiants et les transitions sont stabilisées, puis chaque notification, lecture et compensation est exercée avant d’ajouter un second parcours.

Une commande témoin, pas tout l’historique.

Une chaîne d’identifiants, jamais un rapprochement au montant.

Une notification vérifiée, pas un statut recopié.

Une compensation prouvée, pas une clôture supposée.

La panne SumUp commence souvent après le checkout, au moment où chaque outil interprète le succès différemment.

Un checkout terminé, un webhook reçu ou une ligne visible dans le dashboard ne suffisent pas à solder une commande. Le connecteur doit retrouver la transaction autoritative, appliquer les compensations et prouver le même net au support comme à la finance.

  • Le montant ne rapproche jamais seul une commande

    La commande, checkout_reference, checkout, transaction et écriture locale conservent chacun leur identifiant. Une relation manquante ouvre un écart, pas une correspondance approximative.

  • Le webhook déclenche une vérification, pas une vérité définitive

    La notification est acquittée rapidement puis le checkout ou la transaction est relu par l’API SumUp avant de modifier la commande, l’avoir ou le dossier client.

  • Un remboursement n’est clos qu’une fois son effet métier rapproché

    Refund SumUp, avoir, écriture ERP et solde net sont comparés. La transaction peut être remboursée alors que la clôture interne reste légitimement bloquée.

Critères de recette
  • Chaque checkout retrouve sa commande et chaque transaction retrouve son checkout.
  • Chaque notification est dédupliquée puis vérifiée par une lecture SumUp ciblée.
  • Chaque refund conserve transaction, montant, motif, avoir et solde métier attendu.
  • Chaque écart ouvert indique owner, preuve disponible, action autorisée et condition de clôture.
Ce qu’on vérifie au premier échange
  • Les parcours SumUp, comptes marchands, environnements, moyens, droits et outils consommateurs réellement concernés.
  • La chaîne commande–checkout_reference–checkout–transaction–refund–avoir et la source de vérité à chaque étape.
  • La commande témoin, les cinq contre-tests, la balance attendue et les droits de compensation.

Quelle lecture SumUp et quel effet dans notre SI prouvent ensemble le solde net de cette commande ?

Service SumUp, guide paiement, portefeuille PSP ou comptabilité ?

Quatre pages voisines, quatre responsabilités qui doivent rester nettes.

Nous raccordons SumUp à vos commandes et à votre gestion financière. Les données de paiement sont rapprochées des pièces et des opérations suivies dans vos autres outils.

Intégrateur SumUp

Le besoin porte sur un connecteur à construire ou reprendre

L’intégration proposée cadre checkouts, transactions, refunds, corrélation, rapprochement, supervision et run.

Guide paiement

Le besoin est de comprendre états, webhooks et résilience

Le guide garde l’intention pédagogique et aide à choisir le mode d’intégration avant un projet.

API Paiements

Le besoin compare plusieurs PSP ou un secours

Nous définissons les règles communes et les particularités de chaque prestataire pour gérer plusieurs moyens de paiement.

Pennylane

Le besoin porte sur factures, pièces et traitements comptables

La landing Pennylane conserve son périmètre finance ; elle ne remplace pas le connecteur SumUp.

Preuves paiement, commerce et réconciliation

Quatre réalisations prouvent les mécanismes utiles — aucune ne prétend être SumUp.

France Appro, Ciama et 1UP démontrent checkout, commande, ERP, statuts et reprise sur des périmètres réels. La limite fournisseur est écrite au lieu d’être masquée.

Pilotage des synchronisations Aster et PrestaShop pour Art’Sacs Intégration API France Appro : pilotage Aster–PrestaShop Voir le projet
  • 28 janvier 2020
  • Lecture ~11 min

Dawap a structuré dix traitements Aster–PrestaShop avec fenêtres de données, verrouillage, historique d’exécution et suivi des erreurs pour rendre les synchronisations réellement pilotables.

Intégration Aster et PrestaShop réalisée pour Art’Sacs Intégration API France Appro / Art’Sacs : catalogue Aster dans PrestaShop Voir le projet
  • 28 janvier 2020
  • Lecture ~14 min

Pour Art’Sacs, activité reprise depuis par France Appro, Dawap a relié Aster et PrestaShop afin de transformer le catalogue fournisseur, synchroniser les quantités, enrichir les fiches et préparer les commandes dropshipping. Les tâches, états et erreurs donnent aux équipes un flux pilotable plutôt qu’une synchronisation opaque.

Pipeline API Shopify et Wix transformant commandes et variantes pour Ciama Intégration API Ciama : pipeline API Shopify et Wix Voir le projet
  • 17 mars 2026
  • Étude de cas · 20 min

Ciama sélectionne quatre lecteurs spécialisés pour collecter commandes et variantes Shopify ou Wix, puis les normalise dans deux modèles communs. Le pipeline protège le compte et le canal, décide entre ajout et mise à jour, distribue les écritures et sécurise la désactivation après un snapshot complet.

Architecture du portail B2B 1UP Distribution relié à Algolia et Odoo Intégration API 1UP Distribution : d’Algolia aux commandes Odoo en 48 jours Voir le projet
  • 3 mars 2024
  • Étude de cas · 31 min

En 48 jours, Dawap a relié recherche Algolia, tarifs par compte, stock, paniers et documents à Odoo. La première plateforme Symfony servait clients, commerciaux et administration, avec une règle forte : séparer en deux commandes les quantités disponibles et le reliquat.

SumUp documente le paiement ; votre SI doit encore documenter sa conséquence.
SumUp documente le paiement ; votre SI doit encore documenter sa conséquence.
Les sources officielles ont été relues le 10 septembre 2026. Elles bornent objets, authentification, notifications et opérations documentées. Elles ne prouvent ni vos droits effectifs, ni vos moyens activés, ni vos règles de commande ou de comptabilité.
Les appels sont authentifiés côté serveur
SumUp documente des clés API gardées secrètes et des requêtes HTTPS. Les comptes, environnements et droits réellement disponibles restent vérifiés avant build.
checkout_reference relie l’intention à votre système
Le checkout porte montant, devise, marchand et référence définie par l’intégrateur. La transaction associée reste le résultat autoritatif du paiement.
La notification doit être confirmée par une lecture API
SumUp demande un accusé 2xx rapide et documente des retries. Le consommateur doit vérifier que l’événement a réellement eu lieu.
Le remboursement peut être complet ou partiel
L’opération cible une transaction et dépend des droits et contraintes métier SumUp ; l’avoir et l’écriture restent des responsabilités de votre SI.

Repères du projet

Une intégration SumUp jugée sur le même solde dans tous les outils.

Avant paiement

Référence, montant, devise, marchand, parcours et droits sont explicitement choisis.

Après notification

Checkout et transaction sont relus avant chaque effet irréversible dans le SI.

Après compensation

Refund, avoir, écriture et net métier convergent avant clôture.

Guides paiement et exploitation

Approfondir les états, l’idempotence, la réconciliation et les notifications.

Ces ressources détaillent les états de paiement, la prévention des doublons, le rapprochement et le traitement des notifications SumUp.

Paiement API : intégrer un PSP sans casser le run Intégration API Paiement API : intégrer un PSP sans casser le run Lire l'article
  • 19 août 2024
  • Lecture ~25 min

Le paiement via API ne se résume pas à encaisser. Il faut cadrer PaymentIntents, captures, refunds, webhooks, idempotence, wallets, KYC et réconciliation sans transformer le support en table de reprise manuelle. Ce cadrage protège marge, trésorerie et taux d’acceptation avec une preuve de reprise exploitable.

Idempotence API : éviter les doublons métier Intégration API Idempotence API : éviter les doublons métier Lire l'article
  • 25 mai 2025
  • Lecture ~46 min

Une intégration API peut sembler fonctionner correctement pendant des semaines, puis générer soudainement des doublons de commandes, de paiements ou d’écritures comptables. Ce type d’incident coûte rarement seulement du temps technique. Il mobilise aussi le support, la finance et le commerce dans le run métier.

Réconciliation API : corriger les écarts entre systèmes Intégration API Réconciliation API : détecter et corriger les écarts Lire l'article
  • 27 mai 2025
  • Lecture ~32 min

La réconciliation API devient utile quand chaque écart est relié à une source de vérité, à une preuve d’exécution et à une action bornée. Elle évite les resync massifs et transforme un doute sur la donnée en décision lisible. Le dispositif conserve la fenêtre, le watermark, la clé métier et le droit de correction avant tout replay ou compensation.

Webhooks API : intégrer le temps réel – guide 2025 Intégration API Webhooks API : intégrer le temps réel – guide 2025 Lire l'article
  • 16 août 2024
  • Lecture ~19 min

Un webhook utile ne se juge pas à sa vitesse, mais à sa capacité à garder un événement lisible, rejouable et sûr quand le run se tend. Ce repère aide à cadrer signature, idempotence, retries bornés et supervision pour éviter les doublons, les files opaques et les reprises manuelles coûteuses en production au quotidien.

Vos questions

Questions fréquentes sur l’intégration SumUp API

Les réponses à clarifier avant de relier les paiements SumUp à un portail, un e-commerce, un CRM, un ERP ou la comptabilité.

Quand faire appel à un intégrateur SumUp API ?

Quand un checkout SumUp doit déclencher des états fiables dans un portail, une commande, un CRM, un ERP ou la comptabilité, avec remboursements, rapprochement et reprise.

Quelle différence entre checkout et transaction SumUp ?

Le checkout porte l’intention et le parcours de paiement ; la transaction porte le résultat financier associé. Nous conservons leurs deux identités et leur lien avec la commande.

Un webhook SumUp suffit-il à valider un paiement ?

Non. La documentation SumUp demande de vérifier que l’événement a réellement eu lieu en appelant l’API concernée. Le webhook déclenche donc une relecture ciblée avant l’effet métier.

Comment éviter les doublons après un retry ?

Nous acquittons rapidement, journalisons le signal, dédupliquons la transition et relisons la ressource. Un événement rejoué ne recrée ni commande, ni facture, ni email.

Comment gérer un remboursement partiel ?

Le montant est contrôlé face au solde remboursable, puis le refund est relié à la transaction, au motif, à l’avoir, à l’écriture et au net métier restant.

Quel premier lot SumUp recommandez-vous ?

Une commande, un checkout, une transaction, un refund partiel et une clôture témoin, avec cinq cas d’échec. L’extension attend une chaîne d’identifiants et un solde prouvés.

Paiement et gestion

Service SumUp, guide générique, architecture multi-PSP et comptabilité se renforcent sans se remplacer.

Les profils derrière votre projet

Des interlocuteurs qui comprennent vos flux et votre métier.

Votre sujet : API SumUp : checkout, liens de paiement, refunds et reporting

Relier un ERP, un CRM ou une application métier demande de trancher les responsabilités autant que les contrats de données. Nous rapprochons architecture, usages et priorités pour livrer des échanges testables et maintenables.

Découvrir l’agence
Portrait de Jérémy Chomel

Direction · architecture

Jérémy Chomel

Conception des API et middlewares, mapping, reprise sur erreur, observabilité et mise en production.

  • API
  • Architecture
  • DevOps
Portrait d’Arnault Frier

Direction · produit

Arnault Frier

Analyse des processus métier, choix du premier flux utile et accompagnement des utilisateurs.

  • Produit
  • Cadrage
  • Formation
Portrait de Loïc Orue

Product Owner / Scrum Master

Loïc Orue

Product Owner / Scrum Master : backlog d’intégration, dépendances SI, recette et coordination des parties prenantes.

  • PO
  • Scrum
  • Backlog

Consultant senior mobilisable

La composition de l’équipe et sa disponibilité sont confirmées selon votre périmètre, les accès nécessaires et le niveau de service attendu.

Votre premier échange

Partons d’un paiement SumUp que vos équipes doivent expliquer

Dawap cadre les identifiants, lectures, événements, compensations et soldes avant d’ouvrir le connecteur à plus de commandes ou de consommateurs.

Cadrer mon intégration SumUp