Antoine Laurent

Posted on Mar 25 • Originally published at apidog.com

Comment Utiliser l'API Make (Integromat) ?

En bref

L'API Make (anciennement Integromat) permet d'automatiser des workflows, gérer des scénarios et exécuter des intégrations par programmation. Elle supporte OAuth 2.0 et les clés API, fournit des endpoints RESTful pour les scénarios, exécutions, webhooks et équipes, avec des limites de débit de 60 à 600 requêtes/min selon le plan. Ce guide détaille la configuration de l'authentification, la gestion des scénarios, l'utilisation des webhooks, la surveillance des exécutions et les bonnes pratiques de déploiement en production.

Essayez Apidog dès aujourd'hui

Introduction

Make (Integromat) traite plus de 2 milliards d'opérations par mois pour plus d'un million d'utilisateurs dans plus de 100 pays. Pour les développeurs qui automatisent la gestion de workflows, intègrent avec plus de 1000 applications ou déploient des outils pour leurs clients, maîtriser l’API Make est indispensable pour une automatisation robuste.

Les agences avec plus de 50 automatisations client perdent 15 à 25 heures par semaine en tâches manuelles (mises à jour des scénarios, surveillance, reporting). L’API Make permet d’automatiser le déploiement, la gestion d’erreurs, le suivi des exécutions et le reporting en marque blanche.

Ce guide vous donne le process complet : authentification OAuth 2.0 et clé API, gestion des scénarios, webhooks, exécutions, équipes et stratégies de déploiement. À la fin, vous serez prêt pour une intégration Make en production.

💡 Apidog simplifie les tests d'intégration API. Testez vos endpoints Make, validez les flux OAuth, inspectez les réponses d'exécution et déboguez les problèmes d'automatisation dans un seul espace. Importez des spécifications API, simulez les réponses et partagez les scénarios de test en équipe.

Qu'est-ce que l'API Make ?

L'API RESTful de Make permet de piloter par code :

Création, mise à jour, suppression de scénarios
Exécution manuelle de scénarios
Historique et surveillance des exécutions
Gestion des webhooks
Gestion des équipes et utilisateurs
Gestion des connexions/applications
Paramètres organisation et espace de travail

Fonctionnalités clés

Fonctionnalité	Description
API RESTful	Endpoints JSON
OAuth 2.0 + Clés API	Authentification flexible
Webhooks	Notifications d'exécution en temps réel
Limitation du débit	60-600 requêtes/min selon le plan
Gestion des scénarios	CRUD complet
Contrôle d'exécution	Démarrer, arrêter, surveiller
API d'équipe	Gestion des utilisateurs et permissions

Plans Make et accès API

Plan	Accès API	Limite de débit	Idéal pour
Gratuit	Limité	60/min	Tests, apprentissage
Essentiel	API complète	120/min	Petites entreprises
Pro	API complète + Priorité	300/min	Équipes en croissance
Équipes	API complète + Admin	600/min	Agences, entreprises
Entreprise	Limites personnalisées	Personnalisé	Grandes organisations

Vue d'ensemble de l'architecture API

Base de l’API :

https://api.make.com/api/v2/

Versions de l’API

Version	Statut	Cas d'utilisation
v2	Actuelle	Toutes les nouvelles intégrations
v1	Dépréciée	Anciennes intégrations (à migrer)

Démarrage : Configuration de l’authentification

Étape 1 : Créer un compte Make

Rendez-vous sur Make.com
Inscrivez-vous
Menu : Paramètres > Paramètres développeur
Générez vos identifiants API

Étape 2 : Choisir la méthode d’authentification

Méthode	Idéal pour	Niveau de sécurité
Clé API	Intégrations internes, scripts	Élevé (stocker en toute sécurité)
OAuth 2.0	Applications multi-locataires, clients	Plus élevé (jetons à portée utilisateur)

Étape 3 : Obtenir la clé API (usage interne)

Paramètres > Paramètres développeur
Cliquez sur Créer une clé API
Copiez et stockez dans un gestionnaire sécurisé

