Sommaire
En bref
- Ce tuto Make suit une chaîne simple : comprendre les composants, créer un déclencheur, connecter les applications, mapper les données, ajouter une action et lancer
Run once.- Une exécution réussie doit être contrôlée dans Make et dans l’application cible avant l’activation du scénario.
- L’historique, les bundles et les journaux aident à localiser les erreurs. Make documente aussi plusieurs stratégies de reprise.
- Les limites de forfait et l’interface citées correspondent aux pages de Make consultées le 22 octobre 2026. Elles peuvent évoluer.
Ce tuto Make décrit un parcours documentaire pour construire, tester et superviser une première automatisation. Il ne repose pas sur un test réalisé par la rédaction. Les fonctionnalités et limites rapportées viennent du Make Help Center et de la page tarifaire de Make, consultés le 22 octobre 2026.
L’exemple reste volontairement générique : une application source produit des données, puis une application cible les reçoit. Les réglages précis, les champs et les autorisations dépendront de vos applications, de votre compte et de votre forfait.
En bref

Commencez par identifier le déclencheur, les données qu’il produit et l’action attendue. Créez ensuite les connexions nécessaires, exécutez la source pour obtenir un bundle, puis mappez ses champs dans le module d’action.
Lancez Run once. Examinez les entrées, les sorties, les opérations et les crédits affichés, puis vérifiez le résultat dans l’application cible. Si un module échoue, consultez l’historique avant de choisir une stratégie de reprise.
N’activez la planification qu’après ces contrôles. Une fois le scénario en service, surveillez ses erreurs et sa consommation.
tuto Make : les notions à connaître avant de commencer

