Make (Integromat) API nutzen: Anleitung & Tipps

Kurz gesagt

Die Make (ehemals Integromat) API ermöglicht Entwicklern, Workflows zu automatisieren, Szenarien zu verwalten und Integrationen programmatisch auszuführen. Sie verwendet OAuth 2.0 und API-Schlüssel-Authentifizierung, RESTful-Endpunkte für Szenarien, Ausführungen, Webhooks und Teams, mit Ratenbegrenzungen von 60-600 Anfragen pro Minute je nach Plan. Dieser Leitfaden behandelt die Einrichtung der Authentifizierung, das Szenario-Management, Webhook-Trigger, die Überwachung von Ausführungen und Strategien zur Produktionsautomatisierung.

Einführung

Make (Integromat) verarbeitet monatlich über 2 Milliarden Operationen für mehr als 1 Million Benutzer in über 100 Ländern. Für Entwickler, die Automatisierungstools erstellen, Kunden-Workflows verwalten oder Integrationen mit über 1000 Apps vornehmen, ist die Make API-Integration nicht optional – sie ist entscheidend für skalierbare Automatisierung.

Hier ist die Realität: Agenturen, die über 50 Kundenautomatisierungen verwalten, verlieren wöchentlich 15-25 Stunden durch manuelle Szenario-Updates, Ausführungsüberwachung und Kundenberichte. Eine solide Make API-Integration automatisiert die Szenario-Bereitstellung, die Ausführungsverfolgung, die Fehlerbehandlung und das White-Label-Reporting.

Dieser Leitfaden führt Sie durch den vollständigen Prozess der Make API-Integration. Sie lernen die OAuth 2.0- und API-Schlüssel-Authentifizierung, das Szenario-Management, Webhook-Trigger, die Ausführungsüberwachung, das Team-Management und Strategien zur Produktionsbereitstellung kennen. Am Ende werden Sie eine produktionsreife Make-Integration haben.

Was ist die Make API?

Make bietet eine RESTful API zur programmatischen Verwaltung von Automatisierungs-Workflows. Die API handhabt:

• Erstellung, Aktualisierung und Löschung von Szenarien
• Ausführung von Szenarien (manuelles Auslösen)
• Ausführungsverlauf und Überwachung
• Webhook-Verwaltung
• Team- und Benutzerverwaltung
• Verbindungs- und App-Verwaltung
• Organisations- und Arbeitsbereichseinstellungen

Hauptmerkmale

Make Pläne und API-Zugriff

Übersicht über die API-Architektur

Make verwendet eine RESTful API-Struktur:

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

API-Versionen

Erste Schritte: Authentifizierung einrichten

Schritt 1: Make-Konto erstellen

Vor dem Zugriff auf die API:

1. Besuchen Sie Make.com
2. Registrieren Sie sich für ein Konto
3. Navigieren Sie zu Einstellungen > Entwicklereinstellungen
4. API-Anmeldeinformationen generieren

Schritt 2: Authentifizierungsmethode wählen

Make unterstützt zwei Authentifizierungsmethoden:

Schritt 3: API-Schlüssel abrufen (einfachste Methode)

API-Schlüssel für die interne Nutzung generieren:

1. Gehen Sie zu Einstellungen > Entwicklereinstellungen
2. Klicken Sie auf API-Schlüssel erstellen
3. Kopieren und sicher speichern

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

Schritt 4: OAuth 2.0 einrichten (für Multi-Tenant-Apps)

Konfigurieren Sie OAuth für Client-Integrationen:

