Make (인테그로마트) API 사용법

TL;DR

Make(이전 Integromat) API를 사용하면 개발자가 워크플로우를 자동화하고, 시나리오를 관리하며, 통합을 프로그래밍 방식으로 실행할 수 있습니다. OAuth 2.0 및 API 키 인증을 사용하며, 시나리오, 실행, 웹훅 및 팀을 위한 RESTful 엔드포인트를 제공합니다. 요금제에 따라 분당 60-600개의 요청으로 제한됩니다. 이 가이드는 인증 설정, 시나리오 관리, 웹훅 트리거, 실행 모니터링 및 프로덕션 자동화 전략을 다룹니다.

소개

Make(Integromat)는 100개 이상의 국가에서 1백만 명 이상의 사용자를 위해 매월 20억 개 이상의 작업을 처리합니다. 자동화 도구를 구축하거나, 클라이언트 워크플로우를 관리하거나, 1000개 이상의 앱과 통합하는 개발자에게 Make API 통합은 선택 사항이 아니라 확장 가능한 자동화를 위해 필수적입니다.

현실은 이렇습니다. 50개 이상의 클라이언트 자동화를 관리하는 에이전시는 수동 시나리오 업데이트, 실행 모니터링 및 클라이언트 보고에 매주 15-25시간을 낭비합니다. 견고한 Make API 통합은 시나리오 배포, 실행 추적, 오류 처리 및 화이트 라벨 보고를 자동화합니다.

이 가이드는 Make API 통합의 전체 프로세스를 안내합니다. OAuth 2.0 및 API 키 인증, 시나리오 관리, 웹훅 트리거, 실행 모니터링, 팀 관리 및 프로덕션 배포 전략을 배우게 됩니다. 이 가이드를 마치면 프로덕션 준비가 된 Make 통합을 갖게 될 것입니다.

Make API란 무엇인가요?

Make는 자동화 워크플로우를 프로그래밍 방식으로 관리하기 위한 RESTful API를 제공합니다. 이 API는 다음을 처리합니다:

• 시나리오 생성, 업데이트 및 삭제
• 시나리오 실행 (수동 트리거링)
• 실행 기록 및 모니터링
• 웹훅 관리
• 팀 및 사용자 관리
• 연결 및 앱 관리
• 조직 및 작업 공간 설정

주요 기능

Make 요금제 및 API 접근

API 아키텍처 개요

Make는 RESTful API 구조를 사용합니다:

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

API 버전

시작하기: 인증 설정

단계 1: Make 계정 생성

API에 접근하기 전에:

1. Make.com 방문
2. 계정 가입
3. 설정 > 개발자 설정으로 이동
4. API 자격 증명 생성

단계 2: 인증 방법 선택

Make는 두 가지 인증 방법을 지원합니다:

단계 3: API 키 가져오기 (가장 간단한 방법)

내부 사용을 위한 API 키 생성:

1. 설정 > 개발자 설정으로 이동
2. API 키 생성 클릭
3. 복사하여 안전하게 저장

# .env 파일
MAKE_API_KEY="여기에_당신의_api_키"
MAKE_ORGANIZATION_ID="당신의_조직_ID"

단계 4: OAuth 2.0 설정 (멀티테넌트 앱용)

클라이언트 통합을 위한 OAuth 구성:

1. 설정 > 개발자 설정 > OAuth 앱으로 이동
2. OAuth 앱 생성 클릭
3. 리다이렉트 URI 구성
4. 클라이언트 자격 증명 가져오기

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;

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

단계 5: 코드를 액세스 토큰으로 교환

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

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

  try {
    const tokens = await exchangeCodeForToken(code);

    // 토큰을 안전하게 저장
    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);
    res.status(500).send('인증 실패');
  }
});

단계 6: 인증된 API 호출 수행

재사용 가능한 API 클라이언트 생성:

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

  return response.json();
};

// 사용 예시
const scenarios = await makeRequest('/scenarios');
console.log(`발견된 시나리오 수: ${scenarios.data.length}`);

