Make Intégrations : Guide Complet 2026

Make (ex-Integromat) ne se joue pas sur le nombre d'applications affichées en page d'accueil, mais sur la façon dont ces intégrations s'assemblent : un graphe visuel, avec branches, boucles et agrégateurs, là où la plupart des concurrents empilent des étapes dans une liste verticale.

Ce guide couvre l'essentiel : ce qu'est réellement une intégration Make, le catalogue 2026, les modules HTTP et Webhooks, l'authentification, les erreurs, et la facturation à l'opération — le point qui décide si Make vous coûte 9 $ ou 300 $ par mois.

Module, scénario, intégration : le vocabulaire qui compte

Dans Make, une « intégration » n'est pas une case à cocher. C'est une application du catalogue, et chaque application expose une série de modules. Le module est l'unité de base, la bulle qu'on pose sur la toile, en trois familles : les déclencheurs (triggers) qui démarrent l'exécution, les actions qui créent ou mettent à jour, et les recherches (searches) qui renvoient zéro, un ou plusieurs résultats. Google Sheets ne vaut donc pas « une intégration » : l'app apporte une trentaine de modules distincts. Jugez un connecteur au nombre de modules qu'il expose, pas à sa présence au catalogue.

Le scénario, lui, est l'assemblage complet : du déclencheur au dernier module, avec ses routeurs, ses filtres et ses gestionnaires d'erreurs. La distinction n'est pas cosmétique, c'est elle qui détermine la facture : Make ne facture pas les intégrations connectées, il facture les modules exécutés. Les données circulent sous forme de « bundles », et un module qui reçoit dix bundles s'exécute dix fois.

Pour aller plus loin, consultez notre guide complet.

Le catalogue 2026 : plus de 3 000 apps, mais lesquelles comptent ?

Make annonce plus de 3 000 applications prêtes à l'emploi, dont environ un millier maintenues par ses propres équipes ; le reste vient des éditeurs partenaires et de la communauté. Le chiffre bouge chaque mois : ce qui compte, c'est la profondeur des connecteurs que vous utiliserez vraiment.

Les blocs les plus solides, présents dans la majorité des scénarios en production : Google Workspace (Sheets, Drive, Gmail, Agenda, Docs), colonne vertébrale de la plupart des automatisations ; Notion et Airtable, avec une gestion fine des propriétés et des champs, relations comprises ; Slack et Discord pour les alertes ; Stripe pour les événements de paiement ; HubSpot, Pipedrive et Salesforce côté CRM ; Shopify et WooCommerce côté e-commerce ; OpenAI et les autres fournisseurs de modèles pour la génération de texte ou la transcription.

La qualité n'est pas homogène pour autant : les connecteurs maison couvrent l'API en profondeur, quand certains connecteurs communautaires se limitent à deux ou trois modules. Le SaaS français est particulièrement inégal sur ce terrain — sans que ce soit bloquant, comme le montre la section suivante.

HTTP et Webhooks : pourquoi on n'est jamais bloqué

C'est le point que les comparatifs oublient, et sans doute le meilleur argument de Make : l'absence de connecteur natif n'est jamais un mur. Le module HTTP émet une requête vers n'importe quelle API — méthode (GET, POST, PUT, PATCH, DELETE), URL, en-têtes, corps JSON ou form-data. La variante « Make a request » couvre la majorité des cas, et des variantes dédiées gèrent le cycle OAuth 2.0 de bout en bout. La réponse revient en JSON brut, qu'un module « Parse JSON » transforme en champs mappables exactement comme un connecteur natif.

Dans l'autre sens, le module Webhooks génère une URL unique à coller dans l'outil externe. Make capture le premier appel reçu pour en déduire la structure des données, puis déclenche le scénario à l'instant où la donnée arrive — pas au prochain cycle d'interrogation. Un webhook peut même répondre à l'appelant (« Webhook response »), ce qui transforme un scénario en petite API interne. Si votre outil expose une API documentée, il est intégrable, connecteur ou pas.

Authentifier ses connexions : OAuth ou clé API

Une connexion est un objet réutilisable, partagé entre tous les scénarios de l'organisation. L'OAuth 2.0 ouvre une fenêtre de consentement chez l'éditeur : vous validez les autorisations, Make conserve un jeton de rafraîchissement et gère seul le renouvellement. Le plus confortable, mais le plus fragile — un changement de mot de passe, une révocation côté administrateur ou une modification des périmètres invalide la connexion, et tous les scénarios qui l'utilisent tombent en même temps.

L'autre mode, la clé API ou le jeton personnel, est plus stable mais à votre charge : rotation, stockage propre, surveillance de l'expiration. Certaines applications, Google en tête, permettent en plus de créer votre propre client OAuth pour ne pas dépendre des quotas partagés de Make. Dans les deux cas : connectez un compte de service dédié, jamais le compte personnel d'un collaborateur — le jour où cette personne part, quinze scénarios de production s'arrêtent d'un coup.

Erreurs, reprises et exécutions incomplètes

Par défaut, une erreur non gérée interrompt l'exécution : les modules déjà passés ont agi, les suivants non. Après plusieurs échecs, Make désactive le scénario.

