Formation Automatisation avec Make avec des Cas Concrets

Make.com est une plateforme d'automatisation visuelle qui permet de connecter des applications entre elles sans coder. Elle fonctionne selon une logique de scénarios composés de modules.

Notes à retenir:

? Scénario

Un scénario est un flux de travail automatisé. Il commence par un déclencheur (ex. : formulaire rempli) suivi d'une ou plusieurs actions (ex. : ajouter des données, envoyer un email).

? Module

Chaque module représente une application métier (comme Gmail, Notion, OpenAI...) ou une fonction logique (filtre, boucle, variable…). Il exécute une tâche précise.

⚡ Les 3 types de déclencheurs

• Instantané (⚡) : le scénario se déclenche immédiatement lorsqu’un événement survient (ex. : nouveau formulaire Typeform).

• Programmé (⏰) : déclenchement à une fréquence définie (ex. : tous les jours à 8h).

• Manuel (➡) : le scénario démarre uniquement si tu cliques sur Run once.

?Bundle

Un bundle, c’est une collection de données que Make traite à chaque étape d’un scénario.

Par exemple : Une ligne dans un Google Sheets peut contenir plusieurs informations (nom, prénom, email, etc.). Lorsqu’elle est lue par Make, toutes ces données sont regroupées dans ce qu’on appelle un bundle. C’est ce bundle qui circule ensuite dans le scénario, de module en module.

✅ Règles de bonnes pratiques dans Make

Pour garantir la fiabilité et la lisibilité des automatisations, il est recommandé de suivre les principes suivants :

? Organisation & clarté

• Toujours nommer les scénarios de manière explicite (ex. : Automatisation devis).

• Nommer chaque module en fonction de la tâche qu’il exécute.

• Organiser les scénarios dans des dossiers thématiques selon leur usage (ex. : Prospection, RH, Facturation).

• Utiliser les templates proposés par Make pour démarrer plus rapidement ou s’inspirer.

  
  

? Tests & exécutions

• Tester chaque module individuellement pour s’assurer que les données sont correctement traitées.

• Utiliser le mode Run once avant toute mise en production.

• Vérifier les bundles retournés pour comprendre la structure des données manipulées.

  
  

? Sauvegarde & maintenance

• Sauvegarder régulièrement après chaque modification.

• Exporter les blueprints des scénarios critiques pour conserver une copie ou faciliter la duplication.

• Documenter les scénarios via la fonction de notes internes pour faciliter la compréhension lors de mises à jour futures.

Ce chapitre aborde deux notions fondamentales dans Make :

• La gestion des opérations, indispensable pour maîtriser sa consommation et optimiser son abonnement.

• La manipulation des dates, cruciale pour configurer des scénarios précis, comme les envois planifiés, les filtres temporels ou les documents datés.

Ces deux notions sont souvent sous-estimées mais jouent un rôle essentiel dans la stabilité, l’efficacité et la lisibilité des automatisations professionnelles.

Notes à retenir:

? 1. Les opérations dans Make

• Une opération correspond à une action effectuée par un module.

• Le premier module d’un scénario (souvent un déclencheur comme Watch New Rows) consomme toujours une seule opération, peu importe le nombre d’éléments.

• Les modules suivants consomment autant d'opérations que de bundles qu’ils traitent.

  Exemple : un scénario qui lit 5 lignes et envoie 5 emails consomme 1 (lecture) + 5 (envois) = 6 opérations.

• Le plan gratuit comprend 1 000 opérations / mois et 2 scénarios actifs.

• Les plans payants démarrent à 10 000 opérations / mois.

  
  

? 2. Utilisation du module Set Variable

• Le module Set Variable permet de créer une valeur réutilisable dans tout le scénario (par exemple : une date, un identifiant, un lien...).

• Très utile lorsqu’une même valeur est utilisée dans plusieurs modules pour éviter de la reconfigurer à chaque étape.

  
  

? 3. Manipulation des dates

• now : valeur par défaut représentant la date et l’heure actuelles.

• formatDate() : permet de personnaliser l'affichage d’une date selon un format donné (DD/MM/YYYY, YYYY-MM-DD, etc.).

• On peut remplacer les / par des - si un format particulier est requis par une base de données ou un fichier.

• Il est possible de soustraire ou ajouter des jours, heures, minutes, etc.

  • addDays(now; -7) donne la date il y a une semaine.

  • addDays(now; 2) donne la date dans deux jours.

    
    

?Bonnes pratiques

• Toujours tester les formules de date dans un module isolé avant de les intégrer à un scénario critique.

