Sommaire

  1. Ce que tu vas construire
  2. Prérequis (5 minutes)
  3. Étape 1 — Créer le scénario dans Make
  4. Étape 2 — Configurer le déclencheur Gmail
  5. Étape 3 — Connecter le module OpenAI
  6. Étape 4 — Écrire le prompt de classification
  7. Étape 5 — Ajouter le filtre et le label automatique
  8. Étape 6 — Tester et programmer
  9. Le workflow en action
  10. Pièges courants

Ouvrir sa boîte Gmail le matin et voir 80 emails non lus. La moitié inutile, un quart urgent, le reste à traiter. Trier ça à la main prend 20 à 40 minutes. Chaque jour.

Ce tutoriel construit un scénario Make qui lit chaque email entrant, demande à ChatGPT de le classifier, puis applique automatiquement le bon label Gmail. Zéro code. Zéro tri manuel.

Ce que tu vas construire : Un scénario Make qui classe automatiquement tes emails Gmail en catégories (Client, Facture, Support, Commercial, Autre) avec un niveau de priorité (Urgent, Normal, Faible) — via le module OpenAI Create a Chat Completion. Template de référence : Make Template #12155.

Ce que tu vas construire

Le scénario se déroule en 4 étapes automatiques, déclenchées à chaque nouvel email.

GMAIL Watch Emails Déclencheur OPENAI Chat Completion Classification IA MAKE FILTER Router / Condition Tri par catégorie GMAIL Add Label to Email Label automatique

Chaque module correspond à une action concrète dans Make. Les 4 étapes prennent environ 45 minutes à configurer la première fois.

Un scénario Make actif, c'est du temps récupéré chaque matin sans rien toucher.

Prérequis (5 minutes)

  • Compte Make.com — le plan Free suffit pour tester (1 000 opérations/mois incluses). Pour un usage quotidien, le plan Core à 9 €/mois donne 10 000 opérations.
  • Clé API OpenAI — créer un compte sur platform.openai.com, section API Keys. Budget estimé : 1 à 3 € par mois pour 100 emails/jour avec gpt-4o-mini.
  • Compte Gmail — avec les labels déjà créés (Client, Facture, Support, Commercial, Autre).
  • Durée : 45 à 60 minutes pour la configuration initiale.
À propos du coût OpenAI : gpt-4o-mini coûte 0,15 $ pour 1M tokens en entrée. Classifier un email de 300 mots consomme environ 500 tokens. 100 emails/jour = 1 500 000 tokens/mois = ~0,23 $ par mois. Rester sur gpt-4o-mini pour ce type de tâche.

Étape 1 — Créer le scénario dans Make

Ouvrir un nouveau scénario

Connecte-toi sur make.com. Dans le menu gauche, clique sur Scenarios puis sur le bouton + Create a new scenario en haut à droite.

Un éditeur visuel s'ouvre avec un cercle central vide. C'est là que tu vas construire le workflow module par module.

Piège à éviter : Ne pas utiliser le bouton "Use a template". Pour comprendre chaque paramètre, construire le scénario depuis zéro. Les templates cachent les configurations et rendent le débogage difficile.

Nommer le scénario

Clique sur le nom par défaut en haut ("New scenario") et renomme-le : "Classification emails Gmail — IA". Ça paraît anodin. C'est essentiel quand tu en auras 20.

Étape 2 — Configurer le déclencheur Gmail

Ajouter le module Gmail > Watch Emails

Clique sur le cercle central dans l'éditeur. Une bibliothèque d'applications s'ouvre. Cherche "Gmail" et sélectionne l'app. Dans la liste des modules, choisis Watch Emails.

Make te demande de te connecter à ton compte Gmail via OAuth. Clique Add, suis le flux d'autorisation Google, puis reviens sur Make.

Paramétrer Watch Emails

Une fois connecté, le module affiche un formulaire de configuration :

  • Folder : INBOX (ou un label spécifique si tu veux filtrer en amont)
  • Criteria : All email (pour tout classer) ou Unread email (recommandé)
  • Mark email as read when fetched : Yes
  • Maximum number of emails : 10 (valeur sécurisée pour les premiers tests)
Piège à éviter : Mettre "Maximum number of emails" à une valeur trop haute au départ. Si tu as 200 emails non lus, le premier run va consommer 200 opérations Make et générer 200 appels API OpenAI. Commence à 10, augmente après validation.

