Cách Sử Dụng API Make (Integromat)

TÓM TẮT

API của Make (trước đây là Integromat) cho phép các nhà phát triển tự động hóa quy trình làm việc, quản lý các kịch bản (scenarios) và thực hiện các tích hợp theo chương trình. Nó sử dụng xác thực OAuth 2.0 và khóa API, các điểm cuối (endpoints) RESTful cho các kịch bản, thực thi, webhook và nhóm, với giới hạn tốc độ từ 60-600 yêu cầu mỗi phút tùy thuộc vào gói dịch vụ. Hướng dẫn này bao gồm thiết lập xác thực, quản lý kịch bản, kích hoạt webhook, giám sát thực thi và các chiến lược tự động hóa sản xuất.

Giới thiệu

Make (Integromat) xử lý hơn 2 tỷ hoạt động hàng tháng cho hơn 1 triệu người dùng trên 100+ quốc gia. Đối với các nhà phát triển xây dựng công cụ tự động hóa, quản lý quy trình làm việc của khách hàng hoặc tích hợp với hơn 1000 ứng dụng, tích hợp API của Make không phải là tùy chọn — nó là thiết yếu để tự động hóa có khả năng mở rộng.

Thực tế là: các agency quản lý hơn 50 tự động hóa của khách hàng mất 15-25 giờ mỗi tuần cho việc cập nhật kịch bản thủ công, giám sát thực thi và báo cáo cho khách hàng. Một tích hợp API Make vững chắc sẽ tự động hóa việc triển khai kịch bản, theo dõi thực thi, xử lý lỗi và báo cáo nhãn trắng (white-label reporting).

Hướng dẫn này sẽ chỉ cho bạn toàn bộ quy trình tích hợp API của Make. Bạn sẽ tìm hiểu về xác thực OAuth 2.0 và khóa API, quản lý kịch bản, kích hoạt webhook, giám sát thực thi, quản lý nhóm và các chiến lược triển khai sản xuất. Đến cuối cùng, bạn sẽ có một tích hợp Make sẵn sàng cho sản xuất.

Make API là gì?

Make cung cấp một API RESTful để quản lý các quy trình làm việc tự động theo chương trình. API xử lý:

• Tạo, cập nhật và xóa kịch bản
• Thực thi kịch bản (kích hoạt thủ công)
• Lịch sử và giám sát thực thi
• Quản lý Webhook
• Quản lý nhóm và người dùng
• Quản lý kết nối và ứng dụng
• Cài đặt tổ chức và không gian làm việc

Các tính năng chính

Các gói dịch vụ Make và quyền truy cập API

Tổng quan kiến trúc API

Make sử dụng cấu trúc API RESTful:

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

Các phiên bản API

Bắt đầu: Thiết lập xác thực

Bước 1: Tạo tài khoản Make

Trước khi truy cập API:

1. Truy cập Make.com
2. Đăng ký tài khoản
3. Điều hướng đến Settings > Developer settings
4. Tạo thông tin xác thực API

Bước 2: Chọn phương thức xác thực

Make hỗ trợ hai phương thức xác thực:

Bước 3: Lấy khóa API (Phương thức đơn giản nhất)

Tạo khóa API để sử dụng nội bộ:

1. Đi tới Settings > Developer settings
2. Nhấp vào Create API key
3. Sao chép và lưu trữ an toàn

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

Bước 4: Thiết lập OAuth 2.0 (Đối với ứng dụng đa người thuê)

Cấu hình OAuth cho tích hợp với khách hàng:

1. Đi tới Settings > Developer settings > OAuth apps
2. Nhấp vào Create OAuth app
3. Cấu hình URI chuyển hướng (redirect URI)
4. Lấy thông tin xác thực client (client credentials)

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

Bước 5: Trao đổi mã để lấy mã truy cập (Access Token)

Xử lý callback 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');
  }
});

Bước 6: Thực hiện các cuộc gọi API đã xác thực

Tạo client API có thể tái sử dụng:

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

Quản lý kịch bản

Liệt kê các kịch bản

Lấy tất cả các kịch bản:

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

Lấy chi tiết kịch bản

Lấy một kịch bản duy nhất:

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

Tạo một kịch bản

Tạo kịch bản mới:

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

Cập nhật một kịch bản

Sửa đổi cấu hình kịch bản:

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

Xóa một kịch bản

Xóa kịch bản:

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

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

Quản lý thực thi

Kích hoạt thực thi kịch bản

Chạy kịch bản thủ công:

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

Lấy lịch sử thực thi

