DEV Community

Cover image for Como Usar a API do Make (Integromat)?
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Usar a API do Make (Integromat)?

#api #automation #productivity #tutorial

TL;DR

A API do Make (antigo Integromat) permite automatizar fluxos de trabalho, gerenciar cenários e executar integrações programaticamente. Suporta 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/minuto conforme o plano. Este guia é prático: configure autenticação, gerencie cenários, gatilhe webhooks, monitore execuções e automatize operações em produção.

Experimente o Apidog hoje

Introdução

Make (Integromat) processa mais de 2 bilhões de operações mensais para mais de 1 milhão de usuários. Se você desenvolve ferramentas de automação, gerencia fluxos de clientes ou integra com mais de 1000 apps, usar a API do Make é essencial para automação escalável.

Agências com dezenas de automações gastam 15–25 horas semanais em tarefas manuais como atualização de cenários, monitoramento e relatórios. Integrar a API do Make automatiza implantação de cenários, rastreamento, tratamento de erros e relatórios white-label.

Veja neste guia como autenticar (OAuth e chave de API), manipular cenários, usar webhooks, monitorar execuções, gerenciar equipes e implantar automações em produção.

💡 Dica: O Apidog facilita testes de integração de API. Teste endpoints do Make, valide fluxos OAuth, inspecione respostas e depure tudo em um só workspace. Importe specs, simule respostas, compartilhe cenários de teste.

O Que É a API do Make?

A API RESTful do Make permite gerenciar fluxos de automação via código:

  • CRUD de cenários
  • Execução manual de cenários
  • Histórico e monitoramento de execuções
  • Gerenciamento de webhooks
  • Gerenciamento de equipes/usuários
  • Administração de conexões e apps
  • Configuração de organização/workspace

Principais Recursos

Recurso Descrição
API RESTful Endpoints baseados em JSON
OAuth 2.0 + Chaves de API Autenticação flexível
Webhooks Notificações de execução em tempo real
Limite de Taxa 60-600 requisições/minuto por plano
Gerenciamento de Cenários Operações CRUD completas
Controle de Execução Iniciar, parar, monitorar execuções
API de Equipe Gerenciamento de usuários e permissões

Planos do Make e Acesso à API

Plano Acesso à API Limite de Taxa Melhor para
Gratuito Limitado 60/min Testes, aprendizado
Core API Completa 120/min Pequenas empresas
Pro API Completa + Prioridade 300/min Equipes em crescimento
Equipes API Completa + Admin 600/min Agências, empresas
Enterprise Limites Personalizados Personalizado Grandes organizações

Visão Geral da Arquitetura da API

A base da API é:

https://api.make.com/api/v2/
Enter fullscreen mode Exit fullscreen mode

Versões da API

Versão Status Caso de Uso
v2 Atual Todas as novas integrações
v1 Obsoleto Integrações legadas (migrar)

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

Passo 1: Criar Conta no Make

  1. Acesse Make.com
  2. Cadastre-se
  3. Vá para Settings > Developer settings
  4. Gere credenciais de API

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

Método Melhor para Nível de Segurança
Chave de API Integrações internas, scripts Alto (armazenar com segurança)
OAuth 2.0 Aplicativos multi-tenant, integrações de cliente Mais Alto (tokens com escopo de usuário)

Passo 3: Obter Chave de API (Mais Simples)

  1. Em Settings > Developer settings
  2. Clique em Create API key
  3. Copie e armazene no seu .env 
# .env file
MAKE_API_KEY="sua_chave_api_aqui"
MAKE_ORGANIZATION_ID="seu_id_org"
Enter fullscreen mode Exit fullscreen mode

Passo 4: Configurar OAuth 2.0 (Multi-Tenant)

  1. Em Settings > Developer settings > OAuth apps
  2. Clique em Create OAuth app
  3. Informe o URI de redirecionamento
  4. Salve as credenciais 
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;

// Monta a URL de autorização
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()}`;
};
Enter fullscreen mode Exit fullscreen mode

Passo 5: Trocar Código por Token de Acesso 

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 para OAuth
app.get('/oauth/callback', async (req, res) => {
  const { code, state } = req.query;

  try {
    const tokens = await exchangeCodeForToken(code);

    // Armazene os tokens de forma segura
    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');
  }
});
Enter fullscreen mode Exit fullscreen mode

Passo 6: Fazer Chamadas de API Autenticadas 

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

// Exemplo de uso
const scenarios = await makeRequest('/scenarios');
console.log(`Found ${scenarios.data.length} scenarios`);
Enter fullscreen mode Exit fullscreen mode

Gerenciamento de Cenários

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

// Exemplo
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'}`);
});
Enter fullscreen mode Exit fullscreen mode

