Ressources · Intégration Make

Intégration Redmine MakeAutomatiser Redmine avec Make.

Tes demandes Redmine et tes heures saisies pourraient circuler seules vers tes autres outils. L'intégration Redmine Make compte 22 modules : 6 déclencheurs, 13 actions et 3 recherches. Ce guide relie ton compte, monte avec toi un premier scénario et décrit chaque module.

Avis vérifiés sur Trustpilot · Agence IA, automatisation & growth

Ce que tu peux automatiser

Que peut-on automatiser avec l'intégration Redmine Make ?

L'intégration Redmine Make branche ton compte Redmine sur Make, un outil sans code où tu montes des scénarios. Un scénario, c'est ton automatisation : une suite de modules, chacun étant une brique qui surveille, crée, lit ou modifie quelque chose. Redmine peut lancer le scénario quand une demande, un projet ou un temps passé apparaît, ou recevoir ce que d'autres applis lui envoient.

Des heures qui arrivent jusqu'à la compta. Watch Time Entries repère chaque temps saisi par l'équipe et le fait suivre vers un tableur ou ton outil de facturation. Si le temps est rattaché à une demande, Get an Issue peut en ajouter le détail, pour que la ligne soit lisible hors de Redmine.

Des arrivées sans oubli. Quand Watch Users voit un nouveau compte, Create an Issue ouvre un ticket d'accueil au nom de la personne, et un message peut partir vers son responsable.

Des demandes qui naissent ailleurs. Un formulaire de support, un mail ou une fiche CRM se transforme en ticket avec Create an Issue ; Update an Issue le fait avancer quand la source bouge.

Point à connaître : tous les déclencheurs Redmine sont planifiés. Make interroge Redmine au rythme du scénario, donc rien ne part à la seconde près. La doc officielle est aussi signalée comme générée par IA : vérifie dans Redmine ce qui compte pour toi. Pour choisir ton outil, le comparatif n8n vs Make pose les critères, et la Formation Make t'aide à monter tes premiers scénarios. Si tu préfères déléguer, passe par l'Agence Make.

Connexion

Comment connecter Redmine à Make ?

  1. 01

    Récupère ta clé API dans Redmine

    Il te faut un compte Redmine actif. Ouvre My account dans le menu du haut, descends jusqu'à la section API access key et copie la clé affichée. C'est elle qui autorise Make à agir pour toi.

  2. 02

    Ajoute un module Redmine dans Make

    Dans ton scénario, pose n'importe quel module Redmine puis clique sur Create a connection. La connexion, c'est ton compte Redmine relié à Make une bonne fois. Le champ Connection name est facultatif, mais un nom clair t'aidera plus tard.

  3. 03

    Colle les identifiants et valide

    Saisis les identifiants copiés depuis Redmine, ou suis les consignes affichées par Make. Une fois enregistrée, la connexion apparaît dans la liste et tous les autres modules Redmine peuvent s'en servir.

Premier scénario

Ton premier scénario avec Redmine

ObjectifQuand un nouvel utilisateur arrive dans Redmine, Make lui ouvre un ticket d'accueil.

  1. 01

    Crée le scénario

    Depuis la page Scenarios, crée un nouveau scénario et clique sur le + au centre de l'éditeur. Ce rond vide accueille ton premier module.

  2. 02

    Choisis Watch Users

    Cherche Redmine, sélectionne Watch Users et choisis la connexion créée plus haut. Ce déclencheur est planifié : à chaque exécution du scénario, Make demande à Redmine s'il y a de nouveaux comptes.

  3. 03

    Ajoute Create an Issue

    Clique sur le + à droite du déclencheur et ajoute Create an Issue. Remplis les champs du ticket en reprenant les données du bundle précédent, c'est-à-dire l'utilisateur transmis par Watch Users.

  4. 04

    Teste avec Run once

    Ajoute un compte de test dans Redmine, puis clique sur Run once. Ouvre les bulles au-dessus des modules pour lire les bundles reçus et vérifie que le ticket est bien créé.

  5. 05

    Planifie et active

    Clique sur l'horloge de Watch Users pour régler la planification : un nouveau scénario tourne toutes les 15 minutes par défaut. Active-le ensuite, il travaillera sans toi.

Déclencheurs

Les déclencheurs Redmine : ce qui lance un scénario

6 modules démarrent un scénario quand quelque chose se passe dans Redmine. Un déclencheur planifié est vérifié par Make au rythme du scénario ; un déclencheur instantané est appelé par Redmine dès que ça se passe.

Redmine1Watch Time Entries

Watch Time Entries

Déclencheur planifié

Dans MakeTriggers when you add a new time entry.

Chaque temps saisi dans Redmine arrive dans ton scénario, prêt à partir vers une feuille de temps, un brouillon de facture ou un tableau de bord.