# .env
MAKE_API_KEY="your_api_key_here"
MAKE_ORGANIZATION_ID="your_org_id"

Étape 4 : Configurer OAuth 2.0 (applications multi-locataires)

Paramètres > Paramètres développeur > Applications OAuth
Cliquez sur Créer une application OAuth
Configurez l’URI de redirection
Récupérez l’ID et le secret client

const MAKE_CLIENT_ID = process.env.MAKE_CLIENT_ID;
const MAKE_CLIENT_SECRET = process.env.MAKE_CLIENT_SECRET;
const MAKE_REDIRECT_URI = process.env.MAKE_REDIRECT_URI;

// Générer l'URL d'autorisation
const getAuthUrl = (state) => {
  const params = new URLSearchParams({
    client_id: MAKE_CLIENT_ID,
    redirect_uri: MAKE_REDIRECT_URI,
    scope: 'read write execute',
    state: state,
    response_type: 'code'
  });

  return `https://www.make.com/oauth/authorize?${params.toString()}`;
};

Étape 5 : Échanger le code OAuth contre un jeton

const exchangeCodeForToken = async (code) => {
  const response = await fetch('https://www.make.com/oauth/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      client_id: MAKE_CLIENT_ID,
      client_secret: MAKE_CLIENT_SECRET,
      redirect_uri: MAKE_REDIRECT_URI,
      code: code
    })
  });

  const data = await response.json();

  return {
    accessToken: data.access_token,
    refreshToken: data.refresh_token,
    expiresIn: data.expires_in
  };
};

// Callback handler
app.get('/oauth/callback', async (req, res) => {
  const { code, state } = req.query;

  try {
    const tokens = await exchangeCodeForToken(code);

    // Stocker les tokens
    await db.integrations.create({
      userId: req.session.userId,
      accessToken: tokens.accessToken,
      refreshToken: tokens.refreshToken,
      tokenExpiry: Date.now() + (tokens.expiresIn * 1000)
    });

    res.redirect('/success');
  } catch (error) {
    console.error('OAuth error:', error);
    res.status(500).send('Authentication failed');
  }
});

Étape 6 : Effectuer des appels API authentifiés

Créez un client Make réutilisable :

const MAKE_BASE_URL = 'https://api.make.com/api/v2';