Chaque module accepte un gestionnaire d'erreurs, une branche rattachée d'un clic droit qui se termine par une directive : Resume pour continuer avec une valeur de repli, Ignore pour passer au bundle suivant, Break pour mettre l'exécution en file d'attente et la rejouer automatiquement, Rollback pour annuler ce qui est annulable. Le bon réflexe : Break sur tout ce qui dépend d'une API tierce, Ignore sur le cosmétique, Resume quand une valeur par défaut a du sens. Activez aussi le stockage des exécutions incomplètes : les runs échoués sont conservés avec leurs données et rejouables une fois la cause corrigée.

Facturation à l'opération : ce qui coûte vraiment cher

Le modèle est limpide et impitoyable : Make facture chaque module exécuté. Depuis le 27 août 2025, l'unité s'appelle « crédit » et non plus « opération », avec une conversion à l'identique — un module standard vaut 1 crédit. Un scénario de 8 modules qui tourne 500 fois dans le mois consomme donc 4 000 crédits, pas 500 : c'est l'erreur de calcul numéro un des nouveaux venus.

Trois pièges reviennent. Les boucles d'abord : un module de recherche qui renvoie 20 résultats ne coûte qu'un crédit, mais chaque module placé derrière s'exécutera 20 fois, soit 20 crédits par module. Les déclencheurs planifiés ensuite : un scénario réglé toutes les 5 minutes se réveille environ 8 600 fois par mois et consomme le crédit de son déclencheur même sans rien à traiter. Les modules IA natifs enfin, qui ne coûtent plus un crédit forfaitaire mais un montant variable selon les tokens traités ou la taille des fichiers.

Grille tarifaire 2026 : le plan Free offre 1 000 crédits par mois, 2 scénarios actifs et un intervalle minimum de 15 minutes entre deux déclenchements. Les plans payants démarrent à 9 $ par mois pour Core, 16 $ pour Pro et 29 $ pour Teams (facturation mensuelle, environ 15 % de remise à l'année), tous trois avec 10 000 crédits inclus et une planification à la minute. Ce qui sépare ces paliers n'est pas le volume mais les fonctions : variables personnalisées et exécution prioritaire pour Pro, gestion des rôles pour Teams.

Concevoir un scénario économe

La consommation se pilote, et les leviers sont peu nombreux. D'abord le filtre placé le plus tôt possible, juste après le déclencheur. Ce qui coûte, ce sont les modules situés derrière, et un bundle arrêté par un filtre ne les atteint jamais. Filtrer sur un statut ou un montant avant d'appeler OpenAI divise couramment la facture par trois.

Le deuxième : les agrégateurs. Un Array aggregator ou un Text aggregator regroupe N bundles en un seul, et les modules suivants s'exécutent une fois au lieu de N — un récapitulatif Slack agrégé plutôt que quarante messages unitaires, ce sont 39 crédits économisés à chaque passage. L'itérateur fait l'inverse : il éclate un tableau en bundles séparés. Indispensable, mais à placer après le filtre, jamais avant. Deux réflexes complètent le tableau : préférer un webhook instantané à un déclencheur planifié à haute fréquence, et privilégier les écritures en lot plutôt qu'une boucle de mises à jour ligne par ligne.

Make, Zapier ou n8n : lequel pour quel usage

Face à Zapier, l'écart de prix est net. Zapier facture à la tâche : 100 tâches par mois en gratuit, 750 tâches sur le plan Professional à 19,99 $ par mois en engagement annuel (29,99 $ au mois). Rapporté au volume, 10 000 crédits Make à 9 $ ne se compare pas. En contrepartie, Zapier reste plus simple pour un enchaînement linéaire et son catalogue est encore plus large : c'est parfois lui qui aura le connecteur exotique dont vous avez besoin.

n8n change carrément d'unité de compte : il facture à l'exécution de workflow, pas au module. Un workflow de 50 nœuds coûte une exécution, comme un workflow de 2 nœuds. Le cloud Starter est à 24 $ par mois pour 2 500 exécutions, et la version auto-hébergée (Community Edition) est gratuite et sans limite d'exécutions sur un simple VPS. Imbattable sur les scénarios longs — à condition d'assumer l'hébergement et la supervision.

L'arbitrage : Make quand la logique est complexe mais que l'équipe n'est pas composée de développeurs ; Zapier pour trois automatisations simples ; n8n avec une compétence technique interne, des données sensibles ou un volume qui rendrait toute facturation à l'opération déraisonnable.

Notre verdict

Make reste en 2026 le meilleur rapport puissance/prix de l'automatisation sans code. Les modules HTTP et Webhooks garantissent qu'aucun outil documenté ne vous sera fermé, la gestion d'erreurs par module n'a pas d'équivalent chez Zapier, et 10 000 crédits à 9 $ par mois placent la barre très bas. Deux réserves réelles : la facturation au module punit les scénarios mal conçus, et le mapping des données imbriquées demande plusieurs semaines de pratique. Notre analyse détaillée est dans notre comparatif dédié.

Concrètement : validez un scénario de bout en bout sur le plan gratuit, passez à Core dès que la logique est stable, et surveillez le compteur de crédits la première semaine. Si le quota fond, le coupable est presque toujours le même — un itérateur placé avant le filtre.