Comment il se déclenche
planifié. Make interroge l'app au rythme du scénario, et les temps trouvés à ce moment passent tous ensemble.
Quand l'utiliser
quand la personne qui facture ou pilote la charge a besoin des heures sans réclamer d'export à l'équipe.
Attention
chaque temps trouvé forme un bundle, et chaque module placé après consomme une opération par bundle.
Redmine2Watch Issue Priorities

Watch Issue Priorities

Déclencheur planifié

Dans MakeTriggers when you add a new issue priority.

Un administrateur ajoute un niveau de priorité dans Redmine ? Ce déclencheur le transmet au scénario au passage suivant, pour que les outils qui recopient ta configuration suivent.

Comment il se déclenche
planifié. Make interroge l'app au rythme du scénario et récupère les priorités ajoutées depuis.
Quand l'utiliser
si un outil de support ou un tableur garde sa propre liste de priorités, alignée sur celle de Redmine.
Attention
il réagit à l'ajout d'une priorité dans la liste, pas à une demande qui change de priorité ; un ticket devenu urgent ne le déclenche pas.
Redmine3Watch Issues

Watch Issues

Déclencheur planifié

Dans MakeTriggers when you add a new issue.

Chaque nouvelle demande Redmine devient un bundle que tu peux router vers un canal de discussion, ton CRM ou une liste de relance.

Comment il se déclenche
planifié. Make interroge l'app au rythme du scénario, toutes les 15 minutes par défaut.
Quand l'utiliser
pour qu'un bug ou une demande client atteigne quelqu'un qui n'ouvre jamais Redmine, un commercial ou un responsable de compte par exemple.
Attention
si le même scénario contient Create an Issue, il risque de ramasser ses propres tickets au passage suivant.
Redmine4Watch Projects

Watch Projects

Déclencheur planifié

Dans MakeTriggers when you add a new project.

Un projet créé dans Redmine marque souvent le vrai démarrage d'un dossier ; ce déclencheur le passe au scénario pour préparer le reste autour.

Comment il se déclenche
planifié. À chaque exécution, Make interroge l'app et récupère les projets ajoutés depuis le passage précédent.
Quand l'utiliser
pour ouvrir un dossier partagé, un canal client ou les premiers tickets dès qu'un projet existe.
Attention
sur le plan Free, 15 minutes séparent au minimum deux vérifications, prévois ce décalage.
Redmine5Watch Trackers

Watch Trackers

Déclencheur planifié

Dans MakeTriggers when you add a new tracker.

Quand ton Redmine gagne un nouveau tracker, la catégorie à laquelle appartient un ticket, le scénario en est informé et peut prévenir tes autres outils.

Comment il se déclenche
planifié. Make interroge l'app au rythme du scénario pour repérer les trackers ajoutés.
Quand l'utiliser
quand un reporting ou un formulaire externe propose une liste de types de tickets qui doit coller à la configuration de Redmine.
Attention
seul l'ajout compte ; renommer ou supprimer un tracker ne lance rien, à toi de répercuter ces changements.
Redmine6Watch Users

Watch Users

Déclencheur planifié

Dans MakeTriggers when you add a new user.

Chaque personne ajoutée à Redmine arrive dans ton scénario, ce qui te permet de dérouler l'accueil depuis un seul endroit plutôt que plusieurs écrans d'admin.

Comment il se déclenche
planifié. Make interroge l'app au rythme du scénario et ramène les nouveaux comptes.
Quand l'utiliser
quand un nouveau développeur ou un compte client doit aussi recevoir un message de bienvenue ou une place dans l'annuaire de l'équipe.
Attention
un départ ou un changement de rôle ne déclenche rien, seul l'ajout d'un compte est vu.
Modules

Les modules Redmine : ce que Make fait dans ton compte

Redmine te donne 16 modules. Pour chacun : ce qu'il fait pour toi, le moment où tu le choisis, et ce qu'il faut surveiller.

Redmine1

Create an Issue

Action

Dans MakeCreates an issue.

Ouvre un ticket dans Redmine à partir de ce qui arrive dans ton scénario : une demande de formulaire, un mail de client ou une fiche CRM y atterrit sans ressaisie.

Quand l'utiliser
quand le travail naît hors de Redmine mais que l'équipe veut le suivre dedans.
Attention
évite de le placer derrière Watch Issues, sinon les tickets s'engendrent les uns les autres.
Redmine2

Create a Project

Action

Dans MakeCreates a project.

Crée un projet Redmine à partir d'un événement ailleurs, une affaire gagnée dans le CRM ou un devis signé, et l'équipe dispose tout de suite d'un espace de travail.

Quand l'utiliser
quand chaque nouveau client ou contrat a son projet et que quelqu'un le crée encore à la main.
Attention
teste d'abord avec Run once sur une fiche bidon, puis supprime le projet de test ainsi créé.
Redmine3