const makeRequest = async (endpoint, options = {}) => {
  const apiKey = options.useOAuth ? await getOAuthToken() : process.env.MAKE_API_KEY;

  const response = await fetch(`${MAKE_BASE_URL}${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Token ${apiKey}`,
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Make API Error: ${error.message}`);
  }

  return response.json();
};

// Exemple d'utilisation
const scenarios = await makeRequest('/scenarios');
console.log(`Found ${scenarios.data.length} scenarios`);

Gestion des scénarios

Lister les scénarios

const listScenarios = async (filters = {}) => {
  const params = new URLSearchParams({
    limit: filters.limit || 50,
    offset: filters.offset || 0
  });

  if (filters.folder) {
    params.append('folder', filters.folder);
  }

  const response = await makeRequest(`/scenarios?${params.toString()}`);
  return response;
};

// Utilisation
const scenarios = await listScenarios({ limit: 100 });
scenarios.data.forEach(scenario => {
  console.log(`${scenario.name} - ${scenario.active ? 'Active' : 'Paused'}`);
  console.log(`  Last run: ${scenario.lastRunDate || 'Never'}`);
});

Obtenir les détails d’un scénario

const getScenario = async (scenarioId) => {
  const response = await makeRequest(`/scenarios/${scenarioId}`);
  return response;
};

// Utilisation
const scenario = await getScenario('12345');
console.log(`Name: ${scenario.name}`);
console.log(`Modules: ${scenario.modules.length}`);
console.log(`Schedule: ${scenario.schedule?.cronExpression || 'Manual'}`);

Créer un scénario

const createScenario = async (scenarioData) => {
  const scenario = {
    name: scenarioData.name,
    blueprint: scenarioData.blueprint, // JSON blueprint
    active: scenarioData.active || false,
    priority: scenarioData.priority || 1,
    maxErrors: scenarioData.maxErrors || 3,
    autoCommit: scenarioData.autoCommit || true,
    description: scenarioData.description || ''
  };

  const response = await makeRequest('/scenarios', {
    method: 'POST',
    body: JSON.stringify(scenario)
  });

  return response;
};

// Exemple : création depuis un blueprint
const newScenario = await createScenario({
  name: 'Lead Sync to CRM',
  blueprint: {
    modules: [
      { id: 1, app: 'webhooks', action: 'customWebhook', parameters: {} },
      { id: 2, app: 'salesforce', action: 'createRecord', parameters: {} }
    ],
    connections: [
      { from: 1, to: 2 }
    ]
  },
  active: true,
  description: 'Sync webhook leads to Salesforce'
});

console.log(`Scenario created: ${newScenario.id}`);

Mettre à jour un scénario

const updateScenario = async (scenarioId, updates) => {
  const response = await makeRequest(`/scenarios/${scenarioId}`, {
    method: 'PATCH',
    body: JSON.stringify(updates)
  });

  return response;
};

// Mettre en pause un scénario
await updateScenario('12345', { active: false });

// Modifier le schedule
await updateScenario('12345', {
  schedule: {
    cronExpression: '0 */6 * * *', // Toutes les 6h
    timezone: 'America/New_York'
  }
});

Supprimer un scénario

const deleteScenario = async (scenarioId) => {
  await makeRequest(`/scenarios/${scenarioId}`, {
    method: 'DELETE'
  });

  console.log(`Scenario ${scenarioId} deleted`);
};

Gestion des exécutions

Déclencher l’exécution d’un scénario

const executeScenario = async (scenarioId, inputData = null) => {
  const response = await makeRequest(`/scenarios/${scenarioId}/execute`, {
    method: 'POST',
    body: inputData ? JSON.stringify(inputData) : undefined
  });

  return response;
};

// Exécution simple
const execution = await executeScenario('12345');
console.log(`Execution started: ${execution.id}`);

// Avec données d'entrée
const executionWithData = await executeScenario('12345', {
  lead: {
    email: 'prospect@example.com',
    name: 'John Doe',
    company: 'Acme Corp'
  }
});

Obtenir l’historique d’exécution

const getExecutionHistory = async (scenarioId, filters = {}) => {
  const params = new URLSearchParams({
    limit: filters.limit || 50,
    from: filters.from,
    to: filters.to,
    status: filters.status // 'success', 'error', 'running'
  });

  const response = await makeRequest(`/scenarios/${scenarioId}/executions?${params.toString()}`);
  return response;
};

// Exécution échouées des dernières 24h
const failedExecutions = await getExecutionHistory('12345', {
  from: new Date(Date.now() - 86400000).toISOString(),
  status: 'error',
  limit: 100
});

failedExecutions.data.forEach(exec => {
  console.log(`Execution ${exec.id}: ${exec.error?.message}`);
});

Obtenir les détails d’une exécution

const getExecution = async (executionId) => {
  const response = await makeRequest(`/executions/${executionId}`);
  return response;
};

// Utilisation
const execution = await getExecution('98765');
console.log(`Status: ${execution.status}`);
console.log(`Duration: ${execution.duration}ms`);
console.log(`Modules executed: ${execution.modulesExecuted}`);

Arrêter une exécution en cours

const stopExecution = async (executionId) => {
  await makeRequest(`/executions/${executionId}`, {
    method: 'DELETE'
  });

  console.log(`Execution ${executionId} stopped`);
};

Gestion des webhooks

Créer un webhook

const createWebhook = async (webhookData) => {
  const webhook = {
    name: webhookData.name,
    scenarioId: webhookData.scenarioId,
    type: 'custom', // 'custom' ou 'raw'
    hookType: 'HEAD', // 'HEAD' ou 'GET'
    security: {
      type: 'none' // 'none', 'basic', 'token'
    }
  };

  const response = await makeRequest('/webhooks', {
    method: 'POST',
    body: JSON.stringify(webhook)
  });

  return response;
};

// Utilisation
const webhook = await createWebhook({
  name: 'Lead Capture Webhook',
  scenarioId: '12345',
  type: 'custom',
  hookType: 'HEAD',
  security: { type: 'none' }
});

console.log(`Webhook URL: ${hook.url}`);

Lister les webhooks

const listWebhooks = async () => {
  const response = await makeRequest('/webhooks');
  return response;
};

// Utilisation
const webhooks = await listWebhooks();
webhooks.data.forEach(webhook => {
  console.log(`${webhook.name}: ${webhook.url}`);
});

Supprimer un webhook

const deleteWebhook = async (webhookId) => {
  await makeRequest(`/webhooks/${webhookId}`, {
    method: 'DELETE'
  });

  console.log(`Webhook ${webhookId} deleted`);
};

Gestion des équipes et des utilisateurs

Lister les membres de l’équipe

const listTeamMembers = async (organizationId) => {
  const response = await makeRequest(`/organizations/${organizationId}/users`);
  return response;
};

// Utilisation
const members = await listTeamMembers('org-123');
members.data.forEach(member => {
  console.log(`${member.email} - ${member.role}`);
});

Ajouter un membre à l’équipe

const addTeamMember = async (organizationId, email, role) => {
  const response = await makeRequest(`/organizations/${organizationId}/users`, {
    method: 'POST',
    body: JSON.stringify({
      email: email,
      role: role // 'viewer', 'builder', 'manager', 'admin'
    })
  });

  return response;
};

// Utilisation
await addTeamMember('org-123', 'newuser@example.com', 'builder');

Mettre à jour le rôle d’un utilisateur

const updateUserRole = async (organizationId, userId, newRole) => {
  await makeRequest(`/organizations/${organizationId}/users/${userId}`, {
    method: 'PATCH',
    body: JSON.stringify({ role: newRole })
  });

  console.log(`User ${userId} role updated to ${newRole}`);
};

Rôles d’utilisateur

Rôle	Permissions
Lecteur	Consulter les scénarios, aucune modification
Constructeur	Créer/modifier des scénarios
Gestionnaire	Gérer l'équipe, la facturation
Admin	Accès complet à l'organisation

Limitation du débit

Comprendre les limites de débit

Plan	Requêtes/Minute	Limite de rafale
Gratuit	60	100
Essentiel	120	200
Pro	300	500
Équipes	600	1000
Entreprise	Personnalisé	Personnalisé

En-têtes de limitation de débit

En-tête	Description
`X-RateLimit-Limit`	Nombre max de requêtes par minute
`X-RateLimit-Remaining`	Requêtes restantes
`X-RateLimit-Reset`	Secondes avant la réinitialisation

Implémentation de la gestion du rate limiting

const makeRateLimitedRequest = async (endpoint, options = {}, maxRetries = 3) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await makeRequest(endpoint, options);

      const remaining = response.headers.get('X-RateLimit-Remaining');
      if (remaining < 10) {
        console.warn(`Low rate limit: ${remaining} remaining`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Rate limited. Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

Liste de contrôle pour le déploiement en production

Avant la mise en ligne :

[ ] Utiliser clés API pour intégrations internes, OAuth pour clients
[ ] Stocker les identifiants de façon sécurisée (DB chiffrée)
[ ] Implémenter gestion du débit et file d’attente de requêtes
[ ] Surveiller et alerter sur les exécutions
[ ] Notifications d’erreur (email, Slack…)
[ ] Logique de retry pour les échecs d’exécution
[ ] Journalisation complète
[ ] Sauvegarde/export des scénarios critiques

Cas d’utilisation concrets

Gestion des clients d’agence

Défi : Mises à jour manuelles de scénarios sur de multiples comptes clients

Solution : Dashboard centralisé via l’API Make

Résultat : 70% de temps gagné, déploiements fiables

Implémentez :

Intégration OAuth multi-comptes
Déploiement/scaling de scénarios en masse
Rapports d’utilisation client

Traitement des commandes e-commerce

Défi : Saisie manuelle des commandes dans l’entrepôt

Solution : Scénario Make déclenché par webhook

Résultat : Zéro saisie manuelle, 99,9% de précision

Implémentez :