Étape 3 — Connecter le module OpenAI

Ajouter OpenAI > Create a Chat Completion

Clique sur le + à droite du module Gmail dans l'éditeur. Cherche "OpenAI" dans la bibliothèque. Sélectionne l'application OpenAI (ChatGPT, Whisper, DALL-E).

Dans la liste des modules disponibles, choisis Create a Chat Completion. C'est le module actuel — ne pas utiliser "Create a Completion" qui correspond à l'ancienne API et est en voie de dépréciation.

Connecter ta clé API

Clique Add dans le champ Connection. Make te demande un nom de connexion et ta clé API OpenAI. Colle la clé depuis platform.openai.com/api-keys. Clique Save.

Choisir le modèle

Dans le champ Model, sélectionne gpt-4o-mini. Pour une classification d'emails, c'est le bon équilibre coût/qualité. GPT-4o coûte 15 à 20 fois plus cher pour un résultat quasi identique sur des tâches de classification simple.

gpt-4o-mini pour la classification. GPT-4o pour la rédaction. Ne pas confondre les deux.

Étape 4 — Écrire le prompt de classification

Configurer le System Message

Dans le module OpenAI, tu as deux champs de message. Le System définit le comportement de l'IA. Le User contient le contenu à analyser.

Dans Messages > Role : System, colle ce prompt :

Prompt System (à copier) :

Tu es un assistant de classification d'emails professionnels. Quand tu reçois un email, tu dois retourner UNIQUEMENT un JSON valide avec deux champs :
- "categorie" : une valeur parmi [Client, Facture, Support, Commercial, Autre]
- "priorite" : une valeur parmi [Urgent, Normal, Faible]

Règles : Urgent = délai explicite ou problème bloquant. Client = email d'un client connu ou prospect qualifié. Facture = document financier ou relance paiement. Support = demande d'aide technique. Commercial = prospection ou newsletter. Autre = tout le reste.

Ne retourne rien d'autre que le JSON. Pas d'explication, pas de texte supplémentaire.

Configurer le User Message

Dans Messages > Role : User, tu vas mapper les données de l'email. Clique sur le champ et utilise le panneau de mapping Make (la liste de variables à gauche) pour insérer :

  • Sujet : {{1.subject}} (sujet de l'email depuis Gmail)
  • Expéditeur : {{1.from[].name}}
  • Corps : {{1.snippet}} (ou {{1.body.text}} pour le corps complet)

Le message User ressemble à :

Message User (structure) :
Sujet : {{1.subject}}
De : {{1.from[].name}} <{{1.from[].value}}>
Corps : {{1.snippet}}
Piège à éviter : Utiliser {{1.body.html}} au lieu de {{1.snippet}}. Le HTML brut d'un email contient des centaines de balises inutiles qui consomment des tokens pour rien. Utiliser snippet (extrait de 200 mots) ou body.text (texte brut).

Étape 5 — Ajouter le filtre et le label automatique

Parser la réponse JSON

La réponse d'OpenAI est du texte brut. Make ne comprend pas automatiquement le JSON dedans. Ajoute un module intermédiaire : Tools > Parse JSON.

Dans le champ JSON string, insère la variable de réponse OpenAI : {{2.choices[].message.content}}. Make va décomposer le JSON en variables utilisables : categorie et priorite.

Ajouter le Router

Clique sur le + après le module Parse JSON et ajoute un Router (Flow Control > Router). Il crée plusieurs chemins parallèles selon la valeur de categorie.

Pour chaque catégorie, configure un chemin avec une condition :

  • Chemin 1 — Condition : categorie equals Client → module Gmail "Add Label" avec le label "Client"
  • Chemin 2 — Condition : categorie equals Facture → label "Facture"
  • Chemin 3 — etc.

Configurer Gmail > Add a Label to an Email

Dans chaque chemin du Router, ajoute le module Gmail > Add a Label to an Email.

  • Email ID : {{1.id}} (l'ID de l'email depuis le premier module)
  • Label : sélectionne le label Gmail correspondant dans la liste déroulante
Piège à éviter : Les labels Gmail doivent exister AVANT de configurer le module Make. Make ne crée pas de labels à la volée. Crée tous tes labels dans Gmail Settings d'abord.

Étape 6 — Tester et programmer le scénario

Run Once pour valider

Avant d'activer le scénario en continu, clique sur Run once (bouton en bas à gauche de l'éditeur). Make exécute le scénario une fois sur les emails les plus récents.