시나리오 관리

시나리오 목록

모든 시나리오 가져오기:

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

// 사용 예시
const scenarios = await listScenarios({ limit: 100 });
scenarios.data.forEach(scenario => {
  console.log(`${scenario.name} - ${scenario.active ? '활성' : '일시 중지됨'}`);
  console.log(`  마지막 실행: ${scenario.lastRunDate || '없음'}`);
});

시나리오 세부 정보 가져오기

단일 시나리오 가져오기:

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

// 사용 예시
const scenario = await getScenario('12345');
console.log(`이름: ${scenario.name}`);
console.log(`모듈: ${scenario.modules.length}`);
console.log(`스케줄: ${scenario.schedule?.cronExpression || '수동'}`);

시나리오 생성

새 시나리오 생성:

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

// 사용 예시 - 청사진으로부터 생성
const newScenario = await createScenario({
  name: '리드 CRM 동기화',
  blueprint: {
    // 시나리오 청사진 JSON
    // Make 에디터에서 내보내거나 프로그래밍 방식으로 구축
    modules: [
      {
        id: 1,
        app: 'webhooks',
        action: 'customWebhook',
        parameters: { /* ... */ }
      },
      {
        id: 2,
        app: 'salesforce',
        action: 'createRecord',
        parameters: { /* ... */ }
      }
    ],
    connections: [
      { from: 1, to: 2 }
    ]
  },
  active: true,
  description: '웹훅 리드를 Salesforce로 동기화합니다'
});

console.log(`시나리오 생성됨: ${newScenario.id}`);

시나리오 업데이트

시나리오 구성 수정:

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

  return response;
};

// 사용 예시 - 시나리오 일시 중지
await updateScenario('12345', { active: false });

// 사용 예시 - 스케줄 업데이트
await updateScenario('12345', {
  schedule: {
    cronExpression: '0 */6 * * *', // 6시간마다
    timezone: 'America/New_York'
  }
});

시나리오 삭제

시나리오 제거:

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

  console.log(`시나리오 ${scenarioId} 삭제됨`);
};

실행 관리

시나리오 실행 트리거링

수동으로 시나리오 실행:

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

  return response;
};

// 사용 예시 - 입력 없이 실행
const execution = await executeScenario('12345');
console.log(`실행 시작됨: ${execution.id}`);

// 사용 예시 - 입력 데이터로 실행
const executionWithData = await executeScenario('12345', {
  lead: {
    email: 'prospect@example.com',
    name: '존 도',
    company: '아크메 법인'
  }
});

실행 기록 가져오기

실행 로그 가져오기:

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

// 사용 예시 - 지난 24시간 동안 실패한 실행 가져오기
const failedExecutions = await getExecutionHistory('12345', {
  from: new Date(Date.now() - 86400000).toISOString(),
  status: 'error',
  limit: 100
});

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

실행 세부 정보 가져오기

단일 실행 가져오기:

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

// 사용 예시
const execution = await getExecution('98765');
console.log(`상태: ${execution.status}`);
console.log(`기간: ${execution.duration}ms`);
console.log(`실행된 모듈: ${execution.modulesExecuted}`);

실행 중인 실행 중지

실행 취소:

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

  console.log(`실행 ${executionId} 중지됨`);
};

웹훅 관리

웹훅 생성

수신 웹훅 설정:

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

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

  return response;
};

// 사용 예시
const webhook = await createWebhook({
  name: '리드 캡처 웹훅',
  scenarioId: '12345',
  type: 'custom',
  hookType: 'HEAD',
  security: { type: 'none' }
});

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

웹훅 목록

모든 웹훅 가져오기:

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

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

웹훅 삭제

웹훅 제거:

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

  console.log(`웹훅 ${webhookId} 삭제됨`);
};

팀 및 사용자 관리

팀원 목록

조직의 사용자 가져오기:

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

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

팀원 추가

