Make (Integromat) API nutzen: Anleitung & Tipps

Kurz gesagt

Die Make (ehemals Integromat) API ermöglicht es Entwicklern, Workflows zu automatisieren, Szenarien zu verwalten und Integrationen programmatisch auszuführen. Sie nutzt OAuth 2.0 und API-Schlüssel-Authentifizierung sowie RESTful-Endpunkte für Szenarien, Ausführungen, Webhooks und Teams. Je nach Plan gelten Ratenbegrenzungen von 60-600 Anfragen pro Minute. In diesem Leitfaden erhältst du eine Schritt-für-Schritt-Anleitung zur Authentifizierung, zum Szenario-Management, zur Nutzung von Webhook-Triggern, zur Überwachung von Ausführungen und zu Best Practices für Produktionsautomatisierung.

Teste Apidog noch heute

💡Apidog vereinfacht das Testen von API-Integrationen. Teste deine Make-Endpunkte, validiere OAuth-Flows, prüfe Ausführungsantworten und debugge Automatisierungsprobleme in einem einzigen Workspace. Importiere API-Spezifikationen, modelliere Antworten und teile Testszenarien mit deinem Team.

Was ist die Make API?

Make stellt eine RESTful API bereit, um Automatisierungs-Workflows programmatisch zu verwalten:

• Szenarien (Erstellen, Aktualisieren, Löschen)
• Manuelles Auslösen von Szenarien
• Ausführungsverlauf und Monitoring
• Webhook-Verwaltung
• Team- und Benutzerverwaltung
• Verbindungs- und App-Management
• Organisations- und Workspace-Einstellungen

Hauptmerkmale

Merkmal	Beschreibung
RESTful API	JSON-basierte Endpunkte
OAuth 2.0 + API-Schlüssel	Flexible Authentifizierung
Webhooks	Echtzeit-Ausführungsbenachrichtigungen
Ratenbegrenzung	60-600 Anfragen/Minute je nach Plan
Szenario-Management	Vollständige CRUD-Operationen
Ausführungssteuerung	Läufe starten, stoppen, überwachen
Team-API	Benutzer- und Berechtigungsverwaltung

Make Pläne und API-Zugriff

Plan	API-Zugriff	Ratenbegrenzung	Am besten geeignet für
Kostenlos	Begrenzt	60/Min.	Testen, Lernen
Core	Volle API	120/Min.	Kleine Unternehmen
Pro	Volle API + Priorität	300/Min.	Wachsende Teams
Teams	Volle API + Admin	600/Min.	Agenturen, Großunternehmen
Enterprise	Benutzerdefinierte Limits	Benutzerdefiniert	Große Organisationen

Übersicht über die API-Architektur

Make verwendet folgende Basis-URL für alle Endpunkte:

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

API-Versionen

Version	Status	Anwendungsfall
v2	Aktuell	Alle neuen Integrationen
v1	Veraltet	Legacy-Integrationen (migrieren)

Erste Schritte: Authentifizierung einrichten

Schritt 1: Make-Konto erstellen

1. Besuche Make.com
2. Registriere dich für ein Konto
3. Navigiere zu Einstellungen > Entwicklereinstellungen
4. API-Anmeldedaten generieren

Schritt 2: Authentifizierungsmethode wählen

Make unterstützt:

Methode	Am besten geeignet für	Sicherheitsstufe
API-Schlüssel	Interne Integrationen, Skripte	Hoch (sicher speichern)
OAuth 2.0	Multi-Tenant-Apps, Client-Integrationen	Höher (benutzerbezogene Tokens)

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

1. Einstellungen > Entwicklereinstellungen
2. API-Schlüssel erstellen klicken
3. Schlüssel 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)

1. Einstellungen > Entwicklereinstellungen > OAuth-Apps
2. OAuth-App erstellen klicken
3. Umleitungs-URI konfigurieren
4. Client-ID und Secret speichern

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;

// Erzeuge Authorisierungs-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

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

    // Tokens sicher speichern
    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

Erstelle einen wiederverwendbaren API-Client:

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

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

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

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
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: 'Webhook-Leads mit Salesforce synchronisieren'
});

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

Szenario aktualisieren

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

  return response;
};

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

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

Szenario löschen

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

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

Ausführungsverwaltung

Szenario-Ausführung auslösen

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

  return response;
};

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

// Mit Eingabedaten ausführen
const executionWithData = await executeScenario('12345', {
  lead: {
    email: '[e-mail]',
    name: 'John Doe',
    company: 'Acme Corp'
  }
});

Ausführungsverlauf 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;
};

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

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

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

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

Webhook-Verwaltung

Webhook erstellen

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

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

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

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

Team- und Benutzerverwaltung

Teammitglieder auflisten

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

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', '[e-mail]', 'builder');

Benutzerrolle aktualisieren

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

Rolle	Berechtigungen
Betrachter	Szenarien anzeigen, keine Bearbeitung
Ersteller	Szenarien erstellen/bearbeiten
Manager	Team, Abrechnung verwalten
Administrator	Voller Organisationszugriff

Ratenbegrenzung

Ratenbegrenzungen verstehen

Plan	Anfragen/Minute	Burst-Limit
Kostenlos	60	100
Core	120	200
Pro	300	500
Teams	600	1000
Enterprise	Benutzerdefiniert	Benutzerdefiniert

Ratenbegrenzung-Header

Header	Beschreibung
X-RateLimit-Limit	Max. Anfragen pro Minute
X-RateLimit-Remaining	Verbleibende Anfragen
X-RateLimit-Reset	Sekunden bis zum Reset

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 dem Go-Live:

• [ ] 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

Wichtige Implementierungsschritte:

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

E-Commerce-Auftragsabwicklung

Ein Online-Shop automatisiert die Auftragsabwicklung:

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

Wichtige Implementierungsschritte:

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

Fazit

Die Make API bietet umfangreiche Möglichkeiten für Workflow-Automatisierung. Wichtige Aspekte:

• API-Schlüssel für interne Nutzung, OAuth 2.0 für Multi-Tenant-Apps
• Vollständige CRUD-Operationen für Szenarien, Ausführungen, Webhooks
• Team-Management für Organisationskontrolle
• Ratenbegrenzungen je nach Plan (60–600 Anfragen/Minute)
• Ausführungsüberwachung ist essentiell für die Produktion
• Apidog optimiert API-Tests und die Zusammenarbeit im Team

Wie authentifiziere ich mich bei der Make API?

Verwende 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, nutze den Endpunkt /scenarios/{id}/execute, um Szenarioläufe manuell mit optionalen Eingabedaten zu starten.

Was sind die Make-Ratenbegrenzungen?

Die Limits liegen zwischen 60 Anfragen/Minute (Kostenlos) und 600 Anfragen/Minute (Teams/Enterprise).

Wie erhalte ich Ausführungsprotokolle?

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

Kann ich Webhooks über die API erstellen?

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