1. Gehen Sie zu Einstellungen > Entwicklereinstellungen > OAuth-Apps
2. Klicken Sie auf OAuth-App erstellen
3. Umleitungs-URI konfigurieren
4. Client-Anmeldeinformationen abrufen

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()}`;
};

Schritt 5: Code gegen Zugangs-Token austauschen

OAuth-Callback handhaben:

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

Schritt 6: Authentifizierte API-Aufrufe tätigen

Wiederverwendbaren API-Client erstellen:

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

// Nutzung
const scenarios = await makeRequest('/scenarios');
console.log(`Es wurden ${scenarios.data.length} Szenarien gefunden`);

Szenario-Verwaltung

Szenarien auflisten

Alle Szenarien abrufen:

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

// Nutzung
const scenarios = await listScenarios({ limit: 100 });
scenarios.data.forEach(scenario => {
  console.log(`${scenario.name} - ${scenario.active ? 'Aktiv' : 'Pausiert'}`);
  console.log(`  Letzter Lauf: ${scenario.lastRunDate || 'Nie'}`);
});

Szenario-Details abrufen

Einzelnes Szenario abrufen:

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

// Nutzung
const scenario = await getScenario('12345');
console.log(`Name: ${scenario.name}`);
console.log(`Module: ${scenario.modules.length}`);
console.log(`Zeitplan: ${scenario.schedule?.cronExpression || 'Manuell'}`);

Szenario erstellen

Neues Szenario erstellen:

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

// Nutzung - Aus Blueprint erstellen
const newScenario = await createScenario({
  name: 'Lead Sync to CRM',
  blueprint: {
    // Szenario-Blueprint (JSON)
    // Aus Make-Editor exportieren oder programmatisch erstellen
    modules: [
      {
        id: 1,
        app: 'webhooks',
        action: 'customWebhook',
        parameters: { /* ... */ }
      },
      {
        id: 2,
        app: 'salesforce',
        action: 'createRecord',
        parameters: { /* ... */ }
      }
    ],
    connections: [
      { from: 1, to: 2 }
    ]
  },
  active: true,
  description: 'Webhook-Leads mit Salesforce synchronisieren'
});

console.log(`Szenario erstellt: ${newScenario.id}`);

Szenario aktualisieren

Szenario-Konfiguration ändern:

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

  return response;
};

// Nutzung - Szenario pausieren
await updateScenario('12345', { active: false });

// Nutzung - Zeitplan aktualisieren
await updateScenario('12345', {
  schedule: {
    cronExpression: '0 */6 * * *', // Alle 6 Stunden
    timezone: 'America/New_York'
  }
});

Szenario löschen

Szenario entfernen:

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

  console.log(`Szenario ${scenarioId} gelöscht`);
};

Ausführungsverwaltung

Szenario-Ausführung auslösen

Szenario manuell ausführen:

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

  return response;
};

// Nutzung - Ohne Eingabe ausführen
const execution = await executeScenario('12345');
console.log(`Ausführung gestartet: ${execution.id}`);

// Nutzung - Mit Eingabedaten ausführen
const executionWithData = await executeScenario('12345', {
  lead: {
    email: 'prospect@example.com',
    name: 'John Doe',
    company: 'Acme Corp'
  }
});

Ausführungsverlauf abrufen

Ausführungsprotokolle abrufen:

const getExecutionHistory = async (scenarioId, filters = {}) => {
  const params = new URLSearchParams({
    limit: filters.limit || 50,
    from: filters.from,
    to: filters.to,
    status: filters.status // 'erfolgreich', 'fehler', 'läuft'
  });

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

// Nutzung - Fehlgeschlagene Ausführungen der letzten 24 Stunden abrufen
const failedExecutions = await getExecutionHistory('12345', {
  from: new Date(Date.now() - 86400000).toISOString(),
  status: 'error',
  limit: 100
});

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

Ausführungsdetails abrufen

Einzelne Ausführung abrufen:

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

// Nutzung
const execution = await getExecution('98765');
console.log(`Status: ${execution.status}`);
console.log(`Dauer: ${execution.duration}ms`);
console.log(`Ausgeführte Module: ${execution.modulesExecuted}`);

Laufende Ausführung stoppen

Ausführung abbrechen:

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

  console.log(`Ausführung ${executionId} gestoppt`);
};

Webhook-Verwaltung

Webhook erstellen

Eingehenden Webhook einrichten:

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

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

  return response;
};

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

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

Webhooks auflisten

Alle Webhooks abrufen:

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

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

Webhook löschen

Webhook entfernen:

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

  console.log(`Webhook ${webhookId} gelöscht`);
};

Team- und Benutzerverwaltung

Teammitglieder auflisten

Benutzer in der Organisation abrufen:

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

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

Teammitglied hinzufügen

Benutzer zur Organisation einladen:

const addTeamMember = async (organizationId, email, role) => {
  const response = await makeRequest(`/organizations/${organizationId}/users`, {
    method: 'POST',
    body: JSON.stringify({
      email: email,
      role: role // 'Betrachter', 'Ersteller', 'Manager', 'Administrator'
    })
  });

  return response;
};

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

Benutzerrolle aktualisieren

Benutzerberechtigungen ändern:

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

  console.log(`Benutzer ${userId} Rolle aktualisiert auf ${newRole}`);
};

Benutzerrollen

Ratenbegrenzung

Ratenbegrenzungen verstehen

Make erzwingt Ratenbegrenzungen nach Plan:

Ratenbegrenzung-Header

Implementierung der Ratenbegrenzungsbehandlung

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(`Niedrige Ratenbegrenzung: ${remaining} verbleibend`);
      }

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

Checkliste für die Produktionsbereitstellung

Vor der Live-Schaltung:

• [ ] API-Schlüssel für interne, OAuth für Client-Integrationen verwenden
• [ ] Anmeldeinformationen sicher speichern (verschlüsselte Datenbank)
• [ ] Ratenbegrenzung und Anfragen-Warteschlange implementieren
• [ ] Ausführungsüberwachung und -alarmierung einrichten
• [ ] Fehlerbenachrichtigungen konfigurieren (E-Mail, Slack)
• [ ] Wiederholungslogik für fehlgeschlagene Ausführungen implementieren
• [ ] Umfassendes Logging hinzufügen
• [ ] Backup/Export kritischer Szenarien erstellen

Praxisbeispiele

Agentur-Kundenverwaltung

Eine Marketingagentur verwaltet über 100 Kundenautomatisierungen:

• Herausforderung: Manuelle Szenario-Updates über alle Kundenkonten hinweg
• Lösung: Zentrales Dashboard mit Make API
• Ergebnis: 70% Zeitersparnis, konsistente Bereitstellungen

Schlüsselimplementierung:

• Multi-Konto OAuth-Integration
• Massen-Szenario-Bereitstellung
• Kunden-Nutzungsberichte

E-Commerce-Auftragsabwicklung

Ein Online-Shop automatisiert die Auftragsabwicklung:

• Herausforderung: Manuelle Auftragseingabe in das Lagersystem
• Lösung: Webhook-gesteuertes Make-Szenario
• Ergebnis: Keine manuelle Eingabe, 99,9% Genauigkeit

Schlüsselimplementierung:

• Shopify Webhook an Make
• Szenario verarbeitet Bestellung, aktualisiert Lager
• Fehlerbehandlung mit Wiederholungslogik

Fazit

Die Make API bietet umfassende Workflow-Automatisierungsfunktionen. Wichtige Erkenntnisse:

• API-Schlüssel für interne Nutzung, OAuth 2.0 für Multi-Tenant-Apps
• Vollständiges CRUD für Szenarien, Ausführungen, Webhooks
• Team-Management zur Organisationssteuerung
• Ratenbegrenzungen variieren je nach Plan (60-600 Anfragen/Minute)
• Ausführungsüberwachung unerlässlich für die Produktion
• Apidog optimiert API-Tests und Teamzusammenarbeit

Wie authentifiziere ich mich bei der Make API?

Verwenden Sie einen API-Schlüssel aus den Entwicklereinstellungen für interne Integrationen oder OAuth 2.0 für Multi-Tenant-Anwendungen.

Kann ich Szenarien programmatisch auslösen?

Ja, verwenden Sie den Endpunkt /scenarios/{id}/execute, um Szenarioläufe manuell mit optionalen Eingabedaten auszulösen.

Was sind die Make-Ratenbegrenzungen?

Die Ratenbegrenzungen reichen von 60 Anfragen/Minute (Kostenlos) bis 600 Anfragen/Minute (Teams/Enterprise).

Wie erhalte ich Ausführungsprotokolle?

Verwenden Sie /scenarios/{id}/executions, um den Ausführungsverlauf mit Filterung nach Datum und Status abzurufen.

Kann ich Webhooks über die API erstellen?

Ja, verwenden Sie den /webhooks-Endpunkt, um Webhooks für Szenarien zu erstellen, aufzulisten und zu löschen.