Create a Time Entry

Action

Dans MakeCreates a time entry.

Enregistre des heures dans Redmine pour une personne, afin que le temps suivi dans un autre outil ou déclaré dans un formulaire compte là où vivent tes projets.

Quand l'utiliser
quand une partie de l'équipe pointe ailleurs et que les totaux dans Redmine restent incomplets.
Attention
lance une seule saisie de test et contrôle-la dans Redmine avant d'activer, des heures en double se repèrent mal après coup.
Redmine4

Delete an Issue

Action

Dans MakeDeletes an issue.

Supprime définitivement un ticket de Redmine, pratique pour garder l'outil propre quand la demande a été annulée à la source.

Quand l'utiliser
pour les tickets de test ou les doublons créés par tes scénarios, ou une demande retirée avant tout traitement.
Attention
une suppression ne se rattrape pas depuis Make ; place un filtre avant pour que seuls les bons tickets arrivent jusqu'ici.
Redmine5

Delete a Project

Action

Dans MakeDeletes a project.

Efface un projet Redmine entier depuis un scénario, avec l'espace de travail de l'équipe : c'est un module de ménage, pas de flux quotidien.

Quand l'utiliser
pour retirer les projets bac à sable ouverts pour un test ou une démo, une fois qu'ils ne servent plus.
Attention
rien dans Make ne ramène un projet supprimé ; lance-le d'abord à la main sur un seul projet.
Redmine6

Delete a Time Entry

Action

Dans MakeDeletes a time entry.

Retire un temps saisi dans Redmine, ce qui corrige des heures comptées deux fois ou imputées à la mauvaise tâche par un autre scénario.

Quand l'utiliser
quand une synchro depuis ton outil de pointage a poussé une ligne qui n'a rien à faire là.
Attention
la ligne disparaît dès que le module tourne, alors cible un temps précis repris d'un module précédent.
Redmine7

Get an Issue

Action

Dans MakeGets an issue.

Récupère une demande Redmine avec son détail, pour qu'un module suivant puisse la citer dans un message ou un rapport.

Quand l'utiliser
quand ton scénario sait seulement quel ticket est concerné, par exemple via un temps passé, et a besoin du ticket complet pour continuer.
Attention
il lit une seule demande ; pour en parcourir plusieurs, List Issues convient mieux.
Redmine8

Get a Project

Action

Dans MakeGets a project.

Lit un projet Redmine et transmet son détail au module suivant, utile quand une notification ou un document doit reprendre les informations du projet.

Quand l'utiliser
après un déclencheur qui donne une référence de projet sans tout ce que tu veux montrer à un client.
Attention
ce module ne modifie rien ; associe-le à Update a Project si tu dois corriger ce que tu lis.
Redmine9

Get a Time Entry

Action

Dans MakeGets a time entry.

Va chercher un temps passé précis dans Redmine pour que ton scénario le vérifie avant de l'envoyer vers la facturation ou le reporting.

Quand l'utiliser
quand une autre appli garde la référence d'une saisie et que tu veux sa version actuelle, pas une vieille copie.
Attention
un module, une saisie ; pour une période ou un projet entier, List Time Entries les renvoie toutes en bundles séparés.
Redmine10

Make an API Call

Action

Dans MakePerforms an arbitrary authorized API call.

Appelle n'importe quel point d'entrée de l'API Redmine avec la connexion que tu as déjà, et couvre ce que les autres modules de la page laissent de côté.

Quand l'utiliser
quand ton besoin dépasse les demandes, les projets et les temps passés, seuls objets gérés par les modules prêts à l'emploi.
Attention
tu écris la requête toi-même, garde la doc de l'API Redmine ouverte et teste avec Run once.
Redmine11

Update an Issue

Action

Dans MakeUpdates an issue.

Modifie un ticket Redmine existant depuis l'extérieur, pour qu'il suive ce qui s'est passé dans un autre outil sans que personne n'y touche.

Quand l'utiliser
quand la réponse d'un client ou une mise à jour dans le CRM doit faire avancer la demande liée.
Attention
reprends le ticket depuis un module précédent au lieu de le saisir en dur, sinon chaque exécution modifie le même.
Redmine12

Update a Project

Action

Dans MakeUpdates a project.

Met à jour un projet Redmine existant pour qu'il reste cohérent avec la fiche client ou le contrat qui vit dans une autre appli.

Quand l'utiliser
quand un client change de nom ou qu'un contrat évolue, et que Redmine doit suivre sans passer par un admin.
Attention
fais un Run once sur un projet de test et compare le résultat dans Redmine avant de toucher aux vrais.
Redmine13

Update a Time Entry

Action

Dans MakeUpdates a time entry.