• Bien comprendre sa consommation d’opérations pour ne pas dépasser son quota, notamment lors de l’itération sur plusieurs bundles.

• Utiliser Set Variable pour améliorer la lisibilité et réduire les erreurs dans les scénarios complexes.

• S’assurer que les formats de date sont compatibles avec les outils tiers (ex. : Airtable, Google Sheets, Notion).

La gestion des erreurs est une étape essentielle mais souvent négligée lors de la création de scénarios Make.

Même si un scénario fonctionne correctement lors des tests, il peut échouer à tout moment en production pour plusieurs raisons.

Ce chapitre vous apprend à identifier les causes les plus fréquentes d’erreurs dans vos flux de travail et à utiliser les gestionnaires d’erreurs (Error Handlers) de Make pour garantir la continuité de vos automatisations.

Vous découvrirez également les bonnes pratiques pour notifier les erreurs ou éviter les interruptions critiques.

Notes à retenir:

1. Causes fréquentes d’erreurs dans Make
? Champs obligatoires non remplis (ex. : Notion ne supporte pas les champs vides)
? Limites d’API dépassées (erreur 429 "Too Many Requests")
? Erreurs temporaires côté application (maintenance, bugs, etc.)
? Problèmes d’authentification ou connexions expirées (ex. : Gmail, Google Drive)

2. Principaux gestionnaires d’erreurs dans Make

? Break
→ Pour les appels API répétitifs (HTTP request, scrapping…)
→ Paramètres à définir :
-Nombre d’essais (number of attempts)

-Délai entre les essais (interval)

-Dans les paramètres du scénario, activez "Allow storing of Incomplete Executions" pour permettre aux gestionnaires d’erreurs de s’exécuter correctement.

? Ignore
→ À utiliser quand une erreur ne doit pas bloquer tout le scénario
→ Utile par exemple avec Notion si des champs sont manquants

? Commit / Rollback
→ Spécialement pour les bases de données relationnelles (Postgres, MySQL)
→ Continue : permet de conserver les données insérées avant l’erreur
→ Rollback : annule les données insérées

? Resume
→ Permet de définir des valeurs par défaut si une erreur survient

? Notification par une application
→ Ajouter un module Email, Slack ou Telegram dans un error handler
→ Objectif : être alerté immédiatement lorsqu’un scénario échoue

Contrairement aux comptes Google professionnels (type Google Workspace), les comptes personnels nécessitent une configuration manuelle via Google Cloud Platform pour être connectés à Make. Cela s’explique par les restrictions de sécurité imposées par Google. Ce tutoriel pas à pas permet de créer cette connexion de manière fiable et sécurisée, en s’appuyant sur la documentation officielle de Make.

Notes à retenir:

• Créer un projet dans Google Cloud Platform

  Aller sur console.cloud.google.com

  Sélectionner ou créer un nouveau projet (ex. : make)

  
  

• Activer les API nécessaires

  Gmail API

  Google Drive API
  (Google Sheets, Docs, Forms ne nécessitent pas cette étape pour le moment)

  
  

• Configurer l'application OAuth

  Nommer l’application (ex. : make)

  Choisir le type d’utilisateur : Externe

  Ajouter une adresse email de contact

  Ajouter les domaines autorisés : make.com et integromat.com

  Publier l'application (passer de mode test à production)

  
  

• Ajouter les scopes d’accès

  Sélectionner tous les scopes relatifs à Gmail et Google Drive

  
  

• Créer un identifiant OAuth

  Type d’application : Web Application

  Ajouter l’URL de redirection fournie par Make

  Récupérer le Client ID et le Client Secret

  
  

• Finaliser la connexion dans Make

  Dans Make, choisir “Show advanced settings” lors de la connexion à Gmail/Drive

  Coller le Client ID et le Client Secret

  S’authentifier avec le compte Google concerné

  Valider les autorisations même si l’application n’est pas validée par Google

  
  

? Sécurité

Les identifiants Client ID et Client Secret sont sensibles.
⚠️ Ne jamais les partager, car ils permettent un accès complet à vos données Gmail et Drive.

Dans ce chapitre on va créer une première automatisation complète dans Make. À partir d’une ligne ajoutée dans un Google Sheets, un email personnalisé est automatiquement envoyé au destinataire indiqué. Ce module permet de découvrir concrètement le fonctionnement d’un scénario simple : déclencheur + action.

Deux scénarios d’envoi d’emails sont créés à partir de Google Sheets :

• Avec Gmail (compte Google personnel connecté via Google Cloud Platform)

