Como Usar a API do Make (Integromat)?

TL;DR

A API do Make (anteriormente Integromat) permite que desenvolvedores automatizem fluxos de trabalho, gerenciem cenários e executem integrações programaticamente. Ela utiliza autenticação OAuth 2.0 e chave de API, endpoints RESTful para cenários, execuções, webhooks e equipes, com limites de taxa de 60 a 600 requisições por minuto, dependendo do plano. Este guia aborda a configuração de autenticação, gerenciamento de cenários, gatilhos de webhook, monitoramento de execução e estratégias de automação em produção.

Introdução

Make (Integromat) processa mais de 2 bilhões de operações mensalmente para mais de 1 milhão de usuários em mais de 100 países. Para desenvolvedores que constroem ferramentas de automação, gerenciam fluxos de trabalho de clientes ou integram com mais de 1000 aplicativos, a integração com a API do Make não é opcional—é essencial para uma automação escalável.

Aqui está a realidade: agências que gerenciam mais de 50 automações de clientes perdem de 15 a 25 horas semanais em atualizações manuais de cenários, monitoramento de execução e relatórios de clientes. Uma sólida integração com a API do Make automatiza a implantação de cenários, o rastreamento de execução, o tratamento de erros e a emissão de relatórios white-label.

Este guia descreve o processo completo de integração com a API do Make. Você aprenderá sobre a autenticação OAuth 2.0 e chave de API, gerenciamento de cenários, gatilhos de webhook, monitoramento de execução, gerenciamento de equipes e estratégias de implantação em produção. Ao final, você terá uma integração com o Make pronta para produção.

O Que É a API do Make?

Make fornece uma API RESTful para gerenciar fluxos de trabalho de automação programaticamente. A API lida com:

• Criação, atualização e exclusão de cenários
• Execução de cenários (gatilho manual)
• Histórico e monitoramento de execução
• Gerenciamento de webhooks
• Gerenciamento de equipes e usuários
• Gerenciamento de conexões e aplicativos
• Configurações de organização e workspace

Principais Recursos

Planos do Make e Acesso à API

Visão Geral da Arquitetura da API

Make utiliza uma estrutura de API RESTful:

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

Versões da API

Primeiros Passos: Configuração de Autenticação

Passo 1: Criar Conta no Make

Antes de acessar a API:

1. Visite Make.com
2. Cadastre-se para uma conta
3. Navegue até Settings (Configurações) > Developer settings (Configurações do Desenvolvedor)
4. Gere credenciais de API

Passo 2: Escolher Método de Autenticação

Make suporta dois métodos de autenticação:

Passo 3: Obter Chave de API (Método Mais Simples)

Gere uma chave de API para uso interno:

1. Vá para Settings (Configurações) > Developer settings (Configurações do Desenvolvedor)
2. Clique em Create API key (Criar chave de API)
3. Copie e armazene com segurança

# .env file
MAKE_API_KEY="sua_chave_api_aqui"
MAKE_ORGANIZATION_ID="seu_id_org"

Passo 4: Configurar OAuth 2.0 (Para Aplicativos Multi-Tenant)

Configure OAuth para integrações de cliente:

1. Vá para Settings (Configurações) > Developer settings (Configurações do Desenvolvedor) > OAuth apps (Aplicativos OAuth)
2. Clique em Create OAuth app (Criar aplicativo OAuth)
3. Configure o URI de redirecionamento
4. Obtenha as credenciais do cliente

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

Passo 5: Trocar Código por Token de Acesso

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

Passo 6: Fazer Chamadas de API Autenticadas

Crie um cliente de API reutilizável:

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

Gerenciamento de Cenários

Listando Cenários

