Comment Utiliser l'API Make (Integromat) ?

En bref

L'API Make (anciennement Integromat) permet aux développeurs d'automatiser des workflows, de gérer des scénarios et d'exécuter des intégrations par programmation. Elle utilise l'authentification OAuth 2.0 et par clé API, des points de terminaison RESTful pour les scénarios, les exécutions, les webhooks et les équipes, avec des limites de débit de 60 à 600 requêtes par minute selon le plan. Ce guide couvre la configuration de l'authentification, la gestion des scénarios, les déclencheurs de webhook, la surveillance des exécutions et les stratégies d'automatisation de production.

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 créent des outils d'automatisation, gèrent des workflows clients ou s'intègrent à plus de 1000 applications, l'intégration de l'API Make n'est pas une option, elle est essentielle pour une automatisation évolutive.

Voici la réalité : les agences gérant plus de 50 automatisations clients perdent 15 à 25 heures par semaine en mises à jour manuelles de scénarios, en surveillance des exécutions et en rapports clients. Une solide intégration de l'API Make automatise le déploiement des scénarios, le suivi des exécutions, la gestion des erreurs et la création de rapports en marque blanche.

Ce guide vous présente le processus complet d'intégration de l'API Make. Vous apprendrez l'authentification OAuth 2.0 et par clé API, la gestion des scénarios, les déclencheurs de webhook, la surveillance des exécutions, la gestion des équipes et les stratégies de déploiement en production. À la fin, vous disposerez d'une intégration Make prête pour la production.

Qu'est-ce que l'API Make ?

Make fournit une API RESTful pour gérer les workflows d'automatisation par programmation. L'API gère :

• Création, mise à jour et suppression de scénarios
• Exécution de scénarios (déclenchement manuel)
• Historique et surveillance des exécutions
• Gestion des webhooks
• Gestion des équipes et des utilisateurs
• Gestion des connexions et des applications
• Paramètres de l'organisation et de l'espace de travail

Fonctionnalités clés

Plans Make et accès API

Vue d'ensemble de l'architecture API

Make utilise une structure d'API RESTful :

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

Versions de l'API

Démarrage : Configuration de l'authentification

Étape 1 : Créer un compte Make

Avant d'accéder à l'API :

1. Visitez Make.com
2. Inscrivez-vous pour un compte
3. Accédez à Paramètres > Paramètres développeur
4. Générez les identifiants API

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

Make prend en charge deux méthodes d'authentification :

Étape 3 : Obtenir la clé API (méthode la plus simple)

Générez la clé API pour usage interne :

1. Allez dans Paramètres > Paramètres développeur
2. Cliquez sur Créer une clé API
3. Copiez et stockez en toute sécurité

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

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

Configurez OAuth pour les intégrations client :

1. Allez dans Paramètres > Paramètres développeur > Applications OAuth
2. Cliquez sur Créer une application OAuth
3. Configurez l'URI de redirection
4. Obtenez les identifiants 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;

// Build authorization URL
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 contre un jeton d'accès

Gérez le rappel OAuth :

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
  };
};

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

  try {
    const tokens = await exchangeCodeForToken(code);

    // Store tokens securely
    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 API 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();
};

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

Gestion des scénarios

Lister les scénarios

Récupérer tous 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;
};

// Usage
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 du scénario

Récupérer un seul scénario :

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

// Usage
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

Créer un nouveau scénario :

const createScenario = async (scenarioData) => {
  const scenario = {
    name: scenarioData.name,
    blueprint: scenarioData.blueprint, // Scenario 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;
};

// Usage - Create from blueprint
const newScenario = await createScenario({
  name: 'Lead Sync to CRM',
  blueprint: {
    // Scenario blueprint JSON
    // Export from Make editor or build programmatically
    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

Modifier la configuration du scénario :

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

  return response;
};

// Usage - Pause scenario
await updateScenario('12345', { active: false });

// Usage - Update schedule
await updateScenario('12345', {
  schedule: {
    cronExpression: '0 */6 * * *', // Every 6 hours
    timezone: 'America/New_York'
  }
});

Supprimer un scénario

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

Exécuter un scénario manuellement :

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

  return response;
};

// Usage - Run without input
const execution = await executeScenario('12345');
console.log(`Execution started: ${execution.id}`);

// Usage - Run with input data
const executionWithData = await executeScenario('12345', {
  lead: {
    email: 'prospect@example.com',
    name: 'John Doe',
    company: 'Acme Corp'
  }
});

Obtenir l'historique d'exécution

Récupérer les journaux 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;
};

// Usage - Get failed executions from last 24 hours
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 de l'exécution

Récupérer une seule exécution :

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

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

Arrêter l'exécution en cours

Annuler l'exécution :

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

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

Gestion des webhooks

Créer un webhook

Configurer un webhook entrant :

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

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

  return response;
};