Lấy nhật ký thực thi:

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

Lấy chi tiết thực thi

Lấy một thực thi duy nhất:

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

Dừng thực thi đang chạy

Hủy thực thi:

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

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

Quản lý Webhook

Tạo Webhook

Thiết lập webhook đến:

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

Liệt kê các Webhook

Lấy tất cả các webhook:

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

Xóa Webhook

Xóa webhook:

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

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

Quản lý nhóm và người dùng

Liệt kê các thành viên nhóm

Lấy người dùng trong tổ chức:

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

Thêm thành viên nhóm

Mời người dùng vào tổ chức:

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

Cập nhật vai trò người dùng

Thay đổi quyền người dùng:

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

Các vai trò người dùng

Giới hạn tốc độ

Tìm hiểu giới hạn tốc độ

Make thực thi giới hạn tốc độ theo gói dịch vụ:

Tiêu đề giới hạn tốc độ

Triển khai xử lý giới hạn tốc độ

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

Danh sách kiểm tra triển khai sản xuất

Trước khi đưa vào hoạt động:

• [ ] Sử dụng khóa API cho nội bộ, OAuth cho tích hợp với khách hàng
• [ ] Lưu trữ thông tin xác thực an toàn (cơ sở dữ liệu được mã hóa)
• [ ] Triển khai giới hạn tốc độ và hàng đợi yêu cầu
• [ ] Thiết lập giám sát và cảnh báo thực thi
• [ ] Cấu hình thông báo lỗi (email, Slack)
• [ ] Triển khai logic thử lại cho các thực thi thất bại
• [ ] Thêm ghi nhật ký toàn diện
• [ ] Tạo bản sao lưu/xuất các kịch bản quan trọng

Các trường hợp sử dụng trong thực tế

Quản lý khách hàng của Agency

Một agency marketing quản lý hơn 100 tự động hóa cho khách hàng:

• Thách thức: Cập nhật kịch bản thủ công trên các tài khoản khách hàng
• Giải pháp: Bảng điều khiển trung tâm với Make API
• Kết quả: Tiết kiệm 70% thời gian, triển khai nhất quán

Triển khai chính:

• Tích hợp OAuth đa tài khoản
• Triển khai kịch bản hàng loạt
• Báo cáo sử dụng của khách hàng

Xử lý đơn hàng Thương mại điện tử

Một cửa hàng trực tuyến tự động hóa việc thực hiện đơn hàng:

• Thách thức: Nhập đơn hàng thủ công vào hệ thống kho hàng
• Giải pháp: Kịch bản Make được kích hoạt bằng Webhook
• Kết quả: Không cần nhập liệu thủ công, độ chính xác 99.9%

Triển khai chính:

• Webhook từ Shopify tới Make
• Kịch bản xử lý đơn hàng, cập nhật kho hàng
• Xử lý lỗi với logic thử lại

Kết luận

Make API cung cấp khả năng tự động hóa quy trình làm việc toàn diện. Những điểm chính cần nhớ:

• Khóa API cho sử dụng nội bộ, OAuth 2.0 cho ứng dụng đa người thuê
• Các thao tác CRUD đầy đủ cho kịch bản, thực thi, webhook
• Quản lý nhóm để kiểm soát tổ chức
• Giới hạn tốc độ khác nhau tùy theo gói (60-600 yêu cầu/phút)
• Giám sát thực thi là thiết yếu cho sản xuất
• Apidog đơn giản hóa việc kiểm thử API và cộng tác nhóm

Làm cách nào để xác thực với Make API?

Sử dụng khóa API từ cài đặt Nhà phát triển (Developer settings) cho tích hợp nội bộ, hoặc OAuth 2.0 cho các ứng dụng đa người thuê.

Tôi có thể kích hoạt kịch bản theo chương trình không?

Có, sử dụng điểm cuối /scenarios/{id}/execute để kích hoạt chạy kịch bản thủ công với dữ liệu đầu vào tùy chọn.

Giới hạn tốc độ của Make là gì?

Giới hạn tốc độ dao động từ 60 yêu cầu/phút (Gói miễn phí) đến 600 yêu cầu/phút (Gói Teams/Enterprise).

Làm cách nào để lấy nhật ký thực thi?

Sử dụng /scenarios/{id}/executions để lấy lịch sử thực thi với khả năng lọc theo ngày và trạng thái.

Tôi có thể tạo webhook thông qua API không?

Có, sử dụng điểm cuối /webhooks để tạo, liệt kê và xóa webhook cho các kịch bản.