Corrige un temps déjà saisi dans Redmine, pour qu'un ajustement validé par un manager ou fait dans ton outil de pointage atteigne la saisie d'origine.

Quand l'utiliser
quand les heures sont revues après coup et que le bon chiffre doit remplacer le premier au lieu de s'y ajouter.
Attention
ne le confonds pas avec Create a Time Entry, qui ajouterait une seconde ligne au lieu de corriger la première.
Redmine14

List Issues

Recherche

Dans MakeLists issues.

Renvoie d'un coup un ensemble de demandes Redmine, chacune sous forme de bundle, idéal pour un récapitulatif, un rapport ou une mise à jour en masse.

Quand l'utiliser
quand il te faut tous les tickets ouverts d'un projet, pas seulement le dernier arrivé que Watch Issues attraperait.
Attention
une recherche peut renvoyer zéro, un ou plusieurs bundles, et chaque module suivant tourne une fois par bundle, ce qui pèse en opérations.
Redmine15

List Projects

Recherche

Dans MakeLists projects.

Ramène les projets Redmine visibles par ta connexion, un bundle par projet, pour qu'un scénario les passe tous en revue.

Quand l'utiliser
pour dresser une vue d'ensemble dans un tableur ou appliquer le même contrôle à chaque projet actif.
Attention
avec beaucoup de projets, les modules suivants tournent autant de fois ; ajoute un filtre juste après pour ne garder que l'utile.
Redmine16

List Time Entries

Recherche

Dans MakeLists time entries.

Rassemble les temps déjà saisis dans Redmine en bundles séparés, une bonne base pour une synthèse de feuilles de temps ou un export vers la facturation.

Quand l'utiliser
quand tu as besoin d'heures enregistrées avant la création du scénario, ou hors de ce que Watch Time Entries a vu passer.
Attention
sans résultat, la recherche renvoie zéro bundle et les modules suivants ne tournent tout simplement pas.
Besoin d'aide

Besoin d'aide pour automatiser Redmine avec Make ?

Une personne lit chaque message.

FAQ

Redmine et Make : les questions fréquentes

01L'intégration Redmine Make est-elle gratuite ?
Oui. Redmine est une app standard de Make, ses modules fonctionnent donc dès le plan Free. Ce plan donne 2 scénarios actifs, 15 minutes minimum entre deux exécutions planifiées, 5 minutes d'exécution au plus, des fichiers jusqu'à 5 Mo et 512 Mo de transfert. Les plans payants (Core, Pro, Teams, Enterprise) descendent à 1 minute d'intervalle et lèvent la limite de scénarios actifs. La consommation se compte en opérations : une par module et par bundle. L'abonnement Redmine, lui, se gère côté Redmine.
02Que faut-il pour connecter Redmine à Make ?
Un compte Redmine actif et sa clé API. Dans Redmine, ouvre My account dans le menu du haut, descends jusqu'à la section API access key et copie la clé. Dans Make, ajoute un module Redmine, clique sur Create a connection, donne un nom dans Connection name si tu veux, puis saisis les identifiants copiés ou suis les consignes à l'écran. La connexion s'enregistre une fois et tous tes modules Redmine la réutilisent, qu'ils surveillent, créent ou listent.
03Les déclencheurs Redmine réagissent-ils en temps réel dans Make ?
Non. Les 6 déclencheurs Redmine sont planifiés : Make interroge Redmine au rythme du scénario, Redmine ne le prévient pas. Un nouveau scénario tourne toutes les 15 minutes par défaut, et c'est aussi l'intervalle minimal sur le plan Free ; les plans payants descendent à 1 minute. Une nouvelle demande, un projet ou un temps passé arrive donc au passage suivant. Tout ce qui est trouvé à ce moment est traité ensemble, un bundle par élément.
04Que faire si le module Redmine dont tu as besoin n'existe pas ?
Passe par Make an API Call. Ce module appelle n'importe quel point d'entrée de l'API Redmine avec la même connexion que les autres, ce qui couvre ce que les 22 modules prêts à l'emploi laissent de côté : ils se limitent aux demandes, aux projets et aux temps passés. Tu rédiges la requête toi-même, alors teste-la avec Run once. Garde aussi en tête que la doc Make de Redmine est signalée comme générée par IA : vérifie les points importants dans Redmine.
05Make ou n8n pour Redmine ?
Ça dépend de l'outil où ton équipe construit déjà. Côté Make, Redmine offre 22 modules, dont 6 déclencheurs planifiés, une connexion par clé API et Make an API Call pour le reste. La même app a souvent un nœud n8n : si n8n est déjà ton standard, regarde ce que propose ce nœud avant de changer d'outil. Décide sur les modules dont tu as vraiment besoin et sur qui maintiendra le scénario, pas sur la marque.