// Usage
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

Récupérer tous les webhooks :

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

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

Supprimer un webhook

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

Récupérer les utilisateurs de l'organisation :

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

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

Ajouter un membre à l'équipe

Inviter un utilisateur à l'organisation :

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;
};

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

Mettre à jour le rôle d'un utilisateur

Modifier les permissions de l'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

Limitation du débit

Comprendre les limites de débit

Make applique des limites de débit par plan :

En-têtes de limitation de débit

Implémentation de la gestion de la limitation de débit

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 les clés API pour les intégrations internes, OAuth pour les intégrations client
• [ ] Stocker les identifiants en toute sécurité (base de données chiffrée)
• [ ] Implémenter la limitation du débit et la mise en file d'attente des requêtes
• [ ] Mettre en place la surveillance et l'alerte des exécutions
• [ ] Configurer les notifications d'erreur (e-mail, Slack)
• [ ] Implémenter une logique de nouvelle tentative pour les exécutions échouées
• [ ] Ajouter une journalisation complète
• [ ] Créer une sauvegarde/exportation des scénarios critiques

Cas d'utilisation concrets

Gestion des clients d'agence

Une agence marketing gère plus de 100 automatisations clients :

• Défi : Mises à jour manuelles des scénarios à travers les comptes clients
• Solution : Tableau de bord centralisé avec l'API Make
• Résultat : 70% de gain de temps, déploiements cohérents

Implémentation clé :

• Intégration OAuth multi-comptes
• Déploiement de scénarios en masse
• Rapports d'utilisation client

Traitement des commandes e-commerce

Une boutique en ligne automatise l'exécution des commandes :

• Défi : Saisie manuelle des commandes dans le système d'entrepôt
• Solution : Scénario Make déclenché par webhook
• Résultat : Aucune saisie manuelle, 99,9% de précision

Implémentation clé :

• Webhook Shopify vers Make
• Le scénario traite la commande, met à jour l'entrepôt
• Gestion des erreurs avec logique de nouvelle tentative

Conclusion

L'API Make offre des capacités complètes d'automatisation des workflows. Points clés à retenir :

• Clé API pour usage interne, OAuth 2.0 pour les applications multi-locataires
• Opérations CRUD complètes pour les scénarios, exécutions, webhooks
• Gestion d'équipe pour le contrôle de l'organisation
• Les limites de débit varient selon le plan (60-600 requêtes/minute)
• La surveillance des exécutions est essentielle pour la production
• Apidog simplifie les tests API et la collaboration d'équipe

Comment m'authentifier avec l'API Make ?

Utilisez la clé API des paramètres développeur pour les intégrations internes, ou OAuth 2.0 pour les applications multi-locataires.

Puis-je déclencher des scénarios par programmation ?

Oui, utilisez le point de terminaison /scenarios/{id}/execute pour déclencher manuellement des exécutions de scénarios avec des données d'entrée facultatives.

Quelles sont les limites de débit de Make ?

Les limites de débit varient de 60 requêtes/minute (Gratuit) à 600 requêtes/minute (Équipes/Entreprise).

Comment obtenir les journaux d'exécution ?

Utilisez /scenarios/{id}/executions pour récupérer l'historique d'exécution avec filtrage par date et statut.

Puis-je créer des webhooks via l'API ?

Oui, utilisez le point de terminaison /webhooks pour créer, lister et supprimer des webhooks pour les scénarios.