• Avec un fournisseur tiers comme Infomaniak (connexion SMTP + IMAP)

  
  

Chaque scénario se déclenche à l’ajout d’une nouvelle ligne dans un Google Sheets et utilise les données de cette ligne pour générer dynamiquement un message.

Notes à retenir:

? 1. Connexion de Google Sheets

• Module déclencheur : Watch New Rows

• Choix du fichier, de l’onglet et d’une limite (ex. : 100 lignes maximum par exécution)

• Test du module pour valider la récupération des données

  
  

? 2. Structure du bundle

• Chaque ligne du Google Sheets = 1 bundle

• Le bundle contient les colonnes du Google Sheets (ex. : nom, email)

  
  

? 3. Envoi d’un email personnalisé

• Module : Gmail > Send an Email ou Email > Send Email (SMTP/IMAP)

• Renseignement dynamique des champs :

  • To = email extrait du bundle

  • Subject = message personnalisé avec le nom

  • Content = texte simple ou HTML (Le HTML permet de personnaliser le style, notamment en ajoutant du texte en gras, des liens, des émojis, etc.)

  • Test avec Run once

    
    

? 4. Connexion à un fournisseur externe (ex : Infomaniak)

• Paramétrage SMTP pour l’envoi d’emails

• Paramétrage IMAP pour la réception ou la sauvegarde

• Informations à récupérer depuis la documentation du fournisseur

  
  

? Bonnes pratiques appliquées

• Nommer les scénarios et les modules

• Tester chaque module individuellement

• Sauvegarder le scénario

• Activer le scénario et définir la fréquence

Pour utiliser ChatGPT (ou tout autre modèle d’OpenAI) dans un scénario Make, il est nécessaire de générer une clé API depuis platform.openai.com. Cette clé permettra d’authentifier la connexion entre Make et OpenAI et de lancer des requêtes automatiques vers le modèle choisi.

Notes à retenir:

? 1. Connexion à la plateforme OpenAI

• Accéder à : https://platform.openai.com

• Se connecter avec le même compte utilisé pour ChatGPT

  
  

? 2. Ajouter un moyen de paiement

• Aller dans Settings > Billing > Payment Methods

• Ajouter une carte bancaire (minimum 6 $ de crédit recommandé)

• ⚠️ Désactiver l’option “auto-recharge” si on veut éviter des frais automatiques

  
  

? 3. Générer une clé API

• Aller dans API Keys

• Cliquer sur Create new secret key

• Donner un nom à la clé (ex. : make)

• Sélectionner le projet par défaut

• Copier la clé et la stocker dans un endroit sécurisé

  ⚠️ Cette clé est confidentielle : ne jamais la partager

  
  

? 4. Connecter OpenAI dans Make

• Créer un nouveau scénario Make

• Ajouter un module OpenAI > Create a Completion ou autre

• Cliquer sur Create connection

• Coller la clé API générée puis sauvegarder

  
  

? 5. Retrouver ses connexions

• Dans Make : Menu > My Connections

• Permet de consulter, réutiliser ou supprimer les connexions existantes

Ce chapitre présente une automatisation complète de la création de contenu avec ChatGPT destinée aux professionnels des ressources humaines ou aux agences de recrutement. Lorsqu’un nouveau poste est ajouté dans une base de données Notion, l’automatisation génère une description avec ChatGPT, une image correspondante, puis publie automatiquement le contenu sur LinkedIn et Instagram. Le scénario combine l'utilisation de Notion, OpenAI, Google Drive, LinkedIn et Instagram.

Notes à retenir:

? Déclenchement via Notion

• Utilisation du module Notion > Watch database items.

• Identification précise de la base de données via son Database ID.

• Accès aux données via le champ properties.value, plain text.

  
  

? Rédaction dynamique avec ChatGPT

• Utilisation du module OpenAI > Create a chat completion.

• Construction d’un prompt structuré :

  • Rôle (ex. : expert en communication RH)

  • Tâche (rédiger une annonce professionnelle)

  • Contexte (description du poste)

  • Audience cible (candidats)

  • Instructions précises (style, ton, structure, appel à l’action)

    ?Utiliser ChatGPT pour rédiger le prompt.

    
    

? Génération de l’image

• Utilisation du module OpenAI > Generate image.

• Prompt en anglais ou en français, selon le style souhaité.

  
  

? Sauvegarde des fichiers

• Module Google Drive > Upload a file pour enregistrer l’image générée.

• Module Google Drive > Download a file pour récupérer une URL utilisable sur Instagram.

• Utilisation du champ thumbnailLink pour Instagram.

  
  