Buscar todos os cenários:

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 ? 'Ativo' : 'Pausado'}`);
  console.log(`  Última execução: ${scenario.lastRunDate || 'Nunca'}`);
});

Obtendo Detalhes do Cenário

Buscar um único cenário:

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

// Usage
const scenario = await getScenario('12345');
console.log(`Nome: ${scenario.name}`);
console.log(`Módulos: ${scenario.modules.length}`);
console.log(`Agendamento: ${scenario.schedule?.cronExpression || 'Manual'}`);

Criando um Cenário

Criar novo cenário:

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: 'Sincronização de Leads para 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: 'Sincronizar leads do webhook para o Salesforce'
});

console.log(`Cenário criado: ${newScenario.id}`);

Atualizando um Cenário

Modificar a configuração do cenário:

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

  return response;
};

// Usage - Pausar cenário
await updateScenario('12345', { active: false });

// Usage - Atualizar agendamento
await updateScenario('12345', {
  schedule: {
    cronExpression: '0 */6 * * *', // A cada 6 horas
    timezone: 'America/New_York'
  }
});

Excluindo um Cenário

Remover cenário:

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

  console.log(`Cenário ${scenarioId} excluído`);
};

Gerenciamento de Execução

Acionando a Execução do Cenário

Executar cenário manualmente:

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

  return response;
};

// Usage - Executar sem entrada
const execution = await executeScenario('12345');
console.log(`Execução iniciada: ${execution.id}`);

// Usage - Executar com dados de entrada
const executionWithData = await executeScenario('12345', {
  lead: {
    email: 'prospect@example.com',
    name: 'John Doe',
    company: 'Acme Corp'
  }
});

Obtendo Histórico de Execução

Buscar logs de execução:

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 - Obter execuções falhas das últimas 24 horas
const failedExecutions = await getExecutionHistory('12345', {
  from: new Date(Date.now() - 86400000).toISOString(),
  status: 'error',
  limit: 100
});

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

Obtendo Detalhes da Execução

Buscar uma única execução:

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(`Duração: ${execution.duration}ms`);
console.log(`Módulos executados: ${execution.modulesExecuted}`);

Parando uma Execução em Andamento

Cancelar execução:

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

  console.log(`Execução ${executionId} parada`);
};

Gerenciamento de Webhooks

Criando Webhook

Configurar webhook de entrada:

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: 'Webhook de Captura de Leads',
  scenarioId: '12345',
  type: 'custom',
  hookType: 'HEAD',
  security: { type: 'none' }
});

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

Listando Webhooks

Buscar todos os webhooks:

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

Excluindo Webhook

Remover webhook:

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

  console.log(`Webhook ${webhookId} excluído`);
};

Gerenciamento de Equipe e Usuários

Listando Membros da Equipe

Buscar usuários na organização:

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

Adicionando Membro da Equipe

Convidar usuário para a organização:

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

Atualizando Função do Usuário

Alterar permissões do usuário:

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

  console.log(`Função do usuário ${userId} atualizada para ${newRole}`);
};

Funções de Usuário

Limite de Taxa

Compreendendo os Limites de Taxa

Make aplica limites de taxa por plano:

Cabeçalhos de Limite de Taxa

Implementando o Tratamento de Limite de Taxa

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(`Baixo limite de taxa: ${remaining} restantes`);
      }

      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Limite de taxa atingido. Tentando novamente em ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

Checklist de Implantação em Produção

Antes de entrar em produção:

• [ ] Use chaves de API para uso interno, OAuth para integrações de cliente
• [ ] Armazene credenciais com segurança (banco de dados criptografado)
• [ ] Implemente limites de taxa e enfileiramento de requisições
• [ ] Configure monitoramento de execução e alertas
• [ ] Configure notificações de erro (e-mail, Slack)
• [ ] Implemente lógica de repetição para execuções falhas
• [ ] Adicione log abrangente
• [ ] Crie backup/exportação de cenários críticos

Casos de Uso no Mundo Real

Gerenciamento de Clientes da Agência

Uma agência de marketing gerencia mais de 100 automações de clientes:

• Desafio: Atualizações manuais de cenários em contas de clientes
• Solução: Dashboard centralizado com a API do Make
• Resultado: 70% de economia de tempo, implantações consistentes

Implementação chave:

• Integração OAuth multi-conta
• Implantação de cenários em massa
• Relatórios de uso do cliente

Processamento de Pedidos de E-commerce

Uma loja online automatiza o cumprimento de pedidos:

• Desafio: Entrada manual de pedidos no sistema do armazém
• Solução: Cenário do Make acionado por Webhook
• Resultado: Zero entrada manual, 99,9% de precisão

Implementação chave:

• Webhook do Shopify para o Make
• Cenário processa o pedido, atualiza o armazém
• Tratamento de erros com lógica de repetição

Conclusão

A API do Make oferece capacidades abrangentes de automação de fluxo de trabalho. Principais pontos:

• Chave de API para uso interno, OAuth 2.0 para aplicativos multi-tenant
• CRUD completo para cenários, execuções, webhooks
• Gerenciamento de equipes para controle da organização
• Limites de taxa variam por plano (60-600 requisições/minuto)
• Monitoramento de execução essencial para produção
• Apidog agiliza o teste de API e a colaboração em equipe

Como faço para autenticar com a API do Make?

Use a chave de API das configurações de Desenvolvedor para integrações internas, ou OAuth 2.0 para aplicativos multi-tenant.

Posso acionar cenários programaticamente?

Sim, use o endpoint /scenarios/{id}/execute para acionar manualmente execuções de cenários com dados de entrada opcionais.

Quais são os limites de taxa do Make?

Os limites de taxa variam de 60 requisições/minuto (Gratuito) a 600 requisições/minuto (Equipes/Enterprise).

Como obtenho os logs de execução?

Use /scenarios/{id}/executions para buscar o histórico de execução com filtragem por data e status.

Posso criar webhooks via API?

Sim, use o endpoint /webhooks para criar, listar e excluir webhooks para cenários.