사용자를 조직에 초대:

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

// 사용 예시
await addTeamMember('org-123', 'newuser@example.com', 'builder');

사용자 역할 업데이트

사용자 권한 변경:

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

  console.log(`사용자 ${userId}의 역할이 ${newRole}로 업데이트됨`);
};

사용자 역할

속도 제한

속도 제한 이해하기

Make는 요금제별로 속도 제한을 적용합니다:

속도 제한 헤더

속도 제한 처리 구현

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(`낮은 속도 제한: ${remaining}개 남음`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`속도 제한에 걸렸습니다. ${delay}ms 후 재시도합니다...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

프로덕션 배포 체크리스트

실제 운영 환경으로 전환하기 전에:

• [ ] 내부용으로는 API 키를, 클라이언트 통합용으로는 OAuth를 사용하십시오
• [ ] 자격 증명을 안전하게 저장하십시오 (암호화된 데이터베이스)
• [ ] 속도 제한 및 요청 큐잉을 구현하십시오
• [ ] 실행 모니터링 및 알림을 설정하십시오
• [ ] 오류 알림을 구성하십시오 (이메일, Slack)
• [ ] 실패한 실행에 대한 재시도 로직을 구현하십시오
• [ ] 포괄적인 로깅을 추가하십시오
• [ ] 중요한 시나리오의 백업/내보내기를 생성하십시오

실제 사용 사례

에이전시 클라이언트 관리

마케팅 에이전시가 100개 이상의 클라이언트 자동화를 관리합니다:

• 과제: 클라이언트 계정 전반에 걸친 수동 시나리오 업데이트
• 해결책: Make API를 사용하는 중앙 대시보드
• 결과: 70% 시간 절약, 일관된 배포

핵심 구현:

• 다중 계정 OAuth 통합
• 대량 시나리오 배포
• 클라이언트 사용량 보고

전자상거래 주문 처리

온라인 상점이 주문 처리 과정을 자동화합니다:

• 과제: 창고 시스템으로의 수동 주문 입력
• 해결책: 웹훅 트리거 Make 시나리오
• 결과: 수동 입력 제로, 99.9% 정확성

핵심 구현:

• Shopify 웹훅을 Make로 연결
• 시나리오가 주문을 처리하고 창고를 업데이트
• 재시도 로직을 통한 오류 처리

결론

Make API는 포괄적인 워크플로우 자동화 기능을 제공합니다. 핵심 요점:

• 내부용으로는 API 키를, 멀티테넌트 앱용으로는 OAuth 2.0을 사용합니다
• 시나리오, 실행, 웹훅에 대한 전체 CRUD를 지원합니다
• 조직 제어를 위한 팀 관리
• 속도 제한은 요금제에 따라 다릅니다 (분당 60-600 요청)
• 프로덕션을 위해서는 실행 모니터링이 필수적입니다
• Apidog는 API 테스트 및 팀 협업을 간소화합니다

Make API로 어떻게 인증하나요?

내부 통합을 위해서는 개발자 설정에서 API 키를 사용하거나, 멀티테넌트 애플리케이션을 위해서는 OAuth 2.0을 사용하십시오.

시나리오를 프로그래밍 방식으로 트리거할 수 있나요?

예, /scenarios/{id}/execute 엔드포인트를 사용하여 선택적 입력 데이터로 시나리오 실행을 수동으로 트리거할 수 있습니다.

Make의 속도 제한은 무엇인가요?

속도 제한은 분당 60회 요청(무료)에서 분당 600회 요청(Teams/Enterprise)까지 다양합니다.

실행 로그를 어떻게 얻나요?

/scenarios/{id}/executions를 사용하여 날짜 및 상태별 필터링을 통해 실행 기록을 가져올 수 있습니다.

API를 통해 웹훅을 생성할 수 있나요?

예, /webhooks 엔드포인트를 사용하여 시나리오에 대한 웹훅을 생성, 목록화 및 삭제할 수 있습니다.