Les définitions qui suivent proviennent du Make Help Center consulté le 22 octobre 2026. La documentation citée ne donne pas toujours une date d’entrée en vigueur propre à chaque définition.
Scénario, module, connexion et bundle
Un scénario Make assemble un workflow automatisé. Chaque module appartient à une application et accomplit une tâche précise. Une connexion autorise Make à communiquer avec un service tiers, sous réserve des droits accordés par ce service.
Le bundle transporte les informations produites ou traitées par un module. Vous devez examiner son contenu pour savoir quels champs pourront alimenter la suite du scénario. Le guide officiel sur le mapping compare ce bundle à une boîte d’informations.
Déclencheur et modules d’action : dans quel ordre s’exécutent-ils ?
Le premier module déclenche le scénario. Il surveille une source, reçoit un événement ou recherche de nouvelles données. Les modules placés après lui s’exécutent ensuite dans l’ordre du scénario.
Un module d’action exploite les données reçues pour créer, modifier, transmettre ou traiter un élément dans une autre application. Les actions disponibles varient selon le connecteur choisi.
Comment les bundles multiplient les opérations
Selon la documentation Make consultée le 22 octobre 2026, une opération correspond à l’exécution d’un module qui vérifie ou traite des données. Un déclencheur compte une opération par vérification. S’il renvoie plusieurs bundles, chaque module aval s’exécute séparément pour chacun d’eux.
Cette mécanique pèse directement sur la consommation. Dix bundles envoyés vers deux modules d’action peuvent entraîner vingt exécutions de modules aval, auxquelles s’ajoute l’exécution du déclencheur selon les règles applicables. Ce calcul reste une estimation : il suppose que chaque bundle traverse les deux actions, sans filtre, erreur, agrégation ni fonction avancée facturée différemment.
Créer le premier scénario Make étape par étape
1. Créer un scénario et choisir l’application source
Connectez-vous à Make, puis cliquez sur Create scenario. Dans le Scenario Builder, utilisez le grand bouton plus pour ouvrir le sélecteur d’applications.
Recherchez l’application qui détient les données initiales. Ce choix fixe les déclencheurs disponibles.
2. Ajouter et configurer le module déclencheur
Sélectionnez un module de déclenchement, puis renseignez ses paramètres. Selon l’application, il pourra recevoir immédiatement un événement ou interroger périodiquement le service.
Les champs, la méthode de sélection des données et les réglages de départ dépendent du connecteur. Le brief documentaire ne couvre donc pas la configuration propre à chaque application tierce.
3. Enregistrer la configuration avant de poursuivre
Enregistrez le module après avoir choisi la connexion et rempli ses champs obligatoires. Cette étape stabilise la configuration avant l’ajout de l’action.
Contrôlez aussi la source surveillée, par exemple un formulaire, une feuille ou un dossier. Une erreur de sélection à ce stade peut produire un bundle inattendu ou aucun bundle.
Connecter les applications et vérifier leurs autorisations
4. Créer la connexion depuis le module
Make crée une connexion depuis le module qui en a besoin. Selon l’application, vous accorderez un accès OAuth ou saisirez des identifiants ou une clé.
Ne transposez pas la procédure d’un connecteur à un autre. Le fournisseur de l’application définit la méthode d’authentification et les droits demandés.
5. Contrôler le compte et les permissions accordées
Vérifiez d’abord que la connexion vise le bon compte. Dans Make, ouvrez ensuite Credentials, puis Connections. L’icône des permissions affiche les autorisations accordées lorsqu’elles sont exposées par la connexion.
Comparez ces droits à l’action prévue. Un scénario chargé d’écrire une donnée exige généralement davantage qu’un accès limité à la lecture, sous réserve du modèle d’autorisation de l’application concernée.
6. Repérer un périmètre d’autorisation insuffisant
La documentation Make indique que des scopes insuffisants peuvent déclencher une erreur. Examinez alors le message du module, les permissions visibles et les droits détenus par le compte dans l’application tierce.
Les sources fournies ne décrivent pas une procédure universelle de renouvellement ou de correction. Celle-ci dépend du service connecté.
Mapper et transformer les données dans Make
7. Produire un bundle exploitable avec le module source
Exécutez d’abord le module source afin qu’il récupère un exemple de données. Ouvrez sa bulle de résultat et inspectez le bundle obtenu.
Cette étape révèle les champs réellement disponibles. Si le déclencheur ne renvoie rien, le scénario s’arrête normalement après ce premier module.
8. Ajouter l’action et mapper les champs disponibles
Ajoutez l’application cible et choisissez son module d’action. Cliquez dans un champ de configuration, puis sélectionnez la valeur issue du module source dans le panneau de mapping.
Associez chaque donnée à un champ compatible. Un nom peut alimenter une zone de texte ; une date ou un nombre pourra exiger une transformation avant son envoi.
9. Nettoyer un texte avec trim() et replace()
trim() retire les espaces placés au début et à la fin d’un texte. replace() recherche une chaîne et la remplace par une autre.
Ces fonctions agissent sur la valeur reçue. Vérifiez donc le texte d’entrée dans le bundle et le texte transformé avant de transmettre le résultat.
10. Convertir et présenter un nombre avec parseNumber() et formatNumber()
parseNumber() convertit une chaîne numérique en nombre. Le séparateur décimal déclaré doit correspondre à l’écriture reçue.
formatNumber() produit ensuite la présentation demandée en appliquant les décimales et les séparateurs fournis. Gardez la conversion et l’affichage distincts : la première change le type exploitable, le second façonne sa représentation.
11. Convertir et formater une date avec parseDate() et formatDate()
parseDate() interprète un texte selon le format et, le cas échéant, le fuseau indiqués. Le texte doit correspondre aux jetons de format saisis.
formatDate() transforme une valeur de type date en texte. Si vous omettez le fuseau, Make utilise celui de l’organisation, d’après la documentation consultée le 22 octobre 2026. Ce réglage mérite un contrôle lorsque plusieurs équipes ou applications travaillent dans des fuseaux différents.
Filtrer les données et créer plusieurs routes
12. Ajouter une condition de filtre
Placez un filtre entre deux modules, puis définissez le champ contrôlé, l’opérateur et la valeur attendue. Seules les données conformes aux conditions franchiront ce point.
Un filtre peut écarter des traitements inutiles. Il ne constitue toutefois pas, à lui seul, une déduplication documentée.
13. Utiliser un routeur pour plusieurs traitements
Ajoutez un routeur lorsque les mêmes données doivent suivre plusieurs traitements. Chaque branche reçoit sa propre suite de modules.
Cette structure convient, par exemple, à deux destinations ou à deux traitements conditionnels. Chaque branche exécutée peut néanmoins augmenter le nombre d’opérations.
14. Vérifier les conditions propres à chaque route
Appliquez un filtre distinct à chaque route, puis contrôlez les cas limites avec des bundles représentatifs. Des conditions qui se recouvrent peuvent faire passer une même donnée dans plusieurs branches.
La documentation fournie établit le fonctionnement des routes et des filtres, mais ne prouve pas une exclusivité automatique entre les branches.
Tester le scénario Make avant son activation
15. Lancer une exécution manuelle avec Run once
Cliquez sur Run once dans la barre d’outils du Scenario Builder. Déclenchez ensuite un événement source compatible avec le scénario.
Cette exécution manuelle fait circuler un exemple de données. Elle ne démontre pas encore que tous les cas futurs seront correctement traités.
16. Examiner les entrées, sorties, opérations et crédits
Ouvrez les bulles affichées au-dessus des modules. Examinez les données d’entrée, les sorties, le nombre d’opérations et les crédits indiqués.
Suivez la valeur importante de module en module. Vous verrez où elle disparaît, change de type ou prend un format inattendu.
17. Contrôler le résultat dans l’application de destination
Ouvrez l’application cible et recherchez l’élément créé ou modifié. Vérifiez son contenu, son emplacement et les champs concernés.
Un module peut terminer son exécution sans produire un résultat métier conforme. Le contrôle dans l’application de destination complète donc l’examen technique réalisé dans Make.
Diagnostiquer les erreurs d’un scénario Make
Les causes ci-dessous figurent dans la documentation Make consultée le 22 octobre 2026. Les sources disponibles ne livrent toutefois pas une procédure complète et propre à chacune d’elles.
Le scénario s’arrête : vérifier si le déclencheur a produit un bundle
Ouvrez la bulle du déclencheur pendant l’essai ou retrouvez l’exécution dans l’historique. Si le premier module n’a produit aucun bundle, Make arrête normalement le flux à cet endroit.
Contrôlez la présence d’une donnée nouvelle, la source surveillée et les paramètres du déclencheur. Les vérifications propres au service tiers restent à consulter dans sa documentation.
Un module échoue : contrôler la connexion, le mapping et les champs obligatoires
Make cite parmi les causes d’échec les problèmes de connexion, le mapping invalide, les erreurs d’API et les données incorrectes. Un champ obligatoire absent peut notamment produire une BundleValidationError.
Inspectez le message associé au module, puis comparez ses entrées aux champs requis. Vérifiez aussi les permissions de la connexion. Le brief ne permet pas d’attribuer chaque message possible à une cause unique.
Le résultat a un format incorrect : inspecter la valeur d’entrée et sa transformation
Ouvrez l’entrée du module qui transforme la valeur, puis sa sortie. Vérifiez le type reçu, le séparateur décimal, le format de date et le fuseau.
Une transformation peut échouer ou produire un résultat différent lorsque la donnée réelle ne correspond pas au format déclaré. Appuyez le diagnostic sur le bundle observé, sans déduire le contenu à partir du seul nom du champ.
Retrouver les bundles et les journaux dans Scenario history
Ouvrez l’onglet History, choisissez l’exécution concernée, puis ouvrez Details. Make y donne accès aux bundles de sortie et aux journaux disponibles.
Remontez depuis le premier module qui affiche une valeur erronée ou une erreur. Cette méthode resserre la recherche sur l’étape où le flux change réellement.
Choisir une stratégie de reprise après erreur
Ignorer, reprendre ou retenter : distinguer les effets attendus
La documentation Make répertorie les gestionnaires Skip, Retry, Resume, Commit et Rollback. Leur choix dépend de ce que vous acceptez de perdre, de répéter ou de valider.
Skip écarte le traitement concerné. Retry retente l’opération. Resume poursuit avec une sortie de remplacement. Commit et Rollback agissent sur le traitement pris en charge, dans les limites transactionnelles des modules concernés.
Conserver une exécution incomplète pour une reprise
Une exécution incomplète peut conserver l’état et les données liés à un échec. Le gestionnaire Retry peut servir à stocker ces exécutions et à organiser une nouvelle tentative automatique ou manuelle.
Avant de l’utiliser, vérifiez si l’action échouée peut être répétée sans créer de doublon dans le service cible. Les sources du brief ne documentent aucun mécanisme général d’idempotence valable pour toutes les applications.
Comprendre la limite des actions externes non annulables
Make indique que Rollback ne peut pas annuler les actions effectuées par des modules dépourvus de transactions. Une écriture déjà réalisée dans une application externe peut donc subsister malgré l’échec ultérieur du scénario.
Documentez les effets irréversibles avant de choisir cette stratégie. Placez-les avec prudence dans l’ordre d’exécution.
Activer le traitement séquentiel lorsque l’ordre doit être préservé
Le réglage Process data in order oblige Make à terminer une exécution avant d’en commencer une autre. Il convient lorsque l’ordre des traitements compte.
Ce réglage sérialise les exécutions. La documentation fournie ne l’établit pas comme une protection générale contre les doublons ou les boucles logiques.
Activer, planifier et superviser l’automatisation Make
18. Activer le scénario après les vérifications
Un scénario nouvellement créé reste inactif par défaut. Après l’essai et le contrôle de la destination, activez-le avec le bouton ON/OFF.
Une fois actif, il suit sa planification. Conservez une trace des entrées attendues, des sorties, des erreurs prévues et de la reprise choisie avant ce passage en production.
19. Choisir entre webhook et interrogation périodique
Lorsqu’une application prend en charge les webhooks, la réception d’une requête déclenche normalement le scénario immédiatement. Si elle n’en fournit pas, Make peut interroger périodiquement le service au moyen d’un déclencheur de polling.
Le connecteur détermine les possibilités réelles. Le besoin métier fixe ensuite le délai acceptable.
20. Régler la fréquence selon le délai acceptable
Ouvrez Schedule settings et choisissez une fréquence compatible avec votre forfait. Une interrogation rapprochée réduit l’attente, mais multiplie les vérifications et peut accroître la consommation de crédits.
Choisissez l’intervalle à partir d’un délai concret : combien de temps une nouvelle donnée peut-elle attendre avant son traitement ? La réponse évite de planifier chaque scénario à la fréquence maximale.
21. Suivre les exécutions, les erreurs et la consommation
Consultez régulièrement l’historique, les détails d’exécution, les bundles et les journaux. Suivez aussi les opérations et crédits affichés dans l’interface.
Une supervision exploitable associe chaque erreur à une action : retenter, corriger la donnée, renouveler la connexion ou intervenir manuellement. La procédure exacte d’alerte n’est pas couverte par les sources fournies.
Maîtriser les crédits et les limites du forfait Make
Ce que la page tarifaire affichait pour Free et Core
La page tarifaire officielle de Make affichait les éléments suivants lors de sa consultation le 22 octobre 2026 :
- l’offre Free comprenait 1 000 crédits par mois et imposait un intervalle minimal de 15 minutes entre les exécutions ;
- l’offre Core annonçait une planification pouvant descendre à la minute.
La page indiquait aussi que la plupart des actions consomment un crédit, certaines fonctions avancées pouvant en demander davantage. Ces données décrivent l’affichage observé à cette date. Elles ne figent ni le prix public de Core, absent du brief, ni les conditions futures.
Pour choisir entre les offres, comparez les limites documentées à la consommation et à la fréquence requises par votre scénario.
Estimer une consommation à partir des modules et des bundles
Voici une estimation pédagogique, non un relevé observé. Hypothèses : une vérification du déclencheur, trois bundles produits, deux modules aval exécutés pour chaque bundle, aucun filtre bloquant, aucune erreur et aucun surcoût lié à une fonction avancée.
Le déclencheur représente une opération de vérification. Les modules aval représentent ensuite 3 bundles × 2 modules, soit 6 opérations. L’exécution atteindrait donc 7 opérations dans ce modèle simplifié.
Le résultat réel dépend du scénario, des branches parcourues, des agrégations, des erreurs et des règles de crédit applicables. Consultez les compteurs de Make pour mesurer une exécution réelle.
Limiter les pointes d’un déclencheur instantané
Dans Schedule settings, Make documente un nombre maximal de démarrages par minute pour les scénarios à déclencheur instantané. Lorsque le flux dépasse cette limite, Make place les requêtes suivantes en file et les traite progressivement.
Cette limite lisse une pointe de trafic. Selon la conception du webhook, une réponse HTTP 429 peut aussi intervenir.
Ce que la limitation de débit ne résout pas
La file d’attente ne prouve pas qu’un événement est unique. Elle ne bloque pas non plus une boucle créée par la logique du scénario.
Vous devez traiter séparément l’identité des événements, les écritures répétées et les interactions capables de redéclencher la source. Le brief ne fournit pas de mécanisme général documenté pour résoudre ces risques.
Éviter les traitements inutiles sans promettre une déduplication
Réduire les exécutions avec une fréquence et des filtres adaptés
Adaptez le polling au délai réellement acceptable. Ajoutez des filtres avant les actions coûteuses ou inutiles pour certaines données, puis contrôlez les bundles qui traversent chaque route.
Ces choix réduisent les traitements dans les cas qu’ils excluent. Ils ne garantissent pas qu’une donnée identique ne repassera jamais.
Mettre en file les pointes grâce à la limite de débit
Fixez un nombre maximal de démarrages par minute pour un déclencheur instantané lorsque votre scénario doit absorber des pointes. Make conservera les requêtes excédentaires dans une file et les relâchera selon la limite configurée.
Surveillez le retard accumulé et les réponses du webhook. Une file maîtrise le rythme, mais peut allonger le délai de traitement.
Documenter séparément les besoins de déduplication et d’anti-boucle
Les sources fournies ne documentent ni mécanisme général d’idempotence ou de déduplication, ni protection complète contre les boucles logiques. N’attribuez donc pas ces garanties aux filtres, à la limitation de débit ou au traitement séquentiel.
Ajoutez ces deux risques à votre fiche d’exploitation. Décrivez l’événement qui pourrait revenir, l’action qui pourrait redéclencher le scénario et la règle métier attendue. La solution technique devra ensuite être vérifiée dans la documentation des connecteurs et du compte concernés.
tuto Make 2026 : créer un scénario et vérifier ses erreurs
Un scénario fiable relie une chaîne contrôlable : déclencheur, bundle, mapping, transformation, filtre éventuel, action, vérification dans la destination, reprise et supervision. Run once et l’historique montrent ce que les modules ont réellement reçu et produit. Les compteurs éclairent ensuite la consommation.
La prochaine étape consiste à rédiger une fiche d’exploitation pour votre scénario. Notez le déclencheur, les données entrantes, les étapes, les sorties, les erreurs attendues, la stratégie de reprise, la fréquence, les règles de supervision et la consommation estimée. Lancez enfin une exécution manuelle contrôlée avant toute activation planifiée.