Cara Menggunakan API Make (Integromat): Panduan Lengkap

Intinya

API Make (sebelumnya Integromat) memungkinkan pengembang untuk mengotomatiskan alur kerja, mengelola skenario, dan mengeksekusi integrasi secara terprogram. Ini menggunakan otentikasi OAuth 2.0 dan kunci API, titik akhir RESTful untuk skenario, eksekusi, webhook, dan tim, dengan batas kecepatan 60-600 permintaan per menit tergantung pada paket. Panduan ini mencakup pengaturan otentikasi, manajemen skenario, pemicu webhook, pemantauan eksekusi, dan strategi otomatisasi produksi.

Pendahuluan

Make (Integromat) memproses lebih dari 2 miliar operasi setiap bulan untuk 1+ juta pengguna di 100+ negara. Bagi pengembang yang membangun alat otomatisasi, mengelola alur kerja klien, atau berintegrasi dengan 1000+ aplikasi, integrasi Make API bukanlah pilihan—ini penting untuk otomatisasi yang skalabel.

Inilah kenyataannya: agensi yang mengelola 50+ otomatisasi klien kehilangan 15-25 jam setiap minggu untuk pembaruan skenario manual, pemantauan eksekusi, dan pelaporan klien. Integrasi Make API yang solid mengotomatiskan penerapan skenario, pelacakan eksekusi, penanganan kesalahan, dan pelaporan label putih.

Panduan ini membahas proses integrasi Make API secara lengkap. Anda akan mempelajari otentikasi OAuth 2.0 dan kunci API, manajemen skenario, pemicu webhook, pemantauan eksekusi, manajemen tim, dan strategi penerapan produksi. Pada akhirnya, Anda akan memiliki integrasi Make yang siap produksi.

Apa Itu Make API?

Make menyediakan API RESTful untuk mengelola alur kerja otomatisasi secara terprogram. API ini menangani:

• Pembuatan, pembaruan, dan penghapusan skenario
• Eksekusi skenario (pemicuan manual)
• Riwayat dan pemantauan eksekusi
• Manajemen webhook
• Manajemen tim dan pengguna
• Manajemen koneksi dan aplikasi
• Pengaturan organisasi dan ruang kerja

Fitur Utama

Paket Make dan Akses API

Ikhtisar Arsitektur API

Make menggunakan struktur API RESTful:

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

Versi API

Memulai: Pengaturan Otentikasi

Langkah 1: Membuat Akun Make

Sebelum mengakses API:

1. Kunjungi Make.com
2. Daftar untuk akun
3. Navigasi ke Settings > Developer settings
4. Hasilkan kredensial API

Langkah 2: Memilih Metode Otentikasi

Make mendukung dua metode otentikasi:

Langkah 3: Mendapatkan Kunci API (Metode Termudah)

Hasilkan kunci API untuk penggunaan internal:

1. Pergi ke Settings > Developer settings
2. Klik Create API key
3. Salin dan simpan dengan aman

# file .env
MAKE_API_KEY="kunci_api_anda_di_sini"
MAKE_ORGANIZATION_ID="id_organisasi_anda"

Langkah 4: Mengatur OAuth 2.0 (Untuk Aplikasi Multi-Tenant)

Konfigurasi OAuth untuk integrasi klien:

1. Pergi ke Settings > Developer settings > OAuth apps
2. Klik Create OAuth app
3. Konfigurasi URI pengalihan
4. Dapatkan kredensial klien

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;