? Mise à jour de la base Notion

• Mise à jour du champ “réseaux sociaux” avec la description générée via Notion > Update a Database item.

  
  

? Publication sur LinkedIn et Instagram

• LinkedIn accepte directement l’image générée.

• Instagram nécessite le lien public depuis Google Drive.

• Module Router utilisé pour envoyer les données vers deux branches distinctes : LinkedIn et Instagram.

  
  

?Bonnes pratiques appliquées

• Nommer chaque module selon sa fonction (ex. : Génération texte, Upload image, Post LinkedIn).

• Tester chaque étape avec Run Once pour s’assurer du bon traitement des données.

• Vérifier l’accessibilité publique des images pour Instagram.

• Documenter les prompts utilisés et les centraliser pour réutilisation.

Ce chapitre montre comment automatiser la transcription d’un fichier audio (par exemple une réunion Zoom) à l’aide du modèle Whisper d’OpenAI. L’automatisation permet de détecter un fichier audio ajouté à Google Drive, d’en générer automatiquement le texte, puis de sauvegarder le transcript dans un document Google Docs.

Notes à retenir:

? 1. Déclenchement par ajout de fichier audio

• Module utilisé : Google Drive > Watch Files

• Ciblage d’un dossier spécifique (ex. : audio_rendez-vous)

• Limitation à un fichier par exécution

  ⚠️ Certains fichiers audio peuvent ne pas être pris en charge par Whisper. Privilégiez les fichiers d’enregistrement provenant de Zoom, Google Meet, etc.

  
  

? 2. Téléchargement du fichier

• Module : Google Drive > Download a file

• Récupération dynamique du champ File ID à partir du module précédent

  
  

? 3. Transcription avec OpenAI Whisper

• Module : OpenAI > Create transcription

• Utilisation d’un modèle léger (ex. : gpt-4o-mini-transcribe)

• Indication du prompt dans la langue du fichier audio (ex. : “Transcris ce fichier audio.”)

• La transcription est retournée dans le champ text du module

  
  

? 4. Sauvegarde dans Google Docs

• Module : Google Docs > Create a document

• Nom du document = nom du fichier audio (pour cohérence)

• Contenu du document = texte transcrit

• Dossier cible = même que celui du fichier audio pour un classement clair

  
  

?Bonnes pratiques appliquées

• Toujours tester chaque module séparément avec Run Once pour vérifier le bon traitement du fichier.

• Nommer les documents de manière logique pour faciliter la recherche.

• S’assurer que le fichier audio est bien lisible par Whisper (format accepté, qualité correcte).

Ce chapitre aborde le fonctionnement de la tarification de l’API OpenAI, en particulier pour les modèles de génération de texte, d’images et de transcription audio. L’objectif est de comprendre comment sont calculés les coûts en fonction du nombre de tokens consommés lors de chaque interaction, afin de mieux anticiper la consommation liée à une automatisation.

Notes à retenir:

? 1. Tarification par token

OpenAI facture l’usage de l’API selon deux types de tokens :

• Input token : correspond au prompt envoyé à l’IA.

• Output token : correspond à la réponse générée par l’IA.

  Consulter https://openai.com/pricing pour les dernières mises à jour de tarification.

  
  

? 2. Suivi de la consommation

Dans les données d’exécution de l’automatisation, il est possible de visualiser l’usage :

• Visualiser séparément les tokens d’entrée (prompt tokens) et de sortie (completion tokens)

• Utiliser ces données pour calculer précisément le coût d’une automatisation

• Accéder à la consommation totale du mois sur https://platform.openai.com/account/usage

?Bonnes pratiques

• Favoriser les modèles légers (ex. : GPT-4o mini) pour les automatisations répétitives.

• Limiter la longueur des prompts et la taille des réponses lorsque possible.

• Suivre régulièrement sa consommation pour éviter les dépassements budgétaires.

Ce chapitre présente une automatisation utile pour la prospection B2B, basée sur le scraping intelligent de Google Maps grâce à l’acteur "Google Maps Email Extractor" proposé par Apify. L’objectif est de récupérer automatiquement les informations clés (nom, site web, adresse, numéro de téléphone, email) d’entreprises ciblées selon un secteur et une localisation fournis dans un Google Sheets.

Notes à retenir:

? 1. Déclenchement à partir de Google Sheets

• Module utilisé : Google Sheets > Watch New Rows

• Déclenchement programmé (pas instantané)

• Chaque ligne contient deux champs : secteur + localisation

  
  

? 2. Connexion à Apify

• Créer un compte sur https://apify.com

