Si quelqu'un, dans votre organisation, recopie chaque semaine des données d'un logiciel vers un autre, vous connaissez déjà le problème. La question n'est plus « faut-il intégrer ses logiciels ? », mais « comment le faire sans créer une nouvelle fragilité ». Cet article explique les mécanismes (API, webhooks, fichiers), les décisions de fond (sens de la synchronisation, source de vérité) et les exigences qui font la différence entre une intégration qui dure et une qui casse au premier incident.
Les symptômes de la double saisie
La double saisie se reconnaît rarement à son nom. Elle se manifeste plutôt par des phénomènes bien concrets :
- une même fiche client existe en deux versions légèrement différentes selon l'outil consulté;
- un rapport « officiel » est refait à la main parce que personne ne fait confiance aux chiffres automatiques;
- une tâche de ressaisie revient chaque fin de mois, avec une personne désignée qui connaît « les trucs »;
- une erreur de frappe découverte tard oblige à corriger à plusieurs endroits;
- l'arrivée d'un nouvel employé ralentit tout, parce que la procédure vit dans la tête de quelqu'un.
Ces symptômes ont une source commune : plusieurs systèmes détiennent la même information sans qu'aucun lien contrôlé n'existe entre eux. Le but d'une intégration n'est donc pas « de faire parler des logiciels », mais de décider qui détient quoi et de rendre le transfert fiable.
Trois façons d'intégrer ses logiciels
Les API
Une API (interface de programmation) permet à un logiciel d'interroger ou de modifier un autre logiciel selon des règles publiées. Dans le monde du Web, il s'agit le plus souvent d'une API HTTP. L'OpenAPI Initiative décrit la spécification OpenAPI comme « un format de description neutre » des API distantes fondées sur HTTP : elle recense les interactions permises, les paramètres, les valeurs de retour et les formats de données. Selon l'initiative, une telle description facilite la génération de documentation cohérente avec l'API, la génération de code de base et la création de serveurs fictifs pour tester tôt, même avant que le code du fournisseur soit écrit.
Pour une organisation, la leçon est pratique : avant de choisir une approche, vérifiez si les logiciels concernés publient une description d'API à jour. C'est un bon indicateur de la facilité (et du coût) d'intégration.
Les webhooks
Un webhook inverse la logique : au lieu d'interroger régulièrement l'autre système, vous lui indiquez une adresse, et il vous prévient lorsqu'un événement se produit. La documentation de Stripe, un fournisseur de paiement qui utilise abondamment ce mécanisme, illustre bien les précautions à prévoir. Son guide demande notamment de vérifier la signature de chaque requête, de répondre rapidement par un code de succès (2xx) avant tout traitement complexe, et de traiter les événements de façon asynchrone, par une file, pour résister aux pointes de volume. Il précise aussi que l'ordre de livraison n'est pas garanti et qu'un même événement peut arriver plus d'une fois.
Ces principes valent bien au-delà de ce fournisseur : tout récepteur de webhooks doit être pensé pour les doublons, le désordre et la vérification d'authenticité.
Les fichiers échangés
Certains systèmes, souvent plus anciens, n'offrent ni API ni webhooks, mais savent exporter ou importer des fichiers (CSV, XML, etc.). Une intégration par fichiers peut être parfaitement raisonnable pour des volumes modestes ou des échanges périodiques, à condition de traiter les mêmes sujets que pour une API : format documenté, validation à la réception, contrôle des doublons, journal des traitements. Le risque principal est la dépendance à une personne qui « dépose le fichier au bon endroit ».
Synchronisation unidirectionnelle ou bidirectionnelle
C'est la décision de conception la plus structurante.
Unidirectionnelle : un système envoie, l'autre reçoit. C'est plus simple à comprendre, à tester et à dépanner. Elle convient bien aux cas où une information naît clairement à un seul endroit, par exemple une commande saisie dans un outil et reprise ensuite par la facturation.
Bidirectionnelle : les deux systèmes peuvent modifier la même information et doivent se synchroniser dans les deux sens. C'est parfois nécessaire, mais cela crée des questions difficiles : que faire si la même fiche est modifiée des deux côtés avant la prochaine synchronisation ? Quelle modification gagne ? Sur quelle base décide-t-on ?
Une règle prudente consiste à partir de l'unidirectionnel et à ne passer au bidirectionnel que si un besoin d'affaires clair l'exige, champ par champ plutôt que pour tout l'objet.
Désigner une source de vérité
Pour chaque donnée partagée (client, produit, employé, facture) et, au besoin, pour chaque champ, désignez une source de vérité : le système autorisé à créer ou à corriger cette donnée. Les autres systèmes en reçoivent une copie, selon des règles de synchronisation documentées. Concrètement :
- dressez la liste des données partagées;
- attribuez à chacune un système propriétaire;
- documentez les règles de correspondance (par exemple, quel identifiant relie un client dans l'outil A à son homologue dans l'outil B);
- interdisez, dans les systèmes secondaires, la modification des champs gérés ailleurs, ou rendez-la visible comme une exception.
Sans cette décision, aucune technologie ne vous évitera de nouveaux écarts de données.
Gérer les erreurs et les reprises
Une intégration finira par échouer : réseau coupé, service indisponible, donnée invalide, changement de format. Le critère de qualité n'est pas l'absence d'erreur, mais le comportement quand elle survient.
Rendre les opérations répétables
Le glossaire de MDN définit une méthode HTTP idempotente comme une méthode dont l'effet voulu sur le serveur est le même qu'on envoie la requête une fois ou plusieurs fois. Les méthodes GET, HEAD, OPTIONS, PUT et DELETE sont idempotentes; POST et PATCH ne sont pas garanties idempotentes. MDN en tire la conséquence : un client peut réessayer sans crainte une requête idempotente quand il ignore si elle est parvenue au serveur. À l'inverse, répéter un POST peut créer un doublon (l'exemple de MDN est l'ajout d'une ligne à chaque envoi).
Pour une intégration, cela signifie concevoir les échanges pour qu'un rejeu ne duplique rien : identifiants uniques, mise à jour par remplacement plutôt que création aveugle, et, côté webhooks, conservation des identifiants d'événements déjà traités, comme le recommande Stripe.
Respecter les limites du fournisseur
Quand un service juge que vous envoyez trop de requêtes, il peut répondre 429 (« Too Many Requests »), un mécanisme appelé limitation de débit. Il peut ajouter un en-tête Retry-After indiquant le délai d'attente, en secondes ou sous forme de date. MDN précise que la prise en charge de cet en-tête varie selon les clients et les serveurs. Lorsqu'il est présent et valide, respectez le délai indiqué; s'il est absent ou inutilisable, prévoyez un délai d'attente progressif par défaut.
Prévoir la file des cas en échec
Une bonne intégration ne se contente pas de réessayer indéfiniment. Elle limite le nombre de tentatives, met de côté les cas qui échouent toujours, et alerte une personne désignée avec assez de contexte pour corriger. Elle permet aussi de rejouer un lot après la correction du problème de fond.
Sécuriser les accès
Relier deux logiciels, c'est ouvrir une porte entre eux. L'OWASP, organisme reconnu en sécurité applicative, tient une liste des dix principaux risques propres aux API (édition 2023). Plusieurs concernent directement les intégrations :
- Autorisation au niveau des objets : un point d'accès qui reçoit un identifiant peut permettre d'accéder à des données qui ne devraient pas être accessibles.
- Authentification défaillante : une gestion fragile des connexions ou des jetons permet d'usurper une identité.
- Autorisation au niveau des propriétés et des fonctions : des vérifications manquantes sur certains champs ou certaines fonctions exposent ou modifient des données sans permission.
- Consommation de ressources non restreinte : sans limites d'usage, une API peut être surchargée ou entraîner des coûts élevés lorsqu'elle s'appuie sur des services payants.
- Consommation non sécurisée d'API : on fait trop confiance aux données d'une API tierce, que des attaquants peuvent cibler pour atteindre votre système.
Ce dernier point est souvent oublié : vos données reçues d'un partenaire doivent être validées comme toute autre entrée.
Côté pratique, retenez au minimum :
- un compte de service dédié à l'intégration, avec les droits strictement nécessaires (principe du moindre privilège);
- des secrets (clés, jetons) stockés hors du code et renouvelables;
- des connexions chiffrées (HTTPS/TLS) entre les systèmes : MDN avertit que l'authentification Basic, qui encode le nom d'utilisateur et le mot de passe de façon réversible, serait « complètement non sécuritaire » sans connexion sécurisée (HTTPS/TLS);
- la vérification de l'authenticité des appels entrants, par exemple la signature des webhooks.
Journaliser pour comprendre, sans exposer
Quand un client demande « pourquoi cette commande n'est-elle jamais arrivée ? », seul un journal permet de répondre. Le guide de journalisation de l'OWASP recommande de consigner les événements de sécurité (échecs d'authentification ou d'autorisation, échecs de validation), les erreurs applicatives, les changements de configuration et l'accès aux données sensibles ou leur exportation.
Le même guide demande de ne pas inscrire en clair dans les journaux les mots de passe, jetons d'accès, clés, chaînes de connexion ni les renseignements personnels sensibles : ils doivent être retirés, masqués ou hachés. Il recommande aussi de contrôler qui peut lire les journaux, de détecter toute altération et d'utiliser des formats structurés plutôt que du texte libre. En clair : un journal utile à l'exploitation ne doit pas devenir une seconde fuite de données.
Tester avant, pendant et après la mise en service
Une intégration se teste sur plusieurs plans :
- Cas nominaux : une donnée valide circule correctement d'un système à l'autre.
- Cas limites : champs vides, caractères accentués, très grands volumes, doublons.
- Pannes simulées : service indisponible, réponse lente, 429, rejeu d'un même événement, événements dans le désordre.
- Rapprochement : comparaison périodique des deux systèmes pour détecter tout écart silencieux.
- Environnement d'essai : si le fournisseur en offre un, utilisez-le avant d'impliquer des données réelles.
La description OpenAPI, quand elle existe, aide à bâtir ces essais : l'OpenAPI Initiative souligne qu'elle permet de simuler l'API pour tester tôt.
Prévoir la maintenance
Une intégration n'est jamais « terminée ». Les fournisseurs font évoluer leurs API, les clés expirent, les volumes changent, les processus d'affaires aussi. Prévoyez dès le départ :
- une personne responsable de l'intégration, avec un suppléant;
- une documentation à jour des flux, des correspondances de champs et des procédures de reprise;
- une veille sur les avis de changement des fournisseurs;
- un inventaire des intégrations en place (l'OWASP classe d'ailleurs la gestion déficiente de l'inventaire d'API parmi les dix risques);
- des alertes sur les échecs répétés.
Questions fréquentes
Faut-il toujours passer par une API ? Non. Une API est généralement préférable lorsqu'elle existe, mais un échange de fichiers bien encadré peut suffire pour des besoins simples ou des logiciels plus anciens.
Par où commencer ? Par un inventaire des doubles saisies actuelles : qui ressaisit quoi, à quelle fréquence, avec quelles erreurs constatées. Cet exercice indique où l'intégration apporte le plus et dans quel ordre agir.
Comment éviter les doublons dans un échange automatique ? Par des identifiants uniques, des opérations conçues pour être rejouées sans effet de bord, et, côté webhooks, par la conservation des identifiants d'événements déjà traités.
Conclusion
Intégrer ses logiciels est avant tout un exercice de clarté : décider qui détient chaque donnée, dans quel sens elle circule, comment on réagit quand un échange échoue, qui y a accès et comment on en garde la trace. La technologie (API, webhooks, fichiers) vient ensuite. Si vous avez déjà identifié vos doubles saisies, vous avez fait le plus difficile : décrire le problème.
Les solutions KTMA qui peuvent vous aider
Vous avez une situation précise en tête ? Parler de mon projet.
Sources
- OWASP API Security Top 10 (édition 2023) (consulté le )
- OpenAPI Initiative : Introduction to the OpenAPI Specification (consulté le )
- MDN Web Docs : Idempotent (glossaire) (consulté le )
- MDN Web Docs : 429 Too Many Requests (consulté le )
- MDN Web Docs : Retry-After (consulté le )
- MDN Web Docs : HTTP authentication (consulté le )
- Stripe : Receive Stripe events in your webhook endpoint (consulté le )
- OWASP Logging Cheat Sheet (consulté le )