Obtendo Detalhes do Cenário 

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

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

Criando um Cenário 

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

// Exemplo
const newScenario = await createScenario({
  name: 'Sincronização de Leads para 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: 'Sincronizar leads do webhook para o Salesforce'
});

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

Atualizando um Cenário 

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

  return response;
};

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

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

Excluindo um Cenário 

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

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

Gerenciamento de Execução

Acionando a Execução do Cenário 

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

  return response;
};

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

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

Obtendo Histórico 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;
};

// Execuções falhas das últimas 24h
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}`);
});
Enter fullscreen mode Exit fullscreen mode

Obtendo Detalhes da Execução 

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

// Exemplo
const execution = await getExecution('98765');
console.log(`Status: ${execution.status}`);
console.log(`Duração: ${execution.duration}ms`);
console.log(`Módulos executados: ${execution.modulesExecuted}`);
Enter fullscreen mode Exit fullscreen mode

Parando uma Execução em Andamento 

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

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

Gerenciamento de Webhooks

Criando Webhook 

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

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

  return response;
};

// Exemplo
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}`);
Enter fullscreen mode Exit fullscreen mode

Listando Webhooks 

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

// Exemplo
const webhooks = await listWebhooks();
webhooks.data.forEach(webhook => {
  console.log(`${webhook.name}: ${webhook.url}`);
});
Enter fullscreen mode Exit fullscreen mode

Excluindo Webhook 

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

  console.log(`Webhook ${webhookId} excluído`);
};
Enter fullscreen mode Exit fullscreen mode

Gerenciamento de Equipe e Usuários

Listando Membros da Equipe 

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

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

Adicionando Membro da Equipe 

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

// Exemplo
await addTeamMember('org-123', 'newuser@example.com', 'builder');
Enter fullscreen mode Exit fullscreen mode

Atualizando Função 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}`);
};
Enter fullscreen mode Exit fullscreen mode

Funções de Usuário

Função Permissões
Viewer Visualizar cenários, sem edições
Builder Criar/editar cenários
Manager Gerenciar equipe, faturamento
Admin Acesso total à organização

Limite de Taxa

Compreendendo os Limites de Taxa

Plano Requisições/Minuto Limite de Rajada
Gratuito 60 100
Core 120 200
Pro 300 500
Equipes 600 1000
Enterprise Personalizado Personalizado

Cabeçalhos de Limite de Taxa

Cabeçalho Descrição
X-RateLimit-Limit Máximo de requisições por minuto
X-RateLimit-Remaining Requisições restantes
X-RateLimit-Reset Segundos até o reset

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;
      }
    }
  }
};
Enter fullscreen mode Exit fullscreen mode

Checklist de Implantação em Produção

Antes de rodar para clientes, valide:

  • [ ] Use chave de API para uso interno, OAuth para integrações de cliente
  • [ ] Armazene credenciais em banco criptografado
  • [ ] Implemente controle de limite de taxa e enfileiramento
  • [ ] Monitore execuções e configure alertas
  • [ ] Notificações de erro (e-mail, Slack)
  • [ ] Lógica de repetição para execuções falhas
  • [ ] Logging detalhado
  • [ ] Backup/exportação de cenários críticos

Casos de Uso no Mundo Real

Gerenciamento de Clientes de Agência

Cenário: agência de marketing com 100+ automações de clientes.

  • Desafio: Atualização manual de cenários
  • Solução: Dashboard centralizado usando API do Make
  • Resultado: 70% menos tempo gasto, implantação padronizada

Implementação:

  • Integração OAuth multi-conta
  • Deploy em massa de cenários
  • Relatórios de uso automático

Processamento de Pedidos de E-commerce

Cenário: loja online automatizando fulfillment.

  • Desafio: Input manual de pedidos no armazém
  • Solução: Cenário Make disparado por Webhook
  • Resultado: Zero input manual, 99,9% de precisão

Implementação:

  • Webhook do Shopify → Make
  • Make processa pedido e atualiza armazém
  • Tratamento de erro com retry

Conclusão

A API do Make oferece base sólida para automação robusta:

  • Chave de API para uso interno, OAuth 2.0 para multi-tenant
  • CRUD completo de cenários, execuções e webhooks
  • Gerenciamento de equipes e permissões
  • Limites de taxa por plano (60-600 req/min)
  • Monitoramento de execução essencial para produção
  • Apidog acelera testes e colaboração em APIs

FAQ

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 execuções com dados de entrada opcionais.

Quais são os limites de taxa do Make?

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 histórico de execução filtrando por data/status.

Posso criar webhooks via API?

Sim, utilize o endpoint /webhooks para criar, listar ou excluir webhooks vinculados a cenários.

Top comments (0)