• L’acteur utilisé est Google Maps Email Extractor (scrape jusqu’à 100 entreprises par recherche)

• Lien avec Make via le module Run Actor + Get Dataset Items

  
  

? 3. Construction du JSON d'entrée

• Structure dynamique : les champs searchStringsArray (secteur) et locations (ville) sont remplis à partir du Google Sheets

  
  

? 4. Extraction des résultats

• Module : Apify > Get Dataset Items

• L’ID du dataset est extrait automatiquement du module précédent

• Données récupérées :

  • Nom de l’entreprise

  • Adresse

  • Téléphone

  • Email

  • Site internet

    
    

? 5. Enregistrement des données dans Google Sheets

• Module : Google Sheets > Add a row

• Mapping dynamique des données récupérées (attention aux collections multiples)

  
  

? Bonnes pratiques

• Utiliser Run Once avec prudence : chaque exécution consomme des crédits Apify.

• Exporter les résultats manuellement en CSV si l’on souhaite tester sans consommer de crédit.

• Ne pas oublier de sauvegarder et nommer les scénarios.

• L’automatisation peut être exécutée à la demande ou à des intervalles réguliers (ex. : 1 fois par jour).

  
  

? Informations complémentaires

• Un compte gratuit Apify offre 5$ de crédits mensuels.

• Le coût par extraction varie selon la tarification de l'acteur

Ce chapitre explique comment automatiser la création d’un devis personnalisé à partir d’un Google Sheets en utilisant un modèle Google Docs, puis comment l’envoyer automatiquement par email au client.

Notes à retenir:

? 1. Déclenchement via Google Sheets

• Module utilisé : Google Sheets > Watch New Rows

• Feuille contenant les informations du devis : nom, adresse, prestation, prix, TVA, total, etc.

• Chaque ligne déclenche la génération d’un devis.

  
  

? 2. Création du document à partir d’un modèle

• Module : Google Docs > Create Document from Template

• Les champs à remplir dynamiquement dans le modèle doivent être encadrés par deux accolades (ex. : {{nom_du_client}}).

• Il est impératif de copier-coller les noms de variables entre Google Sheets et le modèle pour éviter les erreurs de correspondance (majuscule, tirets, espaces...).

  
  

? 3. Téléchargement du document au format PDF

• Module : Google Docs > Download a Document

• Sélection du format PDF recommandé pour les envois par email.

• Récupération dynamique du Document ID depuis le module précédent.

  
  

? 4. Envoi du devis par email

• Module : Email > Send Email

• Les éléments dynamiques sont utilisés pour :

  • L’adresse du destinataire (extrait de Google Sheets)

  • Le contenu du message (nom, date, etc.)

  • La pièce jointe (PDF généré précédemment)

  
  

?Bonnes pratiques

• Créer un modèle de devis professionnel avec le logo de l’entreprise et les éléments à compléter entre deux accolades.

• Utiliser un nom clair pour le scénario (ex. : “Génération & envoi de devis”).

• Bien structurer les données dans le Google Sheets en amont pour faciliter la maintenance.

• Conserver les documents dans un dossier dédié pour un meilleur classement.

Ce scénario illustre l'utilisation des filtres dans Make pour segmenter les réponses d’un formulaire Typeform. Selon la motivation et le budget du prospect, un email différent est envoyé. C’est une automatisation précieuse pour optimiser la qualification et la réactivité commerciale sans intervention manuelle.

Notes à retenir:

? Make propose plusieurs types de filtres, adaptés à la nature des données :

• Text Operators : contains, does not contain, equal to, etc.

• Numeric Operators : greater than, less than, equal to, etc.

• Date/Time Operators : before, after, between, is within the last...

• Boolean Operators : is true, is false

• Existence Operators : exists, does not exist

• Array Operators : contains all, contains any, etc.

  
  

? Toujours utiliser contains pour les textes plutôt que equal to, car :

• contains est plus tolérant aux différences de casse, d’espaces ou de ponctuation.

• equal to est strict : un seul caractère en trop et la condition échoue.

  
  

? Copier-coller les valeurs textuelles (ex. : depuis un formulaire ou une base de données) est indispensable :

• Évite les fautes de frappe, majuscules manquantes ou espaces invisibles.

• Garantit une comparaison exacte même si la condition est souple (contains).

  
  

? Tester systématiquement chaque filtre avec des exemples réels dans l’onglet Run once pour valider leur comportement.

? En cas de condition multiple, privilégier une structure claire par route plutôt que d’empiler plusieurs conditions complexes dans un seul filtre.