// Bangun URL otorisasi
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()}`;
};

Langkah 5: Menukar Kode untuk Token Akses

Tangani panggilan balik 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
  };
};

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

  try {
    const tokens = await exchangeCodeForToken(code);

    // Simpan token dengan aman
    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');
  }
});

Langkah 6: Melakukan Panggilan API yang Terotentikasi

Buat klien API yang dapat digunakan kembali:

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

// Penggunaan
const scenarios = await makeRequest('/scenarios');
console.log(`Ditemukan ${scenarios.data.length} skenario`);

Manajemen Skenario

Mendaftar Skenario

Ambil semua skenario:

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

// Penggunaan
const scenarios = await listScenarios({ limit: 100 });
scenarios.data.forEach(scenario => {
  console.log(`${scenario.name} - ${scenario.active ? 'Aktif' : 'Dijeda'}`);
  console.log(`  Jalankan terakhir: ${scenario.lastRunDate || 'Tidak Pernah'}`);
});

Mendapatkan Detail Skenario

Ambil satu skenario:

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

// Penggunaan
const scenario = await getScenario('12345');
console.log(`Nama: ${scenario.name}`);
console.log(`Modul: ${scenario.modules.length}`);
console.log(`Jadwal: ${scenario.schedule?.cronExpression || 'Manual'}`);

Membuat Skenario

Buat skenario baru:

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

// Penggunaan - Buat dari cetak biru
const newScenario = await createScenario({
  name: 'Sinkronisasi Prospek ke CRM',
  blueprint: {
    // Skenario cetak biru JSON
    // Ekspor dari editor Make atau bangun secara terprogram
    modules: [
      {
        id: 1,
        app: 'webhooks',
        action: 'customWebhook',
        parameters: { /* ... */ }
      },
      {
        id: 2,
        app: 'salesforce',
        action: 'createRecord',
        parameters: { /* ... */ }
      }
    ],
    connections: [
      { from: 1, to: 2 }
    ]
  },
  active: true,
  description: 'Sinkronkan prospek webhook ke Salesforce'
});

console.log(`Skenario dibuat: ${newScenario.id}`);

Memperbarui Skenario

Modifikasi konfigurasi skenario:

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

  return response;
};

// Penggunaan - Jeda skenario
await updateScenario('12345', { active: false });

// Penggunaan - Perbarui jadwal
await updateScenario('12345', {
  schedule: {
    cronExpression: '0 */6 * * *', // Setiap 6 jam
    timezone: 'America/New_York'
  }
});

Menghapus Skenario

Hapus skenario:

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

  console.log(`Skenario ${scenarioId} dihapus`);
};

Manajemen Eksekusi

Memicu Eksekusi Skenario

Jalankan skenario secara manual:

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

  return response;
};

// Penggunaan - Jalankan tanpa input
const execution = await executeScenario('12345');
console.log(`Eksekusi dimulai: ${execution.id}`);

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

Mendapatkan Riwayat Eksekusi

Ambil log eksekusi:

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

// Penggunaan - Dapatkan eksekusi yang gagal dari 24 jam terakhir
const failedExecutions = await getExecutionHistory('12345', {
  from: new Date(Date.now() - 86400000).toISOString(),
  status: 'error',
  limit: 100
});

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

Mendapatkan Detail Eksekusi

Ambil satu eksekusi:

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

// Penggunaan
const execution = await getExecution('98765');
console.log(`Status: ${execution.status}`);
console.log(`Durasi: ${execution.duration}ms`);
console.log(`Modul dieksekusi: ${execution.modulesExecuted}`);

Menghentikan Eksekusi yang Berjalan

Batalkan eksekusi:

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

  console.log(`Eksekusi ${executionId} dihentikan`);
};

Manajemen Webhook

Membuat Webhook

Siapkan webhook masuk:

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

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

  return response;
};

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

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

Mendaftar Webhook

Ambil semua webhook:

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

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

Menghapus Webhook

Hapus webhook:

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

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

Manajemen Tim dan Pengguna

Mendaftar Anggota Tim

Ambil pengguna dalam organisasi:

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

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

Menambah Anggota Tim

Undang pengguna ke organisasi:

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

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

Memperbarui Peran Pengguna

Ubah izin pengguna:

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

  console.log(`Peran pengguna ${userId} diperbarui menjadi ${newRole}`);
};

Peran Pengguna

Pembatasan Tingkat (Rate Limiting)

Memahami Pembatasan Tingkat

Make memberlakukan batas tingkat berdasarkan paket:

Header Pembatasan Tingkat

Menerapkan Penanganan Pembatasan Tingkat

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(`Batas tingkat rendah: ${remaining} tersisa`);
      }

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

Daftar Periksa Penerapan Produksi

Sebelum tayang:

• [ ] Gunakan kunci API untuk integrasi internal, OAuth untuk integrasi klien
• [ ] Simpan kredensial dengan aman (database terenkripsi)
• [ ] Terapkan pembatasan tingkat dan antrian permintaan
• [ ] Siapkan pemantauan dan peringatan eksekusi
• [ ] Konfigurasi notifikasi kesalahan (email, Slack)
• [ ] Terapkan logika coba lagi untuk eksekusi yang gagal
• [ ] Tambahkan pencatatan yang komprehensif
• [ ] Buat cadangan/ekspor skenario penting

Studi Kasus Dunia Nyata

Manajemen Klien Agensi

Sebuah agensi pemasaran mengelola 100+ otomatisasi klien:

• Tantangan: Pembaruan skenario manual di seluruh akun klien
• Solusi: Dasbor pusat dengan Make API
• Hasil: Penghematan waktu 70%, penerapan yang konsisten

Implementasi kunci:

• Integrasi OAuth multi-akun
• Penerapan skenario secara massal
• Pelaporan penggunaan klien

Pemrosesan Pesanan E-commerce

Sebuah toko online mengotomatiskan pemenuhan pesanan:

• Tantangan: Entri pesanan manual ke sistem gudang
• Solusi: Skenario Make yang dipicu webhook
• Hasil: Nol entri manual, akurasi 99.9%

Implementasi kunci:

• Webhook Shopify ke Make
• Skenario memproses pesanan, memperbarui gudang
• Penanganan kesalahan dengan logika coba lagi

Kesimpulan

Make API menyediakan kemampuan otomatisasi alur kerja yang komprehensif. Poin-poin penting:

• Kunci API untuk penggunaan internal, OAuth 2.0 untuk aplikasi multi-tenant
• CRUD penuh untuk skenario, eksekusi, webhook
• Manajemen tim untuk kontrol organisasi
• Batas tingkat bervariasi berdasarkan paket (60-600 permintaan/menit)
• Pemantauan eksekusi penting untuk produksi
• Apidog menyederhanakan pengujian API dan kolaborasi tim

Bagaimana cara mengotentikasi dengan Make API?

Gunakan kunci API dari pengaturan Pengembang untuk integrasi internal, atau OAuth 2.0 untuk aplikasi multi-tenant.

Bisakah saya memicu skenario secara terprogram?

Ya, gunakan titik akhir /scenarios/{id}/execute untuk memicu jalankan skenario secara manual dengan data input opsional.

Apa saja batas tingkat Make?

Batas tingkat berkisar dari 60 permintaan/menit (Gratis) hingga 600 permintaan/menit (Tim/Perusahaan).

Bagaimana cara mendapatkan log eksekusi?

Gunakan /scenarios/{id}/executions untuk mengambil riwayat eksekusi dengan pemfilteran berdasarkan tanggal dan status.

Bisakah saya membuat webhook melalui API?

Ya, gunakan titik akhir /webhooks untuk membuat, mendaftar, dan menghapus webhook untuk skenario.