Vérifie dans le panneau d'exécution :

  • Gmail a bien récupéré des emails (nombre d'éléments traités)
  • OpenAI a retourné un JSON valide pour chaque email
  • Parse JSON a bien extrait categorie et priorite
  • Le bon label a été appliqué dans Gmail
Piège à éviter : OpenAI peut retourner du texte avec le JSON entouré de balises markdown (```json ... ```). Dans ce cas, le Parse JSON va échouer. Solution : ajouter dans le System prompt "Ne pas utiliser de blocs de code markdown. Retourner uniquement le JSON brut."

Programmer le scénario

Clique sur Scheduling en bas de l'éditeur. Configure l'intervalle : toutes les 15 minutes suffit pour la plupart des usages. Le plan Free Make tourne jusqu'à toutes les 15 minutes. Le plan Core permet des intervalles de 1 minute.

Active le scénario avec le toggle ON/OFF en haut à droite. C'est actif.

Le workflow en action

Avec ce scénario actif, chaque email entrant dans Gmail est lu par Make dans les 15 minutes, analysé par ChatGPT, et classé avec le bon label — sans intervention. Ce qui prenait 20 à 40 minutes de tri manuel se fait en arrière-plan pendant que tu travailles sur autre chose.

Le coût réel du scénario sur un mois avec 50 emails/jour :

  • Make Core : 9 € (10 000 opérations/mois — largement suffisant)
  • OpenAI gpt-4o-mini : environ 0,10 à 0,20 € pour 1 500 emails/mois
  • Total : ~9,20 € par mois pour une boîte mail triée automatiquement
u/automation_nerd_mk · r/nocode · Janvier 2025
"Le truc qui m'a le plus surpris avec Make + OpenAI, c'est la fiabilité. J'attendais 70% de précision, j'ai eu 92% dès la première semaine sans affiner le prompt. Les 8% restants sont des emails ambigus même pour moi."

Aller plus loin avec ce scénario

Le scénario de base classe les emails. On peut l'étendre facilement :

  • Ajouter une étoile sur les emails "Urgent" → Gmail > Modify an Email Thread
  • Créer une tâche Notion pour chaque email "Client" → module Notion > Create a Page
  • Envoyer un résumé Slack des emails urgents chaque matin à 8h
u/solopreneur_tools · r/automation · Mars 2025
"J'ai ajouté une étape Notion après le label Gmail. Chaque email client déclenche automatiquement une fiche dans ma base CRM Notion. En trois semaines je n'ai plus rien perdu."

La pépite

Ajouter un champ resume dans le JSON retourné par OpenAI — un résumé en une phrase de l'email. Puis créer un deuxième scénario Make qui compile ces résumés chaque matin et te les envoie par email ou Slack. Tu sais ce qui t'attend avant d'ouvrir ta boîte. Zéro configuration supplémentaire côté Gmail.

Red flags

Emails HTML complexes — Les newsletters avec beaucoup de code HTML saturent le prompt. Utiliser snippet ou body.text, jamais body.html.
Réponse non-JSON — OpenAI peut retourner du texte libre si le prompt est mal formulé. Tester avec Run Once avant d'activer. Ajouter "Retourner UNIQUEMENT le JSON brut" dans le System prompt.
Limite d'opérations Make — Le plan Free limite à 1 000 opérations par mois. Avec 5 modules par email et 50 emails/jour, on dépasse en une semaine. Calculer avant de lancer en production.
Erreur de mapping — Les champs Gmail changent selon le type d'email (Gmail normal vs alias). Toujours vérifier les variables dans le panneau d'exécution après Run Once.
ProfilConfiguration recommandéePourquoi
Freelance / solopreneurMake Core (9€) + gpt-4o-miniVolume faible, coût minimal, résultat immédiat.
PME avec volume moyenMake Pro (16€) + gpt-4o-miniPlus d'opérations, intervalles plus courts (1 min).
Équipe support clientMake Teams + GPT-4oPrécision maximale, gestion multi-comptes Gmail.
Débutant make.comCommencer par le template #12155Structure prête, personnaliser le prompt seulement.