Ce chapitre présente comment automatiser la collecte, le filtrage et la sauvegarde des métriques clés d’une campagne d’email marketing à l’aide de Make. L’objectif : chaque mois, récupérer automatiquement les données des campagnes envoyées le mois précédent sur Mailchimp, et les centraliser dans une base de données Airtable.
Ce processus est essentiel pour les équipes marketing cherchant à mesurer la performance de leurs campagnes de façon structurée et récurrente.

Notes à retenir:

? 1. Déclenchement et structure du scénario

• Le scénario est programmé pour s’exécuter chaque 1er du mois.

• Le premier module utilise Mailchimp > Search Campaign pour récupérer les campagnes contenant un mot-clé commun.

• Une limite élevée est conseillée pour s’assurer que toutes les campagnes sont récupérées.

  
  

? 2. Récupération des métriques

• Le module Mailchimp > Get Campaign Report permet d’extraire :

  • Le nom de la campagne

  • La date et l’heure d’envoi (send_time)

  • Le nombre d’emails envoyés

  • Le nombre total d’ouvertures et d’ouvertures uniques

  • Le taux d’ouverture

  • Le nombre total de clics, clics uniques et taux de clic

  • Le nombre de désinscriptions

    
    

? 3. Filtrage des campagnes par date

• Un filtre personnalisé permet de ne garder que les campagnes du mois précédent.

• Le filtre utilise deux conditions :

  • send_time ≥ (addMonths(now; -1))

  • send_time < (now)

• Cela permet de capturer uniquement les campagnes du mois précédent, même si le scénario est exécuté automatiquement chaque mois.

  
  

? 4. Intégration avec Airtable

• Module : Airtable > Create a Record

• La connexion doit être configurée avec accès aux bases futures (All and future bases in all and future workspaces).

• Chaque champ dans Airtable (ex. : campagne, envois, taux d’ouverture, clics...) est rempli dynamiquement depuis les données du rapport.

  
  

?Bonnes pratiques

• Ajouter une colonne Created dans Airtable pour chaque entrée, afin de suivre la date d’enregistrement.

• Toujours tester le filtre de date pour s’assurer qu’il récupère bien la bonne période.

• Uniformiser les noms de campagnes (ex. : toujours inclure un mot-clé commun) pour faciliter leur recherche automatique.

• Surveiller la consommation d’opérations si le scénario traite un volume élevé de campagnes.

Ce chapitre présente une automatisation complète qui permet de générer automatiquement un rapport d’analyse des campagnes d’email marketing à partir de données stockées dans Airtable. L’objectif est de transmettre ces données à ChatGPT, via le module Text Aggregator, pour produire une analyse qualitative, suivie d’un plan d’action personnalisé, puis de sauvegarder ce rapport dans Google Drive. Cette automatisation s’inscrit dans une logique de reporting mensuel intelligent à haute valeur ajoutée.

Notes à retenir:

? 1. Objectif de l’automatisation

• Lancer chaque 1er du mois, après la collecte des données dans Airtable.

• Générer une analyse textuelle automatique de toutes les campagnes email du mois précédent.

• Produire un rapport stratégique comprenant résumé exécutif, checklist et recommandations.

  
  

? 2. Modules utilisés

• Airtable > Search Records : récupère toutes les lignes d’une table contenant les données de campagnes.

• Tools > Text Aggregator : agrège les données ligne par ligne pour les transmettre à ChatGPT.

• OpenAI > Create Chat Completion :

  • Prompt structuré avec rôle, contexte, tâche, audience, instructions.

  • Analyse comparative avec recommandations concrètes.

• Google Drive > Create a File from Text : sauvegarde du rapport généré au format .txt ou .doc.

  
  

? 3. Structure du prompt pour ChatGPT

• Rôle : expert en analyse de campagne marketing.

• Données : nom de la campagne, taux d’ouverture, taux de clics, désabonnements, etc.

• Tâche : analyser et identifier ce qui fonctionne, les signaux faibles, proposer des pistes d’optimisation.

• Format demandé : résumé exécutif, analyse point par point, checklist stratégique, insight marquant

  
  

? 4. Bonnes pratiques

• Utiliser formatDate pour générer un nom de fichier clair et daté.

• Prévoir un filtrage par date via un filtre send_time compris entre le début et la fin du mois précédent.

Dans ce chapitre, on découvre les quatre principaux modules d’agrégation proposés par Make :

• Text Aggregator pour concaténer du texte,

• Numeric Aggregator pour effectuer des calculs,

• Table Aggregator pour regrouper des données tabulaires,

• Array Aggregator pour combiner des collections de données.

L’automatisation illustrée ici montre comment agréger des colonnes Google Sheets (nom + adresse) en une seule opération groupée. Ce processus permet d’économiser des opérations et d’accélérer les scénarios.

Notes à retenir:

? 1. Les types d’agrégateurs

• Text Aggregator : fusionne plusieurs chaînes de texte en une seule.

• Numeric Aggregator : calcule des moyennes, des totaux, des valeurs min/max, ou le nombre d’occurrences (count).

• Table Aggregator : rassemble plusieurs tables en une seule.

• Array Aggregator : regroupe plusieurs collections de données (objets, valeurs, paires clé/valeur) en une seule structure de type tableau.

  
  

? 2. Scénario illustré

• Source : un Google Sheets contenant plusieurs lignes d’entreprises avec leurs noms et adresses.

• Modules utilisés :

  • Google Sheets > Search Rows (extraction des données),

  • Flow Control > Array Aggregator (regroupement des noms + adresses),

  • Google Sheets > Add Rows (Bulk) (ajout groupé des lignes).

• L’identifiant du fichier Google Sheets (Spreadsheet ID) est extrait de l’URL (entre /d/ et /edit)

  
  

? 3. Avantages de cette méthode

• ? Économie d’opérations : au lieu d’exécuter un module Add Row pour chaque ligne, l’usage du Bulk Add Rows permet de tout regrouper en une seule exécution.

• ? Performance : gain de vitesse dans les scénarios volumineux.

• ? Clarté : permet de visualiser et structurer les données de manière plus propre et cohérente.

  
  

? 4. Bonnes pratiques

• Les agrégateurs nécessitent toujours un module source : il s'agit généralement d’un module qui produit plusieurs lignes ou éléments (ex. : Search Rows, Search Records, etc.).

• Le module Array Aggregator a une spécificité importante :
  il nécessite également un module cible (target) pour transférer les données agrégées (par exemple : Bulk Add Rows dans Google Sheets).

• Penser à utiliser un agrégateur chaque fois qu’il faut regrouper plusieurs éléments similaires (textes, nombres, objets, etc.) en une seule structure.

• Ces modules permettent de réduire significativement la consommation d’opérations dans Make, tout en rendant les scénarios plus efficaces et lisibles.

Les Iterators sont l'inverse des Aggregators dans Make.
Alors que les agrégateurs regroupent plusieurs bundles en un seul, les Iterators décomposent un bundle complexe pour en extraire des éléments individuellement. Les iterators se trouvent dans Flow Control > Iterator.

Ce scénario permet de déclencher automatiquement la création et l’envoi d’une facture via Stripe dès qu’un utilisateur clique sur un bouton dans Airtable. Grâce à un webhook, le processus s’active instantanément, sans besoin de programmation horaire. L'automatisation gère la création du client Stripe, la facture, l'envoi du lien de paiement, et la mise à jour du statut dans Airtable.

Notes à retenir:

? 1. Déclenchement via Webhook

• Le module Make > Custom Webhook permet de déclencher l’automatisation instantanément à partir d’un clic dans Airtable.

• Le webhook agit comme une porte d’entrée sécurisée pour envoyer des données depuis Airtable vers Make.

• Il doit être connecté à Airtable via une formule de type URL.

  
  

? 2. Génération dynamique de l’URL depuis Airtable

• Une colonne de type formula est utilisée pour construire dynamiquement l’appel au webhook avec les données de chaque ligne.

• Chaque URL encode les valeurs transmises pour éviter les erreurs.

• Exemple de formule personnalisable (adapter à votre propre webhook + noms de colonnes) :

  
  

"https://hook.eu2.make.com/vathtrkqtgny5nqakgcqv6if0dtkqwdc?" & "record_id=" & RECORD_ID() & "&nom=" & ENCODE_URL_COMPONENT({Nom du Client}) & "&email=" & ENCODE_URL_COMPONENT(Email) & "&adresse=" & ENCODE_URL_COMPONENT(Adresse) & "&telephone=" & ENCODE_URL_COMPONENT({Téléphone}) & "&service=" & ENCODE_URL_COMPONENT(Service) & "&montant=" & ENCODE_URL_COMPONENT(Montant)

? 3. Importance du RECORD ID

• Le champ record_id est essentiel pour permettre à Make de retrouver et mettre à jour la ligne concernée dans Airtable.

• Il est utilisé dans le module Update Record pour modifier le statut (ex. : passage de “Envoi facture” à “En attente de paiement”).

• Il s'agit d'une formule "RECORD_ID()"

  
  

? 4. Étapes clés dans Stripe (4 modules)

• Create a customer : Ajout du client avec ses coordonnées.

• Create an invoice item : Création de l’élément facturé (produit ou service).

• Create an invoice : Génération de la facture associée au client.

• Finalize invoice : Finalisation et envoi automatique de la facture.

  
  

? 5. Mise à jour automatique dans Airtable

• Une fois la facture créée, Make met à jour le statut dans Airtable et ajoute une date d’envoi (via now) pour faciliter les relances automatisées.

• Cette automatisation permet une gestion fluide, instantanée et sans intervention manuelle.

  
  

?Bonnes pratiques

• Toujours nommer clairement le webhook dans Make pour l’identifier facilement.

• Inclure le RECORD_ID() dans la formule Airtable pour permettre une mise à jour précise.

• Vérifier que le montant est multiplié par 100 (Stripe attend des centimes).

• Choisir le mode de facturation "Send invoice" si vous ne collectez pas les paiements par carte automatiquement.

• Utiliser now comme date d’envoi pour faciliter les relances automatiques à J+10 par exemple.

Cette automatisation permet de relancer les clients dont les factures sont en attente de paiement depuis plus de 10 jours. Elle combine Airtable, Stripe et Make pour :

• Identifier automatiquement les clients concernés.

• Vérifier si la facture est toujours impayée.

• Envoyer un email de relance ou mettre à jour le statut selon le cas.

Notes à retenir:

? 1. Conditions de relance via module Route

• Le filtre vérifie deux éléments :

  • Date d’échéance dépassée : now > date d’envoi + 10 jours.

  • **Statut actuel = “En attente de paiement”`.

• Utiliser l'opérateur Contains plutôt que Equals pour éviter les erreurs dues aux espaces ou à la casse dans le texte.

  
  

? 2. Intégration Stripe : matching essentiel

• Pour garantir une correspondance entre la facture Stripe et la ligne Airtable, ajouter une colonne Customer ID Stripe dans Airtable lors de la création initiale de la facture.

• Ce champ servira de clé de liaison lors des vérifications de paiement.

  
  

? 3. Statuts des factures Stripe

• Utiliser :

  • Status = open pour les factures non payées → envoi d’un email de relance.

  • Status = paid pour les factures réglées → mise à jour du statut Airtable à “Payée”.

    
    

? 4. Email de relance dynamique

• L'email est personnalisé avec :

  • Nom du client (customer_name)

  • Numéro de la facture (invoice_number)

  • Montant dû (total)

  • Date d’échéance (due_date)

  • Lien de paiement (invoice_url)

  Utiliser plain text ou HTML selon le besoin d'ajouter des styles (liens, emojis, etc.).

  
  

?Bonnes pratiques

• Ajouter une colonne de type formula contenant RECORD_ID() pour faciliter la mise à jour de la ligne cible.

• Ce champ est essentiel pour le module Update record dans Make.

Les agents IA de Make offrent une nouvelle dimension à l’automatisation : celle de l’autonomie décisionnelle. Grâce à un modèle de langage connecté à des outils externes (bases de données, fichiers, services web), un agent est capable d’analyser, rédiger, déclencher des actions et s’adapter au contexte. Dans ce cas d’usage, un agent analyse les performances email marketing mensuelles, en combinant des données Airtable et des rapports Google Drive pour générer automatiquement un rapport stratégique complet.

Notes à retenir:

? 1. Création de l’agent IA dans Make

L’agent IA repose sur un modèle de langage (ici GPT-4o mini) et un prompt système qui définit son rôle et ses objectifs et des outils.

Les agents IA sont accessibles uniquement via la formule Pro de Make.

? 2. Configuration des outils de l’agent IA

Chaque outil est un scénario activé à la demande (On-demand), structuré comme suit :

Les outils doivent porter exactement le même nom que dans le prompt système pour être reconnus par l’agent.

Exemples d’outils :

• Base Airtable : récupère les métriques des campagnes marketing

• Dossier Google Drive : récupère les anciens rapports pour comparaison

  
  

? 3. Déclenchement de l’agent et génération du rapport

Le scénario principal contient :

• Make > Run Agent : exécute l’agent avec ses outils configurés

  
  

?Bonnes pratiques

• Scénarios d’outils : ils doivent toujours inclure un Return Output, et être configurés en mode “à la demande”.

• Nommage des outils : respecter exactement le nom spécifié dans le prompt système (majuscules/minuscules inclus).

• Descriptions courtes : chaque outil doit être accompagné d’une description de 240 caractères maximum pour guider l’agent.